jaildesigner-demos/demo6_palette
1
0
Fork 0
Code Activity

migrat a SDL3

Browse Source 
arreglos estetics i d'estil
This commit is contained in:
Sergio
2025-03-24 22:54:14 +01:00
parent 7abbaee706
commit 0c89cd5138
9 changed files with 663 additions and 614 deletions
Download Patch File Download Diff File Expand all files Collapse all files

744
source/gif.c
View File

@@ -3,329 +3,326 @@
#include <string.h>
#include <fcntl.h>
#define EXTENSION_INTRODUCER 0x21
#define IMAGE_DESCRIPTOR 0x2C
#define TRAILER 0x3B
#define GRAPHIC_CONTROL 0xF9
#define APPLICATION_EXTENSION 0xFF
#define COMMENT_EXTENSION 0xFE
#define PLAINTEXT_EXTENSION 0x01
#define READ(dst, size) memcpy(dst, buffer, size); buffer += size
typedef struct
namespace GIF
{
unsigned short width;
unsigned short height;
unsigned char fields;
unsigned char background_color_index;
unsigned char pixel_aspect_ratio;
}
screen_descriptor_t;
#define EXTENSION_INTRODUCER 0x21
#define IMAGE_DESCRIPTOR 0x2C
#define TRAILER 0x3B
typedef struct
{
unsigned char r;
unsigned char g;
unsigned char b;
}
rgb;
#define GRAPHIC_CONTROL 0xF9
#define APPLICATION_EXTENSION 0xFF
#define COMMENT_EXTENSION 0xFE
#define PLAINTEXT_EXTENSION 0x01
typedef struct
{
unsigned short image_left_position;
unsigned short image_top_position;
unsigned short image_width;
unsigned short image_height;
unsigned char fields;
}
image_descriptor_t;
#define READ(dst, size) \
memcpy(dst, buffer, size); \
buffer += size
typedef struct
{
unsigned char byte;
int prev;
int len;
}
dictionary_entry_t;
typedef struct
{
unsigned char extension_code;
unsigned char block_size;
}
extension_t;
typedef struct
{
unsigned char fields;
unsigned short delay_time;
unsigned char transparent_color_index;
}
graphic_control_extension_t;
typedef struct
{
unsigned char application_id[ 8 ];
unsigned char version[ 3 ];
}
application_extension_t;
typedef struct
{
unsigned short left;
unsigned short top;
unsigned short width;
unsigned short height;
unsigned char cell_width;
unsigned char cell_height;
unsigned char foreground_color;
unsigned char background_color;
}
plaintext_extension_t;
//static unsigned short width = 0;
//static unsigned short height = 0;
//static unsigned char* uncompressed_data = NULL;
void uncompress( int code_length,
const unsigned char *input,
int input_length,
unsigned char *out )
{
//int maxbits;
int i, bit;
int code, prev = -1;
dictionary_entry_t *dictionary;
int dictionary_ind;
unsigned int mask = 0x01;
int reset_code_length;
int clear_code; // This varies depending on code_length
int stop_code; // one more than clear code
int match_len;
clear_code = 1 << ( code_length );
stop_code = clear_code + 1;
// To handle clear codes
reset_code_length = code_length;
// Create a dictionary large enough to hold "code_length" entries.
// Once the dictionary overflows, code_length increases
dictionary = ( dictionary_entry_t * )
malloc( sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
// Initialize the first 2^code_len entries of the dictionary with their
// indices. The rest of the entries will be built up dynamically.
// Technically, it shouldn't be necessary to initialize the
// dictionary. The spec says that the encoder "should output a
// clear code as the first code in the image data stream". It doesn't
// say must, though...
for ( dictionary_ind = 0;
dictionary_ind < ( 1 << code_length );
dictionary_ind++ )
typedef struct
{
dictionary[ dictionary_ind ].byte = dictionary_ind;
// XXX this only works because prev is a 32-bit int (> 12 bits)
dictionary[ dictionary_ind ].prev = -1;
dictionary[ dictionary_ind ].len = 1;
}
unsigned short width;
unsigned short height;
unsigned char fields;
unsigned char background_color_index;
unsigned char pixel_aspect_ratio;
} screen_descriptor_t;
// 2^code_len + 1 is the special "end" code; don't give it an entry here
dictionary_ind++;
dictionary_ind++;
// TODO verify that the very last byte is clear_code + 1
while ( input_length )
typedef struct
{
code = 0x0;
// Always read one more bit than the code length
for ( i = 0; i < ( code_length + 1 ); i++ )
unsigned char r;
unsigned char g;
unsigned char b;
} rgb;
typedef struct
{
unsigned short image_left_position;
unsigned short image_top_position;
unsigned short image_width;
unsigned short image_height;
unsigned char fields;
} image_descriptor_t;
typedef struct
{
unsigned char byte;
int prev;
int len;
} dictionary_entry_t;
typedef struct
{
unsigned char extension_code;
unsigned char block_size;
} extension_t;
typedef struct
{
unsigned char fields;
unsigned short delay_time;
unsigned char transparent_color_index;
} graphic_control_extension_t;
typedef struct
{
unsigned char application_id[8];
unsigned char version[3];
} application_extension_t;
typedef struct
{
unsigned short left;
unsigned short top;
unsigned short width;
unsigned short height;
unsigned char cell_width;
unsigned char cell_height;
unsigned char foreground_color;
unsigned char background_color;
} plaintext_extension_t;
// static unsigned short width = 0;
// static unsigned short height = 0;
// static unsigned char* uncompressed_data = NULL;
void uncompress(int code_length,
const unsigned char *input,
int input_length,
unsigned char *out)
{
// int maxbits;
int i, bit;
int code, prev = -1;
dictionary_entry_t *dictionary;
int dictionary_ind;
unsigned int mask = 0x01;
int reset_code_length;
int clear_code; // This varies depending on code_length
int stop_code; // one more than clear code
int match_len;
clear_code = 1 << (code_length);
stop_code = clear_code + 1;
// To handle clear codes
reset_code_length = code_length;
// Create a dictionary large enough to hold "code_length" entries.
// Once the dictionary overflows, code_length increases
dictionary = (dictionary_entry_t *)
malloc(sizeof(dictionary_entry_t) * (1 << (code_length + 1)));
// Initialize the first 2^code_len entries of the dictionary with their
// indices. The rest of the entries will be built up dynamically.
// Technically, it shouldn't be necessary to initialize the
// dictionary. The spec says that the encoder "should output a
// clear code as the first code in the image data stream". It doesn't
// say must, though...
for (dictionary_ind = 0;
dictionary_ind < (1 << code_length);
dictionary_ind++)
{
// This is different than in the file read example; that
// was a call to "next_bit"
bit = ( *input & mask ) ? 1 : 0;
mask <<= 1;
if ( mask == 0x100 )
{
mask = 0x01;
input++;
input_length--;
}
code = code | ( bit << i );
dictionary[dictionary_ind].byte = dictionary_ind;
// XXX this only works because prev is a 32-bit int (> 12 bits)
dictionary[dictionary_ind].prev = -1;
dictionary[dictionary_ind].len = 1;
}
if ( code == clear_code )
// 2^code_len + 1 is the special "end" code; don't give it an entry here
dictionary_ind++;
dictionary_ind++;
// TODO verify that the very last byte is clear_code + 1
while (input_length)
{
code_length = reset_code_length;
dictionary = ( dictionary_entry_t * ) realloc( dictionary,
sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
for ( dictionary_ind = 0;
dictionary_ind < ( 1 << code_length );
dictionary_ind++ )
code = 0x0;
// Always read one more bit than the code length
for (i = 0; i < (code_length + 1); i++)
{
dictionary[ dictionary_ind ].byte = dictionary_ind;
// XXX this only works because prev is a 32-bit int (> 12 bits)
dictionary[ dictionary_ind ].prev = -1;
dictionary[ dictionary_ind ].len = 1;
}
dictionary_ind++;
dictionary_ind++;
prev = -1;
continue;
}
else if ( code == stop_code )
{
/*if ( input_length > 1 )
{
fprintf( stderr, "Malformed GIF (early stop code)\n" );
exit( 0 );
}*/
break;
}
// This is different than in the file read example; that
// was a call to "next_bit"
bit = (*input & mask) ? 1 : 0;
mask <<= 1;
// Update the dictionary with this character plus the _entry_
// (character or string) that came before it
if ( ( prev > -1 ) && ( code_length < 12 ) )
{
if ( code > dictionary_ind )
{
fprintf( stderr, "code = %.02x, but dictionary_ind = %.02x\n",
code, dictionary_ind );
exit( 0 );
}
// Special handling for KwKwK
if ( code == dictionary_ind )
{
int ptr = prev;
while ( dictionary[ ptr ].prev != -1 )
if (mask == 0x100)
{
ptr = dictionary[ ptr ].prev;
mask = 0x01;
input++;
input_length--;
}
dictionary[ dictionary_ind ].byte = dictionary[ ptr ].byte;
code = code | (bit << i);
}
else
if (code == clear_code)
{
int ptr = code;
while ( dictionary[ ptr ].prev != -1 )
code_length = reset_code_length;
dictionary = (dictionary_entry_t *)realloc(dictionary,
sizeof(dictionary_entry_t) * (1 << (code_length + 1)));
for (dictionary_ind = 0;
dictionary_ind < (1 << code_length);
dictionary_ind++)
{
ptr = dictionary[ ptr ].prev;
dictionary[dictionary_ind].byte = dictionary_ind;
// XXX this only works because prev is a 32-bit int (> 12 bits)
dictionary[dictionary_ind].prev = -1;
dictionary[dictionary_ind].len = 1;
}
dictionary[ dictionary_ind ].byte = dictionary[ ptr ].byte;
dictionary_ind++;
dictionary_ind++;
prev = -1;
continue;
}
dictionary[ dictionary_ind ].prev = prev;
dictionary[ dictionary_ind ].len = dictionary[ prev ].len + 1;
dictionary_ind++;
// GIF89a mandates that this stops at 12 bits
if ( ( dictionary_ind == ( 1 << ( code_length + 1 ) ) ) &&
( code_length < 11 ) )
else if (code == stop_code)
{
code_length++;
dictionary = ( dictionary_entry_t * ) realloc( dictionary,
sizeof( dictionary_entry_t ) * ( 1 << ( code_length + 1 ) ) );
/*if ( input_length > 1 )
{
fprintf( stderr, "Malformed GIF (early stop code)\n" );
exit( 0 );
}*/
break;
}
}
prev = code;
// Now copy the dictionary entry backwards into "out"
match_len = dictionary[ code ].len;
while ( code != -1 )
{
out[ dictionary[ code ].len - 1 ] = dictionary[ code ].byte;
if ( dictionary[ code ].prev == code )
// Update the dictionary with this character plus the _entry_
// (character or string) that came before it
if ((prev > -1) && (code_length < 12))
{
fprintf( stderr, "Internal error; self-reference." );
exit( 0 );
}
code = dictionary[ code ].prev;
}
if (code > dictionary_ind)
{
fprintf(stderr, "code = %.02x, but dictionary_ind = %.02x\n",
code, dictionary_ind);
exit(0);
}
out += match_len;
// Special handling for KwKwK
if (code == dictionary_ind)
{
int ptr = prev;
while (dictionary[ptr].prev != -1)
{
ptr = dictionary[ptr].prev;
}
dictionary[dictionary_ind].byte = dictionary[ptr].byte;
}
else
{
int ptr = code;
while (dictionary[ptr].prev != -1)
{
ptr = dictionary[ptr].prev;
}
dictionary[dictionary_ind].byte = dictionary[ptr].byte;
}
dictionary[dictionary_ind].prev = prev;
dictionary[dictionary_ind].len = dictionary[prev].len + 1;
dictionary_ind++;
// GIF89a mandates that this stops at 12 bits
if ((dictionary_ind == (1 << (code_length + 1))) &&
(code_length < 11))
{
code_length++;
dictionary = (dictionary_entry_t *)realloc(dictionary,
sizeof(dictionary_entry_t) * (1 << (code_length + 1)));
}
}
prev = code;
// Now copy the dictionary entry backwards into "out"
match_len = dictionary[code].len;
while (code != -1)
{
out[dictionary[code].len - 1] = dictionary[code].byte;
if (dictionary[code].prev == code)
{
fprintf(stderr, "Internal error; self-reference.");
exit(0);
}
code = dictionary[code].prev;
}
out += match_len;
}
}
}
static int read_sub_blocks( unsigned char* buffer, unsigned char **data )
{
int data_length;
int index;
unsigned char block_size;
// Everything following are data sub-blocks, until a 0-sized block is
// encountered.
data_length = 0;
*data = NULL;
index = 0;
while ( 1 )
static int read_sub_blocks(unsigned char *buffer, unsigned char **data)
{
READ(&block_size, 1);
int data_length;
int index;
unsigned char block_size;
if ( block_size == 0 ) // end of sub-blocks
// Everything following are data sub-blocks, until a 0-sized block is
// encountered.
data_length = 0;
*data = NULL;
index = 0;
while (1)
{
break;
READ(&block_size, 1);
if (block_size == 0) // end of sub-blocks
{
break;
}
data_length += block_size;
*data = (unsigned char *)realloc(*data, data_length);
// TODO this could be split across block size boundaries
READ(*data + index, block_size);
index += block_size;
}
data_length += block_size;
*data = (unsigned char*)realloc( *data, data_length );
// TODO this could be split across block size boundaries
READ(*data + index, block_size);
index += block_size;
return data_length;
}
return data_length;
}
unsigned char *process_image_descriptor(unsigned char *buffer,
rgb *gct,
int gct_size,
int resolution_bits)
{
image_descriptor_t image_descriptor;
int compressed_data_length;
unsigned char *compressed_data = NULL;
unsigned char lzw_code_size;
int uncompressed_data_length = 0;
unsigned char *uncompressed_data = NULL;
unsigned char* process_image_descriptor( unsigned char* buffer,
rgb *gct,
int gct_size,
int resolution_bits )
{
image_descriptor_t image_descriptor;
int compressed_data_length;
unsigned char *compressed_data = NULL;
unsigned char lzw_code_size;
int uncompressed_data_length = 0;
unsigned char *uncompressed_data = NULL;
// TODO there could actually be lots of these
READ(&image_descriptor, 9);
// TODO there could actually be lots of these
READ(&image_descriptor, 9);
// TODO if LCT = true, read the LCT
// TODO if LCT = true, read the LCT
READ(&lzw_code_size, 1);
READ(&lzw_code_size, 1);
compressed_data_length = read_sub_blocks(buffer, &compressed_data);
compressed_data_length = read_sub_blocks( buffer, &compressed_data );
// width = image_descriptor.image_width;
// height = image_descriptor.image_height;
uncompressed_data_length = image_descriptor.image_width *
image_descriptor.image_height;
uncompressed_data = (unsigned char *)malloc(uncompressed_data_length);
// width = image_descriptor.image_width;
// height = image_descriptor.image_height;
uncompressed_data_length = image_descriptor.image_width *
image_descriptor.image_height;
uncompressed_data = (unsigned char*)malloc( uncompressed_data_length );
uncompress(lzw_code_size, compressed_data, compressed_data_length,
uncompressed_data);
uncompress( lzw_code_size, compressed_data, compressed_data_length,
uncompressed_data );
if (compressed_data)
free(compressed_data);
if ( compressed_data ) free( compressed_data );
// if ( uncompressed_data )
// free( uncompressed_data );
//if ( uncompressed_data )
// free( uncompressed_data );
return uncompressed_data;
}
return uncompressed_data;
}
/**
* @param gif_file the file descriptor of a file containing a
@@ -334,101 +331,104 @@ unsigned char* process_image_descriptor( unsigned char* buffer,
*/
#define rb (*(buffer++))
uint32_t* LoadPalette(unsigned char *buffer) {
unsigned char header[7];
screen_descriptor_t screen_descriptor;
//int color_resolution_bits;
int global_color_table_size = 0; // number of entries in global_color_table
uint32_t *global_color_table = NULL;
READ(header, 6);
READ(&screen_descriptor, 7);
//color_resolution_bits = ((screen_descriptor.fields & 0x70) >> 4) + 1;
global_color_table = (uint32_t *)calloc(1, 1024);
if (screen_descriptor.fields & 0x80) {
global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
//global_color_table = (rgb *)malloc(3 * global_color_table_size);
//READ(global_color_table, 3 * global_color_table_size);
for (int i=0; i<global_color_table_size;++i) {
global_color_table[i] = (buffer[0]<<16) + (buffer[1]<<8) + buffer[2];
buffer+=3;
}
}
return global_color_table;
}
static unsigned char* process_gif_stream(unsigned char *buffer, unsigned short* w, unsigned short* h)
{
unsigned char header[ 7 ];
screen_descriptor_t screen_descriptor;
int color_resolution_bits;
int global_color_table_size =0; // number of entries in global_color_table
rgb *global_color_table = NULL;
unsigned char block_type = 0x0;
// A GIF file starts with a Header (section 17)
READ(header, 6);
header[ 6 ] = 0x0;
// XXX there's another format, GIF87a, that you may still find
// floating around.
/*if ( strcmp( "GIF89a", (char*)header ) )
uint32_t *LoadPalette(unsigned char *buffer)
{
fprintf( stderr,
"Invalid GIF file (header is '%s', should be 'GIF89a')\n",
header );
return NULL;
}*/
unsigned char header[7];
screen_descriptor_t screen_descriptor;
// int color_resolution_bits;
// Followed by a logical screen descriptor
// Note that this works because GIFs specify little-endian order; on a
// big-endian machine, the height & width would need to be reversed.
int global_color_table_size = 0; // number of entries in global_color_table
uint32_t *global_color_table = NULL;
// Can't use sizeof here since GCC does byte alignment;
// sizeof( screen_descriptor_t ) = 8!
READ(&screen_descriptor, 7);
*w = screen_descriptor.width;
*h = screen_descriptor.height;
READ(header, 6);
READ(&screen_descriptor, 7);
color_resolution_bits = ( ( screen_descriptor.fields & 0x70 ) >> 4 ) + 1;
// color_resolution_bits = ((screen_descriptor.fields & 0x70) >> 4) + 1;
global_color_table = (uint32_t *)calloc(1, 1024);
if ( screen_descriptor.fields & 0x80 )
{
//int i;
// If bit 7 is set, the next block is a global color table; read it
global_color_table_size = 1 <<
( ( ( screen_descriptor.fields & 0x07 ) + 1 ) );
global_color_table = ( rgb * ) malloc( 3 * global_color_table_size );
// XXX this could conceivably return a short count...
READ(global_color_table, 3 * global_color_table_size);
}
while ( block_type != TRAILER )
{
READ(&block_type, 1);
unsigned char size;
switch ( block_type )
if (screen_descriptor.fields & 0x80)
{
global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
// global_color_table = (rgb *)malloc(3 * global_color_table_size);
// READ(global_color_table, 3 * global_color_table_size);
for (int i = 0; i < global_color_table_size; ++i)
{
global_color_table[i] = (0xFF << 24) + (buffer[0] << 16) + (buffer[1] << 8) + buffer[2];
buffer += 3;
}
}
return global_color_table;
}
static unsigned char *process_gif_stream(unsigned char *buffer, unsigned short *w, unsigned short *h)
{
unsigned char header[7];
screen_descriptor_t screen_descriptor;
int color_resolution_bits;
int global_color_table_size = 0; // number of entries in global_color_table
rgb *global_color_table = NULL;
unsigned char block_type = 0x0;
// A GIF file starts with a Header (section 17)
READ(header, 6);
header[6] = 0x0;
// XXX there's another format, GIF87a, that you may still find
// floating around.
/*if ( strcmp( "GIF89a", (char*)header ) )
{
fprintf( stderr,
"Invalid GIF file (header is '%s', should be 'GIF89a')\n",
header );
return NULL;
}*/
// Followed by a logical screen descriptor
// Note that this works because GIFs specify little-endian order; on a
// big-endian machine, the height & width would need to be reversed.
// Can't use sizeof here since GCC does byte alignment;
// sizeof( screen_descriptor_t ) = 8!
READ(&screen_descriptor, 7);
*w = screen_descriptor.width;
*h = screen_descriptor.height;
color_resolution_bits = ((screen_descriptor.fields & 0x70) >> 4) + 1;
if (screen_descriptor.fields & 0x80)
{
// int i;
// If bit 7 is set, the next block is a global color table; read it
global_color_table_size = 1 << (((screen_descriptor.fields & 0x07) + 1));
global_color_table = (rgb *)malloc(3 * global_color_table_size);
// XXX this could conceivably return a short count...
READ(global_color_table, 3 * global_color_table_size);
}
while (block_type != TRAILER)
{
READ(&block_type, 1);
unsigned char size;
switch (block_type)
{
case IMAGE_DESCRIPTOR:
return process_image_descriptor(buffer,
global_color_table,
global_color_table_size,
color_resolution_bits);
return process_image_descriptor(buffer,
global_color_table,
global_color_table_size,
color_resolution_bits);
break;
case EXTENSION_INTRODUCER:
buffer++;
size = *(buffer++);
buffer += size;
do {
do
{
size = *(buffer++);
buffer += size;
} while (size != 0);
@@ -441,18 +441,18 @@ static unsigned char* process_gif_stream(unsigned char *buffer, unsigned short*
case TRAILER:
break;
default:
fprintf( stderr, "Bailing on unrecognized block type %.02x\n",
block_type );
fprintf(stderr, "Bailing on unrecognized block type %.02x\n",
block_type);
return NULL;
}
}
return NULL;
}
return NULL;
}
unsigned char* LoadGif(unsigned char *buffer, unsigned short* w, unsigned short* h) {
return process_gif_stream(buffer, w, h);
}
unsigned char *LoadGif(unsigned char *buffer, unsigned short *w, unsigned short *h)
{
return process_gif_stream(buffer, w, h);
}
/*int main( int argc, char *argv[] )
{
@@ -475,4 +475,4 @@ unsigned char* LoadGif(unsigned char *buffer, unsigned short* w, unsigned short*
process_gif_stream( gif_file );
fclose( gif_file );
}*/
}*/}