657 lines
18 KiB
C++
657 lines
18 KiB
C++
/*******************************************************************************
|
|
* GIFDEC Wrapper Class
|
|
*
|
|
* Rewrite from: https://github.com/BasementCat/arduino-tft-gif
|
|
******************************************************************************/
|
|
#ifndef _GIFCLASS_H_
|
|
#define _GIFCLASS_H_
|
|
|
|
/* Wio Terminal */
|
|
#if defined(ARDUINO_ARCH_SAMD) && defined(SEEED_GROVE_UI_WIRELESS)
|
|
#include <Seeed_FS.h>
|
|
#elif defined(ESP32) || defined(ESP8266)
|
|
#include <FS.h>
|
|
#else
|
|
#include <SD.h>
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
|
|
#ifndef MIN
|
|
#define MIN(A, B) ((A) < (B) ? (A) : (B))
|
|
#endif
|
|
|
|
#ifndef MAX
|
|
#define MAX(A, B) ((A) > (B) ? (A) : (B))
|
|
#endif
|
|
|
|
#define GIF_BUF_SIZE 1024
|
|
|
|
typedef struct gd_Palette
|
|
{
|
|
int16_t len;
|
|
uint16_t colors[256];
|
|
} gd_Palette;
|
|
|
|
typedef struct gd_GCE
|
|
{
|
|
uint16_t delay;
|
|
uint8_t tindex;
|
|
uint8_t disposal;
|
|
uint8_t input;
|
|
uint8_t transparency;
|
|
} gd_GCE;
|
|
|
|
typedef struct gd_Entry
|
|
{
|
|
int32_t len;
|
|
uint16_t prefix;
|
|
uint8_t suffix;
|
|
} gd_Entry;
|
|
|
|
typedef struct gd_Table
|
|
{
|
|
int16_t bulk;
|
|
int16_t nentries;
|
|
gd_Entry *entries;
|
|
} gd_Table;
|
|
|
|
typedef struct gd_GIF
|
|
{
|
|
File *fd;
|
|
off_t anim_start;
|
|
uint16_t width, height;
|
|
uint16_t depth;
|
|
uint16_t loop_count;
|
|
gd_GCE gce;
|
|
gd_Palette *palette;
|
|
gd_Palette lct, gct;
|
|
void (*plain_text)(
|
|
struct gd_GIF *gif, uint16_t tx, uint16_t ty,
|
|
uint16_t tw, uint16_t th, uint8_t cw, uint8_t ch,
|
|
uint8_t fg, uint8_t bg);
|
|
void (*comment)(struct gd_GIF *gif);
|
|
void (*application)(struct gd_GIF *gif, char id[8], char auth[3]);
|
|
uint16_t fx, fy, fw, fh;
|
|
uint8_t bgindex;
|
|
gd_Table *table;
|
|
bool processed_first_frame;
|
|
} gd_GIF;
|
|
|
|
class GifClass
|
|
{
|
|
public:
|
|
gd_GIF *gd_open_gif(File *fd)
|
|
{
|
|
uint8_t sigver[3];
|
|
uint16_t width, height, depth;
|
|
uint8_t fdsz, bgidx, aspect;
|
|
int16_t gct_sz;
|
|
gd_GIF *gif;
|
|
|
|
// init global variables
|
|
gif_buf_last_idx = GIF_BUF_SIZE;
|
|
gif_buf_idx = gif_buf_last_idx; // no buffer yet
|
|
file_pos = 0;
|
|
|
|
/* Header */
|
|
gif_buf_read(fd, sigver, 3);
|
|
if (memcmp(sigver, "GIF", 3) != 0)
|
|
{
|
|
Serial.println(F("invalid signature"));
|
|
return NULL;
|
|
}
|
|
/* Version */
|
|
gif_buf_read(fd, sigver, 3);
|
|
if (memcmp(sigver, "89a", 3) != 0)
|
|
{
|
|
Serial.println(F("invalid version"));
|
|
return NULL;
|
|
}
|
|
/* Width x Height */
|
|
width = gif_buf_read16(fd);
|
|
height = gif_buf_read16(fd);
|
|
/* FDSZ */
|
|
gif_buf_read(fd, &fdsz, 1);
|
|
/* Presence of GCT */
|
|
if (!(fdsz & 0x80))
|
|
{
|
|
Serial.println(F("no global color table"));
|
|
return NULL;
|
|
}
|
|
/* Color Space's Depth */
|
|
depth = ((fdsz >> 4) & 7) + 1;
|
|
/* Ignore Sort Flag. */
|
|
/* GCT Size */
|
|
gct_sz = 1 << ((fdsz & 0x07) + 1);
|
|
/* Background Color Index */
|
|
gif_buf_read(fd, &bgidx, 1);
|
|
/* Aspect Ratio */
|
|
gif_buf_read(fd, &aspect, 1);
|
|
/* Create gd_GIF Structure. */
|
|
gif = (gd_GIF *)calloc(1, sizeof(*gif));
|
|
gif->fd = fd;
|
|
gif->width = width;
|
|
gif->height = height;
|
|
gif->depth = depth;
|
|
/* Read GCT */
|
|
read_palette(fd, &gif->gct, gct_sz);
|
|
gif->palette = &gif->gct;
|
|
gif->bgindex = bgidx;
|
|
gif->anim_start = file_pos; // fd->position();
|
|
gif->table = new_table();
|
|
gif->processed_first_frame = false;
|
|
return gif;
|
|
}
|
|
|
|
/* Return 1 if got a frame; 0 if got GIF trailer; -1 if error. */
|
|
int32_t gd_get_frame(gd_GIF *gif, uint8_t *frame)
|
|
{
|
|
char sep;
|
|
|
|
while (1)
|
|
{
|
|
gif_buf_read(gif->fd, (uint8_t *)&sep, 1);
|
|
if (sep == 0)
|
|
{
|
|
gif_buf_read(gif->fd, (uint8_t *)&sep, 1);
|
|
}
|
|
if (sep == ',')
|
|
{
|
|
break;
|
|
}
|
|
if (sep == ';')
|
|
{
|
|
return 0;
|
|
}
|
|
if (sep == '!')
|
|
{
|
|
read_ext(gif);
|
|
}
|
|
else
|
|
{
|
|
Serial.print(F("Read sep: ["));
|
|
Serial.print(sep);
|
|
Serial.println(F("].\n"));
|
|
return -1;
|
|
}
|
|
}
|
|
// Serial.println("Do read image");
|
|
if (read_image(gif, frame) == -1)
|
|
return -1;
|
|
return 1;
|
|
}
|
|
|
|
void gd_rewind(gd_GIF *gif)
|
|
{
|
|
#if defined(ESP32) || defined(ESP8266)
|
|
gif->fd->seek(gif->anim_start, SeekSet);
|
|
#else
|
|
gif->fd->seek(gif->anim_start);
|
|
#endif
|
|
file_pos = gif->anim_start;
|
|
gif_buf_idx = gif_buf_last_idx; // reset buffer
|
|
}
|
|
|
|
void gd_close_gif(gd_GIF *gif)
|
|
{
|
|
gif->fd->close();
|
|
free(gif->table);
|
|
free(gif);
|
|
}
|
|
|
|
private:
|
|
bool gif_buf_seek(File *fd, int16_t len)
|
|
{
|
|
if (len > (gif_buf_last_idx - gif_buf_idx))
|
|
{
|
|
#if defined(ESP32) || defined(ESP8266)
|
|
// fd->seek(len - (gif_buf_last_idx - gif_buf_idx), SeekCur);
|
|
fd->seek(file_pos + len - (gif_buf_last_idx - gif_buf_idx), SeekSet);
|
|
#else
|
|
fd->seek(file_pos + len - (gif_buf_last_idx - gif_buf_idx));
|
|
#endif
|
|
|
|
gif_buf_idx = gif_buf_last_idx;
|
|
}
|
|
else
|
|
{
|
|
gif_buf_idx += len;
|
|
}
|
|
file_pos += len;
|
|
|
|
return true;
|
|
}
|
|
|
|
int16_t gif_buf_read(File *fd, uint8_t *dest, int16_t len)
|
|
{
|
|
while (len--)
|
|
{
|
|
if (gif_buf_idx == gif_buf_last_idx)
|
|
{
|
|
gif_buf_last_idx = fd->read(gif_buf, GIF_BUF_SIZE);
|
|
gif_buf_idx = 0;
|
|
}
|
|
|
|
file_pos++;
|
|
*(dest++) = gif_buf[gif_buf_idx++];
|
|
}
|
|
return len;
|
|
}
|
|
|
|
uint8_t gif_buf_read(File *fd)
|
|
{
|
|
if (gif_buf_idx == gif_buf_last_idx)
|
|
{
|
|
gif_buf_last_idx = fd->read(gif_buf, GIF_BUF_SIZE);
|
|
gif_buf_idx = 0;
|
|
}
|
|
|
|
file_pos++;
|
|
return gif_buf[gif_buf_idx++];
|
|
}
|
|
|
|
uint16_t gif_buf_read16(File *fd)
|
|
{
|
|
return gif_buf_read(fd) + (((uint16_t)gif_buf_read(fd)) << 8);
|
|
}
|
|
|
|
void read_palette(File *fd, gd_Palette *dest, int16_t num_colors)
|
|
{
|
|
uint8_t r, g, b;
|
|
dest->len = num_colors;
|
|
for (int16_t i = 0; i < num_colors; i++)
|
|
{
|
|
r = gif_buf_read(fd);
|
|
g = gif_buf_read(fd);
|
|
b = gif_buf_read(fd);
|
|
dest->colors[i] = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3);
|
|
}
|
|
}
|
|
|
|
void discard_sub_blocks(gd_GIF *gif)
|
|
{
|
|
uint8_t len;
|
|
|
|
do
|
|
{
|
|
gif_buf_read(gif->fd, &len, 1);
|
|
gif_buf_seek(gif->fd, len);
|
|
} while (len);
|
|
}
|
|
|
|
void read_plain_text_ext(gd_GIF *gif)
|
|
{
|
|
if (gif->plain_text)
|
|
{
|
|
uint16_t tx, ty, tw, th;
|
|
uint8_t cw, ch, fg, bg;
|
|
gif_buf_seek(gif->fd, 1); /* block size = 12 */
|
|
tx = gif_buf_read16(gif->fd);
|
|
ty = gif_buf_read16(gif->fd);
|
|
tw = gif_buf_read16(gif->fd);
|
|
th = gif_buf_read16(gif->fd);
|
|
cw = gif_buf_read(gif->fd);
|
|
ch = gif_buf_read(gif->fd);
|
|
fg = gif_buf_read(gif->fd);
|
|
bg = gif_buf_read(gif->fd);
|
|
gif->plain_text(gif, tx, ty, tw, th, cw, ch, fg, bg);
|
|
}
|
|
else
|
|
{
|
|
/* Discard plain text metadata. */
|
|
gif_buf_seek(gif->fd, 13);
|
|
}
|
|
/* Discard plain text sub-blocks. */
|
|
discard_sub_blocks(gif);
|
|
}
|
|
|
|
void read_graphic_control_ext(gd_GIF *gif)
|
|
{
|
|
uint8_t rdit;
|
|
|
|
/* Discard block size (always 0x04). */
|
|
gif_buf_seek(gif->fd, 1);
|
|
gif_buf_read(gif->fd, &rdit, 1);
|
|
gif->gce.disposal = (rdit >> 2) & 3;
|
|
gif->gce.input = rdit & 2;
|
|
gif->gce.transparency = rdit & 1;
|
|
gif->gce.delay = gif_buf_read16(gif->fd);
|
|
gif_buf_read(gif->fd, &gif->gce.tindex, 1);
|
|
/* Skip block terminator. */
|
|
gif_buf_seek(gif->fd, 1);
|
|
}
|
|
|
|
void read_comment_ext(gd_GIF *gif)
|
|
{
|
|
if (gif->comment)
|
|
{
|
|
gif->comment(gif);
|
|
}
|
|
/* Discard comment sub-blocks. */
|
|
discard_sub_blocks(gif);
|
|
}
|
|
|
|
void read_application_ext(gd_GIF *gif)
|
|
{
|
|
char app_id[8];
|
|
char app_auth_code[3];
|
|
|
|
/* Discard block size (always 0x0B). */
|
|
gif_buf_seek(gif->fd, 1);
|
|
/* Application Identifier. */
|
|
gif_buf_read(gif->fd, (uint8_t *)app_id, 8);
|
|
/* Application Authentication Code. */
|
|
gif_buf_read(gif->fd, (uint8_t *)app_auth_code, 3);
|
|
if (!strncmp(app_id, "NETSCAPE", sizeof(app_id)))
|
|
{
|
|
/* Discard block size (0x03) and constant byte (0x01). */
|
|
gif_buf_seek(gif->fd, 2);
|
|
gif->loop_count = gif_buf_read16(gif->fd);
|
|
/* Skip block terminator. */
|
|
gif_buf_seek(gif->fd, 1);
|
|
}
|
|
else if (gif->application)
|
|
{
|
|
gif->application(gif, app_id, app_auth_code);
|
|
discard_sub_blocks(gif);
|
|
}
|
|
else
|
|
{
|
|
discard_sub_blocks(gif);
|
|
}
|
|
}
|
|
|
|
void read_ext(gd_GIF *gif)
|
|
{
|
|
uint8_t label;
|
|
|
|
gif_buf_read(gif->fd, &label, 1);
|
|
switch (label)
|
|
{
|
|
case 0x01:
|
|
read_plain_text_ext(gif);
|
|
break;
|
|
case 0xF9:
|
|
read_graphic_control_ext(gif);
|
|
break;
|
|
case 0xFE:
|
|
read_comment_ext(gif);
|
|
break;
|
|
case 0xFF:
|
|
read_application_ext(gif);
|
|
break;
|
|
default:
|
|
Serial.print("unknown extension: ");
|
|
Serial.println(label, HEX);
|
|
}
|
|
}
|
|
|
|
gd_Table *new_table()
|
|
{
|
|
// uint16_t key;
|
|
// int16_t init_bulk = MAX(1 << (key_size + 1), 0x100);
|
|
// Table *table = (Table*) malloc(sizeof(*table) + sizeof(Entry) * init_bulk);
|
|
// if (table) {
|
|
// table->bulk = init_bulk;
|
|
// table->nentries = (1 << key_size) + 2;
|
|
// table->entries = (Entry *) &table[1];
|
|
// for (key = 0; key < (1 << key_size); key++)
|
|
// table->entries[key] = (Entry) {1, 0xFFF, key};
|
|
// }
|
|
// return table;
|
|
int32_t s = sizeof(gd_Table) + (sizeof(gd_Entry) * 4096);
|
|
gd_Table *table = (gd_Table *)malloc(s);
|
|
if (table)
|
|
{
|
|
Serial.print(F("new_table() malloc: "));
|
|
Serial.println(s);
|
|
}
|
|
else
|
|
{
|
|
Serial.print(F("new_table() malloc failed: "));
|
|
Serial.println(s);
|
|
}
|
|
table->entries = (gd_Entry *)&table[1];
|
|
return table;
|
|
}
|
|
|
|
void reset_table(gd_Table *table, uint16_t key_size)
|
|
{
|
|
table->nentries = (1 << key_size) + 2;
|
|
for (uint16_t key = 0; key < (1 << key_size); key++)
|
|
{
|
|
table->entries[key] = (gd_Entry){1, 0xFFF, (uint8_t)key};
|
|
}
|
|
}
|
|
|
|
/* Add table entry. Return value:
|
|
* 0 on success
|
|
* +1 if key size must be incremented after this addition
|
|
* -1 if could not realloc table */
|
|
int32_t add_entry(gd_Table *table, int32_t len, uint16_t prefix, uint8_t suffix)
|
|
{
|
|
// Table *table = *tablep;
|
|
// if (table->nentries == table->bulk) {
|
|
// table->bulk *= 2;
|
|
// table = (Table*) realloc(table, sizeof(*table) + sizeof(Entry) * table->bulk);
|
|
// if (!table) return -1;
|
|
// table->entries = (Entry *) &table[1];
|
|
// *tablep = table;
|
|
// }
|
|
table->entries[table->nentries] = (gd_Entry){len, prefix, suffix};
|
|
table->nentries++;
|
|
if ((table->nentries & (table->nentries - 1)) == 0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
uint16_t get_key(gd_GIF *gif, uint16_t key_size, uint8_t *sub_len, uint8_t *shift, uint8_t *byte)
|
|
{
|
|
int16_t bits_read;
|
|
int16_t rpad;
|
|
int16_t frag_size;
|
|
uint16_t key;
|
|
|
|
key = 0;
|
|
for (bits_read = 0; bits_read < key_size; bits_read += frag_size)
|
|
{
|
|
rpad = (*shift + bits_read) % 8;
|
|
if (rpad == 0)
|
|
{
|
|
/* Update byte. */
|
|
if (*sub_len == 0)
|
|
gif_buf_read(gif->fd, sub_len, 1); /* Must be nonzero! */
|
|
gif_buf_read(gif->fd, byte, 1);
|
|
(*sub_len)--;
|
|
}
|
|
frag_size = MIN(key_size - bits_read, 8 - rpad);
|
|
key |= ((uint16_t)((*byte) >> rpad)) << bits_read;
|
|
}
|
|
/* Clear extra bits to the left. */
|
|
key &= (1 << key_size) - 1;
|
|
*shift = (*shift + key_size) % 8;
|
|
return key;
|
|
}
|
|
|
|
/* Compute output index of y-th input line, in frame of height h. */
|
|
int16_t interlaced_line_index(int16_t h, int16_t y)
|
|
{
|
|
int16_t p; /* number of lines in current pass */
|
|
|
|
p = (h - 1) / 8 + 1;
|
|
if (y < p) /* pass 1 */
|
|
return y * 8;
|
|
y -= p;
|
|
p = (h - 5) / 8 + 1;
|
|
if (y < p) /* pass 2 */
|
|
return y * 8 + 4;
|
|
y -= p;
|
|
p = (h - 3) / 4 + 1;
|
|
if (y < p) /* pass 3 */
|
|
return y * 4 + 2;
|
|
y -= p;
|
|
/* pass 4 */
|
|
return y * 2 + 1;
|
|
}
|
|
|
|
/* Decompress image pixels.
|
|
* Return 0 on success or -1 on out-of-memory (w.r.t. LZW code table). */
|
|
int8_t read_image_data(gd_GIF *gif, int16_t interlace, uint8_t *frame)
|
|
{
|
|
uint8_t sub_len, shift, byte, table_is_full = 0;
|
|
uint16_t init_key_size, key_size;
|
|
int32_t frm_off, str_len = 0, p, x, y;
|
|
uint16_t key, clear, stop;
|
|
int32_t ret;
|
|
gd_Entry entry = {0, 0, 0};
|
|
|
|
// Serial.println("Read key size");
|
|
gif_buf_read(gif->fd, &byte, 1);
|
|
key_size = (uint16_t)byte;
|
|
// Serial.println("Set pos, discard sub blocks");
|
|
// start = gif->fd->position();
|
|
// discard_sub_blocks(gif);
|
|
// end = gif->fd->position();
|
|
// gif_buf_seek(gif->fd, start, SeekSet);
|
|
clear = 1 << key_size;
|
|
stop = clear + 1;
|
|
// Serial.println("New LZW table");
|
|
// table = new_table(key_size);
|
|
reset_table(gif->table, key_size);
|
|
key_size++;
|
|
init_key_size = key_size;
|
|
sub_len = shift = 0;
|
|
// Serial.println("Get init key");
|
|
key = get_key(gif, key_size, &sub_len, &shift, &byte); /* clear code */
|
|
frm_off = 0;
|
|
ret = 0;
|
|
while (1)
|
|
{
|
|
if (key == clear)
|
|
{
|
|
// Serial.println("Clear key, reset nentries");
|
|
key_size = init_key_size;
|
|
gif->table->nentries = (1 << (key_size - 1)) + 2;
|
|
table_is_full = 0;
|
|
}
|
|
else if (!table_is_full)
|
|
{
|
|
// Serial.println("Add entry to table");
|
|
ret = add_entry(gif->table, str_len + 1, key, entry.suffix);
|
|
// if (ret == -1) {
|
|
// // Serial.println("Table entry add failure");
|
|
// free(table);
|
|
// return -1;
|
|
// }
|
|
if (gif->table->nentries == 0x1000)
|
|
{
|
|
// Serial.println("Table is full");
|
|
ret = 0;
|
|
table_is_full = 1;
|
|
}
|
|
}
|
|
// Serial.println("Get key");
|
|
key = get_key(gif, key_size, &sub_len, &shift, &byte);
|
|
if (key == clear)
|
|
continue;
|
|
if (key == stop)
|
|
break;
|
|
if (ret == 1)
|
|
key_size++;
|
|
entry = gif->table->entries[key];
|
|
str_len = entry.len;
|
|
uint8_t tindex = gif->gce.tindex;
|
|
// Serial.println("Interpret key");
|
|
while (1)
|
|
{
|
|
p = frm_off + entry.len - 1;
|
|
x = p % gif->fw;
|
|
y = p / gif->fw;
|
|
if (interlace)
|
|
{
|
|
y = interlaced_line_index((int16_t)gif->fh, y);
|
|
}
|
|
if ((!gif->processed_first_frame) || (tindex != entry.suffix))
|
|
{
|
|
frame[(gif->fy + y) * gif->width + gif->fx + x] = entry.suffix;
|
|
}
|
|
if (entry.prefix == 0xFFF)
|
|
break;
|
|
else
|
|
entry = gif->table->entries[entry.prefix];
|
|
}
|
|
frm_off += str_len;
|
|
if (key < gif->table->nentries - 1 && !table_is_full)
|
|
gif->table->entries[gif->table->nentries - 1].suffix = entry.suffix;
|
|
}
|
|
// Serial.println("Done w/ img data, free table and seek to end");
|
|
// free(table);
|
|
gif_buf_read(gif->fd, &sub_len, 1); /* Must be zero! */
|
|
// gif_buf_seek(gif->fd, end, SeekSet);
|
|
|
|
gif->processed_first_frame = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Read image.
|
|
* Return 0 on success or -1 on out-of-memory (w.r.t. LZW code table). */
|
|
int8_t read_image(gd_GIF *gif, uint8_t *frame)
|
|
{
|
|
uint8_t fisrz;
|
|
int16_t interlace;
|
|
|
|
/* Image Descriptor. */
|
|
// Serial.println("Read image descriptor");
|
|
gif->fx = gif_buf_read16(gif->fd);
|
|
gif->fy = gif_buf_read16(gif->fd);
|
|
gif->fw = gif_buf_read16(gif->fd);
|
|
gif->fh = gif_buf_read16(gif->fd);
|
|
// Serial.println("Read fisrz?");
|
|
gif_buf_read(gif->fd, &fisrz, 1);
|
|
interlace = fisrz & 0x40;
|
|
/* Ignore Sort Flag. */
|
|
/* Local Color Table? */
|
|
if (fisrz & 0x80)
|
|
{
|
|
/* Read LCT */
|
|
// Serial.println("Read LCT");
|
|
read_palette(gif->fd, &gif->lct, 1 << ((fisrz & 0x07) + 1));
|
|
gif->palette = &gif->lct;
|
|
}
|
|
else
|
|
{
|
|
gif->palette = &gif->gct;
|
|
}
|
|
/* Image Data. */
|
|
// Serial.println("Read image data");
|
|
return read_image_data(gif, interlace, frame);
|
|
}
|
|
|
|
void render_frame_rect(gd_GIF *gif, uint16_t *buffer, uint8_t *frame)
|
|
{
|
|
int16_t i, j, k;
|
|
uint8_t index;
|
|
i = gif->fy * gif->width + gif->fx;
|
|
for (j = 0; j < gif->fh; j++)
|
|
{
|
|
for (k = 0; k < gif->fw; k++)
|
|
{
|
|
index = frame[(gif->fy + j) * gif->width + gif->fx + k];
|
|
// color = &gif->palette->colors[index*2];
|
|
if ((!gif->gce.transparency) || (index != gif->gce.tindex))
|
|
{
|
|
buffer[(i + k)] = gif->palette->colors[index];
|
|
}
|
|
// memcpy(&buffer[(i+k)*2], color, 2);
|
|
}
|
|
i += gif->width;
|
|
}
|
|
}
|
|
|
|
int16_t gif_buf_last_idx, gif_buf_idx, file_pos;
|
|
uint8_t gif_buf[GIF_BUF_SIZE];
|
|
};
|
|
|
|
#endif /* _GIFCLASS_H_ */ |