mirror of https://github.com/sm64pc/sm64pc.git
Fixed as many warnings as per possible.
This commit is contained in:
Colton Rushton
parent
7a00799fe9
commit
fdaad3056b
2
Makefile
2
Makefile
|
|
@ -102,10 +102,12 @@ ifeq ($(WINDOWS_BUILD),1)
|
|||
TARGET_ARCH = i386pe
|
||||
TARGET_BITS = 32
|
||||
NO_BZERO_BCOPY := 1
|
||||
NO_PIE := 0
|
||||
else ifeq ($(CROSS),x86_64-w64-mingw32.static-)
|
||||
TARGET_ARCH = i386pep
|
||||
TARGET_BITS = 64
|
||||
NO_BZERO_BCOPY := 1
|
||||
NO_PIE := 0
|
||||
endif
|
||||
endif
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* in the "demofiles" array.
|
||||
* "ifdef" is an optional array property which can be used to specify
|
||||
* requirement of SM64 version.
|
||||
* "extraSize" is an optional property which will be added the size of the
|
||||
* "extraSize" is an optional property which will be added to the size of the
|
||||
* demofile.
|
||||
*
|
||||
* The "demofiles" array declares the inclusion order of the demofiles.
|
||||
|
|
@ -22,14 +22,15 @@
|
|||
{"demofile":"bitdw", "ifdef":["VERSION_US"]},
|
||||
|
||||
/* Whomp's Fortress has the wrong size.
|
||||
The original entries probably manually input the sizes. */
|
||||
The original entries probably manually input the sizes.
|
||||
The unused demo will be showing up with the CCM demo's header in QOL_FIXES. */
|
||||
{"demofile":"wf", "extraSize":368},
|
||||
|
||||
{"demofile":"ccm"},
|
||||
{"demofile":"bbh"},
|
||||
{"demofile":"jrb"},
|
||||
{"demofile":"hmc"},
|
||||
{"demofile":"pss"}
|
||||
{"demofile":"pss"},
|
||||
{"demofile":"unused", "ifdef":["QOL_FIXES"]}
|
||||
],
|
||||
"demofiles": [
|
||||
{"name":"bbh"},
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,4 +1,4 @@
|
|||
/* stb_image_write - v1.09 - public domain - http://nothings.org/stb/stb_image_write.h
|
||||
/* stb_image_write - v1.15 - public domain - http://nothings.org/stb
|
||||
writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015
|
||||
no warranty implied; use at your own risk
|
||||
|
||||
|
|
@ -10,15 +10,9 @@
|
|||
|
||||
Will probably not work correctly with strict-aliasing optimizations.
|
||||
|
||||
If using a modern Microsoft Compiler, non-safe versions of CRT calls may cause
|
||||
compilation warnings or even errors. To avoid this, also before #including,
|
||||
|
||||
#define STBI_MSC_SECURE_CRT
|
||||
|
||||
ABOUT:
|
||||
|
||||
This header file is a library for writing images to C stdio. It could be
|
||||
adapted to write to memory or a general streaming interface; let me know.
|
||||
This header file is a library for writing images to C stdio or a callback.
|
||||
|
||||
The PNG output is not optimal; it is 20-50% larger than the file
|
||||
written by a decent optimizing implementation; though providing a custom
|
||||
|
|
@ -38,6 +32,14 @@ BUILDING:
|
|||
The returned data will be freed with STBIW_FREE() (free() by default),
|
||||
so it must be heap allocated with STBIW_MALLOC() (malloc() by default),
|
||||
|
||||
UNICODE:
|
||||
|
||||
If compiling for Windows and you wish to use Unicode filenames, compile
|
||||
with
|
||||
#define STBIW_WINDOWS_UTF8
|
||||
and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert
|
||||
Windows wchar_t filenames to utf8.
|
||||
|
||||
USAGE:
|
||||
|
||||
There are five functions, one for each image file format:
|
||||
|
|
@ -103,7 +105,7 @@ USAGE:
|
|||
|
||||
TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed
|
||||
data, set the global variable 'stbi_write_tga_with_rle' to 0.
|
||||
|
||||
|
||||
JPEG does ignore alpha channels in input data; quality is between 1 and 100.
|
||||
Higher quality looks better but results in a bigger image.
|
||||
JPEG baseline (no JPEG progressive).
|
||||
|
|
@ -111,7 +113,7 @@ USAGE:
|
|||
CREDITS:
|
||||
|
||||
|
||||
Sean Barrett - PNG/BMP/TGA
|
||||
Sean Barrett - PNG/BMP/TGA
|
||||
Baldur Karlsson - HDR
|
||||
Jean-Sebastien Guay - TGA monochrome
|
||||
Tim Kelsey - misc enhancements
|
||||
|
|
@ -148,6 +150,8 @@ LICENSE
|
|||
#ifndef INCLUDE_STB_IMAGE_WRITE_H
|
||||
#define INCLUDE_STB_IMAGE_WRITE_H
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
// if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline'
|
||||
#ifndef STBIWDEF
|
||||
#ifdef STB_IMAGE_WRITE_STATIC
|
||||
|
|
@ -173,6 +177,10 @@ STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const
|
|||
STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data);
|
||||
STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data);
|
||||
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality);
|
||||
|
||||
#ifdef STBI_WINDOWS_UTF8
|
||||
STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
typedef void stbi_write_func(void *context, void *data, int size);
|
||||
|
|
@ -239,17 +247,17 @@ STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean);
|
|||
#define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff)
|
||||
|
||||
#ifdef STB_IMAGE_WRITE_STATIC
|
||||
static int stbi__flip_vertically_on_write=0;
|
||||
static int stbi_write_png_compression_level = 8;
|
||||
static int stbi_write_tga_with_rle = 1;
|
||||
static int stbi_write_force_png_filter = -1;
|
||||
#else
|
||||
int stbi_write_png_compression_level = 8;
|
||||
int stbi__flip_vertically_on_write=0;
|
||||
int stbi_write_tga_with_rle = 1;
|
||||
int stbi_write_force_png_filter = -1;
|
||||
#endif
|
||||
|
||||
static int stbi__flip_vertically_on_write = 0;
|
||||
|
||||
STBIWDEF void stbi_flip_vertically_on_write(int flag)
|
||||
{
|
||||
stbi__flip_vertically_on_write = flag;
|
||||
|
|
@ -259,6 +267,8 @@ typedef struct
|
|||
{
|
||||
stbi_write_func *func;
|
||||
void *context;
|
||||
unsigned char buffer[64];
|
||||
int buf_used;
|
||||
} stbi__write_context;
|
||||
|
||||
// initialize a callback-based context
|
||||
|
|
@ -275,15 +285,52 @@ static void stbi__stdio_write(void *context, void *data, int size)
|
|||
fwrite(data,1,size,(FILE*) context);
|
||||
}
|
||||
|
||||
static int stbi__start_write_file(stbi__write_context *s, const char *filename)
|
||||
#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
|
||||
#ifdef __cplusplus
|
||||
#define STBIW_EXTERN extern "C"
|
||||
#else
|
||||
#define STBIW_EXTERN extern
|
||||
#endif
|
||||
STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide);
|
||||
STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default);
|
||||
|
||||
STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input)
|
||||
{
|
||||
return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL);
|
||||
}
|
||||
#endif
|
||||
|
||||
static FILE *stbiw__fopen(char const *filename, char const *mode)
|
||||
{
|
||||
FILE *f;
|
||||
#ifdef STBI_MSC_SECURE_CRT
|
||||
if (fopen_s(&f, filename, "wb"))
|
||||
f = NULL;
|
||||
#if defined(_MSC_VER) && defined(STBI_WINDOWS_UTF8)
|
||||
wchar_t wMode[64];
|
||||
wchar_t wFilename[1024];
|
||||
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)))
|
||||
return 0;
|
||||
|
||||
if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)))
|
||||
return 0;
|
||||
|
||||
#if _MSC_VER >= 1400
|
||||
if (0 != _wfopen_s(&f, wFilename, wMode))
|
||||
f = 0;
|
||||
#else
|
||||
f = fopen(filename, "wb");
|
||||
f = _wfopen(wFilename, wMode);
|
||||
#endif
|
||||
|
||||
#elif defined(_MSC_VER) && _MSC_VER >= 1400
|
||||
if (0 != fopen_s(&f, filename, mode))
|
||||
f=0;
|
||||
#else
|
||||
f = fopen(filename, mode);
|
||||
#endif
|
||||
return f;
|
||||
}
|
||||
|
||||
static int stbi__start_write_file(stbi__write_context *s, const char *filename)
|
||||
{
|
||||
FILE *f = stbiw__fopen(filename, "wb");
|
||||
stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f);
|
||||
return f != NULL;
|
||||
}
|
||||
|
|
@ -335,16 +382,36 @@ static void stbiw__writef(stbi__write_context *s, const char *fmt, ...)
|
|||
va_end(v);
|
||||
}
|
||||
|
||||
static void stbiw__write_flush(stbi__write_context *s)
|
||||
{
|
||||
if (s->buf_used) {
|
||||
s->func(s->context, &s->buffer, s->buf_used);
|
||||
s->buf_used = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void stbiw__putc(stbi__write_context *s, unsigned char c)
|
||||
{
|
||||
s->func(s->context, &c, 1);
|
||||
}
|
||||
|
||||
static void stbiw__write1(stbi__write_context *s, unsigned char a)
|
||||
{
|
||||
if (s->buf_used + 1 > sizeof(s->buffer))
|
||||
stbiw__write_flush(s);
|
||||
s->buffer[s->buf_used++] = a;
|
||||
}
|
||||
|
||||
static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c)
|
||||
{
|
||||
unsigned char arr[3];
|
||||
arr[0] = a, arr[1] = b, arr[2] = c;
|
||||
s->func(s->context, arr, 3);
|
||||
int n;
|
||||
if (s->buf_used + 3 > sizeof(s->buffer))
|
||||
stbiw__write_flush(s);
|
||||
n = s->buf_used;
|
||||
s->buf_used = n+3;
|
||||
s->buffer[n+0] = a;
|
||||
s->buffer[n+1] = b;
|
||||
s->buffer[n+2] = c;
|
||||
}
|
||||
|
||||
static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d)
|
||||
|
|
@ -353,7 +420,7 @@ static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, in
|
|||
int k;
|
||||
|
||||
if (write_alpha < 0)
|
||||
s->func(s->context, &d[comp - 1], 1);
|
||||
stbiw__write1(s, d[comp - 1]);
|
||||
|
||||
switch (comp) {
|
||||
case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case
|
||||
|
|
@ -361,7 +428,7 @@ static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, in
|
|||
if (expand_mono)
|
||||
stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp
|
||||
else
|
||||
s->func(s->context, d, 1); // monochrome TGA
|
||||
stbiw__write1(s, d[0]); // monochrome TGA
|
||||
break;
|
||||
case 4:
|
||||
if (!write_alpha) {
|
||||
|
|
@ -377,7 +444,7 @@ static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, in
|
|||
break;
|
||||
}
|
||||
if (write_alpha > 0)
|
||||
s->func(s->context, &d[comp - 1], 1);
|
||||
stbiw__write1(s, d[comp - 1]);
|
||||
}
|
||||
|
||||
static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono)
|
||||
|
|
@ -391,16 +458,18 @@ static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, i
|
|||
if (stbi__flip_vertically_on_write)
|
||||
vdir *= -1;
|
||||
|
||||
if (vdir < 0)
|
||||
j_end = -1, j = y-1;
|
||||
else
|
||||
j_end = y, j = 0;
|
||||
if (vdir < 0) {
|
||||
j_end = -1; j = y-1;
|
||||
} else {
|
||||
j_end = y; j = 0;
|
||||
}
|
||||
|
||||
for (; j != j_end; j += vdir) {
|
||||
for (i=0; i < x; ++i) {
|
||||
unsigned char *d = (unsigned char *) data + (j*x+i)*comp;
|
||||
stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d);
|
||||
}
|
||||
stbiw__write_flush(s);
|
||||
s->func(s->context, &zero, scanline_pad);
|
||||
}
|
||||
}
|
||||
|
|
@ -430,7 +499,7 @@ static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, c
|
|||
|
||||
STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
|
||||
{
|
||||
stbi__write_context s;
|
||||
stbi__write_context s = { 0 };
|
||||
stbi__start_write_callbacks(&s, func, context);
|
||||
return stbi_write_bmp_core(&s, x, y, comp, data);
|
||||
}
|
||||
|
|
@ -438,7 +507,7 @@ STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x,
|
|||
#ifndef STBI_WRITE_NO_STDIO
|
||||
STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
|
||||
{
|
||||
stbi__write_context s;
|
||||
stbi__write_context s = { 0 };
|
||||
if (stbi__start_write_file(&s,filename)) {
|
||||
int r = stbi_write_bmp_core(&s, x, y, comp, data);
|
||||
stbi__end_write_file(&s);
|
||||
|
|
@ -511,24 +580,25 @@ static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, v
|
|||
|
||||
if (diff) {
|
||||
unsigned char header = STBIW_UCHAR(len - 1);
|
||||
s->func(s->context, &header, 1);
|
||||
stbiw__write1(s, header);
|
||||
for (k = 0; k < len; ++k) {
|
||||
stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp);
|
||||
}
|
||||
} else {
|
||||
unsigned char header = STBIW_UCHAR(len - 129);
|
||||
s->func(s->context, &header, 1);
|
||||
stbiw__write1(s, header);
|
||||
stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin);
|
||||
}
|
||||
}
|
||||
}
|
||||
stbiw__write_flush(s);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data)
|
||||
{
|
||||
stbi__write_context s;
|
||||
stbi__write_context s = { 0 };
|
||||
stbi__start_write_callbacks(&s, func, context);
|
||||
return stbi_write_tga_core(&s, x, y, comp, (void *) data);
|
||||
}
|
||||
|
|
@ -536,7 +606,7 @@ STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x,
|
|||
#ifndef STBI_WRITE_NO_STDIO
|
||||
STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
|
||||
{
|
||||
stbi__write_context s;
|
||||
stbi__write_context s = { 0 };
|
||||
if (stbi__start_write_file(&s,filename)) {
|
||||
int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);
|
||||
stbi__end_write_file(&s);
|
||||
|
|
@ -552,7 +622,7 @@ STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const
|
|||
|
||||
#define stbiw__max(a, b) ((a) > (b) ? (a) : (b))
|
||||
|
||||
void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
|
||||
static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
|
||||
{
|
||||
int exponent;
|
||||
float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2]));
|
||||
|
|
@ -569,7 +639,7 @@ void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear)
|
|||
}
|
||||
}
|
||||
|
||||
void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
|
||||
static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte)
|
||||
{
|
||||
unsigned char lengthbyte = STBIW_UCHAR(length+128);
|
||||
STBIW_ASSERT(length+128 <= 255);
|
||||
|
|
@ -577,7 +647,7 @@ void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char dat
|
|||
s->func(s->context, &databyte, 1);
|
||||
}
|
||||
|
||||
void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
|
||||
static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data)
|
||||
{
|
||||
unsigned char lengthbyte = STBIW_UCHAR(length);
|
||||
STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code
|
||||
|
|
@ -585,7 +655,7 @@ void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *d
|
|||
s->func(s->context, data, length);
|
||||
}
|
||||
|
||||
void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)
|
||||
static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline)
|
||||
{
|
||||
unsigned char scanlineheader[4] = { 2, 2, 0, 0 };
|
||||
unsigned char rgbe[4];
|
||||
|
|
@ -686,15 +756,15 @@ static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, f
|
|||
char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
|
||||
s->func(s->context, header, sizeof(header)-1);
|
||||
|
||||
#ifdef STBI_MSC_SECURE_CRT
|
||||
len = sprintf_s(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
|
||||
#ifdef __STDC_WANT_SECURE_LIB__
|
||||
len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
|
||||
#else
|
||||
len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x);
|
||||
#endif
|
||||
s->func(s->context, buffer, len);
|
||||
|
||||
for(i=0; i < y; i++)
|
||||
stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)*x);
|
||||
stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i));
|
||||
STBIW_FREE(scratch);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -702,7 +772,7 @@ static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, f
|
|||
|
||||
STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data)
|
||||
{
|
||||
stbi__write_context s;
|
||||
stbi__write_context s = { 0 };
|
||||
stbi__start_write_callbacks(&s, func, context);
|
||||
return stbi_write_hdr_core(&s, x, y, comp, (float *) data);
|
||||
}
|
||||
|
|
@ -710,7 +780,7 @@ STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x,
|
|||
#ifndef STBI_WRITE_NO_STDIO
|
||||
STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
|
||||
{
|
||||
stbi__write_context s;
|
||||
stbi__write_context s = { 0 };
|
||||
if (stbi__start_write_file(&s,filename)) {
|
||||
int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
|
||||
stbi__end_write_file(&s);
|
||||
|
|
@ -728,7 +798,7 @@ STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const
|
|||
|
||||
#ifndef STBIW_ZLIB_COMPRESS
|
||||
// stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size()
|
||||
#define stbiw__sbraw(a) ((int *) (a) - 2)
|
||||
#define stbiw__sbraw(a) ((int *) (void *) (a) - 2)
|
||||
#define stbiw__sbm(a) stbiw__sbraw(a)[0]
|
||||
#define stbiw__sbn(a) stbiw__sbraw(a)[1]
|
||||
|
||||
|
|
@ -809,7 +879,7 @@ static unsigned int stbiw__zhash(unsigned char *data)
|
|||
|
||||
#endif // STBIW_ZLIB_COMPRESS
|
||||
|
||||
unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
|
||||
STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
|
||||
{
|
||||
#ifdef STBIW_ZLIB_COMPRESS
|
||||
// user provided a zlib compress implementation, use that
|
||||
|
|
@ -822,7 +892,7 @@ unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_l
|
|||
unsigned int bitbuf=0;
|
||||
int i,j, bitcount=0;
|
||||
unsigned char *out = NULL;
|
||||
unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(char**));
|
||||
unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**));
|
||||
if (hash_table == NULL)
|
||||
return NULL;
|
||||
if (quality < 5) quality = 5;
|
||||
|
|
@ -845,7 +915,7 @@ unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_l
|
|||
for (j=0; j < n; ++j) {
|
||||
if (hlist[j]-data > i-32768) { // if entry lies within window
|
||||
int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i);
|
||||
if (d >= best) best=d,bestloc=hlist[j];
|
||||
if (d >= best) { best=d; bestloc=hlist[j]; }
|
||||
}
|
||||
}
|
||||
// when hash table entry is too long, delete half the entries
|
||||
|
|
@ -904,8 +974,8 @@ unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_l
|
|||
int blocklen = (int) (data_len % 5552);
|
||||
j=0;
|
||||
while (j < data_len) {
|
||||
for (i=0; i < blocklen; ++i) s1 += data[j+i], s2 += s1;
|
||||
s1 %= 65521, s2 %= 65521;
|
||||
for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; }
|
||||
s1 %= 65521; s2 %= 65521;
|
||||
j += blocklen;
|
||||
blocklen = 5552;
|
||||
}
|
||||
|
|
@ -923,6 +993,9 @@ unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_l
|
|||
|
||||
static unsigned int stbiw__crc32(unsigned char *buffer, int len)
|
||||
{
|
||||
#ifdef STBIW_CRC32
|
||||
return STBIW_CRC32(buffer, len);
|
||||
#else
|
||||
static unsigned int crc_table[256] =
|
||||
{
|
||||
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
|
||||
|
|
@ -964,6 +1037,7 @@ static unsigned int stbiw__crc32(unsigned char *buffer, int len)
|
|||
for (i=0; i < len; ++i)
|
||||
crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)];
|
||||
return ~crc;
|
||||
#endif
|
||||
}
|
||||
|
||||
#define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4)
|
||||
|
|
@ -994,9 +1068,15 @@ static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int
|
|||
int type = mymap[filter_type];
|
||||
unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y);
|
||||
int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes;
|
||||
|
||||
if (type==0) {
|
||||
memcpy(line_buffer, z, width*n);
|
||||
return;
|
||||
}
|
||||
|
||||
// first loop isn't optimized since it's just one pixel
|
||||
for (i = 0; i < n; ++i) {
|
||||
switch (type) {
|
||||
case 0: line_buffer[i] = z[i]; break;
|
||||
case 1: line_buffer[i] = z[i]; break;
|
||||
case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break;
|
||||
case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break;
|
||||
|
|
@ -1005,20 +1085,17 @@ static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int
|
|||
case 6: line_buffer[i] = z[i]; break;
|
||||
}
|
||||
}
|
||||
for (i=n; i < width*n; ++i) {
|
||||
switch (type) {
|
||||
case 0: line_buffer[i] = z[i]; break;
|
||||
case 1: line_buffer[i] = z[i] - z[i-n]; break;
|
||||
case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break;
|
||||
case 3: line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break;
|
||||
case 4: line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break;
|
||||
case 5: line_buffer[i] = z[i] - (z[i-n]>>1); break;
|
||||
case 6: line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
|
||||
}
|
||||
switch (type) {
|
||||
case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break;
|
||||
case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break;
|
||||
case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break;
|
||||
case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break;
|
||||
case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break;
|
||||
case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
|
||||
STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len)
|
||||
{
|
||||
int force_filter = stbi_write_force_png_filter;
|
||||
int ctype[5] = { -1, 0, 4, 2, 6 };
|
||||
|
|
@ -1040,11 +1117,11 @@ unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, in
|
|||
int filter_type;
|
||||
if (force_filter > -1) {
|
||||
filter_type = force_filter;
|
||||
stbiw__encode_png_line(pixels, stride_bytes, x, y, j, n, force_filter, line_buffer);
|
||||
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer);
|
||||
} else { // Estimate the best filter by running through all of them:
|
||||
int best_filter = 0, best_filter_val = 0x7fffffff, est, i;
|
||||
for (filter_type = 0; filter_type < 5; filter_type++) {
|
||||
stbiw__encode_png_line(pixels, stride_bytes, x, y, j, n, filter_type, line_buffer);
|
||||
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer);
|
||||
|
||||
// Estimate the entropy of the line using this filter; the less, the better.
|
||||
est = 0;
|
||||
|
|
@ -1057,7 +1134,7 @@ unsigned char *stbi_write_png_to_mem(unsigned char *pixels, int stride_bytes, in
|
|||
}
|
||||
}
|
||||
if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it
|
||||
stbiw__encode_png_line(pixels, stride_bytes, x, y, j, n, best_filter, line_buffer);
|
||||
stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer);
|
||||
filter_type = best_filter;
|
||||
}
|
||||
}
|
||||
|
|
@ -1109,14 +1186,10 @@ STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const
|
|||
{
|
||||
FILE *f;
|
||||
int len;
|
||||
unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
|
||||
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
|
||||
if (png == NULL) return 0;
|
||||
#ifdef STBI_MSC_SECURE_CRT
|
||||
if (fopen_s(&f, filename, "wb"))
|
||||
f = NULL;
|
||||
#else
|
||||
f = fopen(filename, "wb");
|
||||
#endif
|
||||
|
||||
f = stbiw__fopen(filename, "wb");
|
||||
if (!f) { STBIW_FREE(png); return 0; }
|
||||
fwrite(png, 1, len, f);
|
||||
fclose(f);
|
||||
|
|
@ -1128,7 +1201,7 @@ STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const
|
|||
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
|
||||
{
|
||||
int len;
|
||||
unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
|
||||
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
|
||||
if (png == NULL) return 0;
|
||||
func(context, png, len);
|
||||
STBIW_FREE(png);
|
||||
|
|
@ -1222,26 +1295,31 @@ static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) {
|
|||
bits[0] = val & ((1<<bits[1])-1);
|
||||
}
|
||||
|
||||
static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
|
||||
static int stbiw__jpg_processDU(stbi__write_context *s, int *bitBuf, int *bitCnt, float *CDU, int du_stride, float *fdtbl, int DC, const unsigned short HTDC[256][2], const unsigned short HTAC[256][2]) {
|
||||
const unsigned short EOB[2] = { HTAC[0x00][0], HTAC[0x00][1] };
|
||||
const unsigned short M16zeroes[2] = { HTAC[0xF0][0], HTAC[0xF0][1] };
|
||||
int dataOff, i, diff, end0pos;
|
||||
int dataOff, i, j, n, diff, end0pos, x, y;
|
||||
int DU[64];
|
||||
|
||||
// DCT rows
|
||||
for(dataOff=0; dataOff<64; dataOff+=8) {
|
||||
for(dataOff=0, n=du_stride*8; dataOff<n; dataOff+=du_stride) {
|
||||
stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+1], &CDU[dataOff+2], &CDU[dataOff+3], &CDU[dataOff+4], &CDU[dataOff+5], &CDU[dataOff+6], &CDU[dataOff+7]);
|
||||
}
|
||||
// DCT columns
|
||||
for(dataOff=0; dataOff<8; ++dataOff) {
|
||||
stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+8], &CDU[dataOff+16], &CDU[dataOff+24], &CDU[dataOff+32], &CDU[dataOff+40], &CDU[dataOff+48], &CDU[dataOff+56]);
|
||||
stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff+du_stride], &CDU[dataOff+du_stride*2], &CDU[dataOff+du_stride*3], &CDU[dataOff+du_stride*4],
|
||||
&CDU[dataOff+du_stride*5], &CDU[dataOff+du_stride*6], &CDU[dataOff+du_stride*7]);
|
||||
}
|
||||
// Quantize/descale/zigzag the coefficients
|
||||
for(i=0; i<64; ++i) {
|
||||
float v = CDU[i]*fdtbl[i];
|
||||
// DU[stbiw__jpg_ZigZag[i]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
|
||||
// ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
|
||||
DU[stbiw__jpg_ZigZag[i]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
|
||||
for(y = 0, j=0; y < 8; ++y) {
|
||||
for(x = 0; x < 8; ++x,++j) {
|
||||
float v;
|
||||
i = y*du_stride+x;
|
||||
v = CDU[i]*fdtbl[j];
|
||||
// DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? ceilf(v - 0.5f) : floorf(v + 0.5f));
|
||||
// ceilf() and floorf() are C99, not C89, but I /think/ they're not needed here anyway?
|
||||
DU[stbiw__jpg_ZigZag[j]] = (int)(v < 0 ? v - 0.5f : v + 0.5f);
|
||||
}
|
||||
}
|
||||
|
||||
// Encode DC
|
||||
|
|
@ -1356,10 +1434,10 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
|
|||
37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99};
|
||||
static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99,
|
||||
99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99};
|
||||
static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f,
|
||||
static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f,
|
||||
1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f };
|
||||
|
||||
int row, col, i, k;
|
||||
int row, col, i, k, subsample;
|
||||
float fdtbl_Y[64], fdtbl_UV[64];
|
||||
unsigned char YTable[64], UVTable[64];
|
||||
|
||||
|
|
@ -1368,6 +1446,7 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
|
|||
}
|
||||
|
||||
quality = quality ? quality : 90;
|
||||
subsample = quality <= 90 ? 1 : 0;
|
||||
quality = quality < 1 ? 1 : quality > 100 ? 100 : quality;
|
||||
quality = quality < 50 ? 5000 / quality : 200 - quality * 2;
|
||||
|
||||
|
|
@ -1390,7 +1469,7 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
|
|||
static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 };
|
||||
static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 };
|
||||
const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width),
|
||||
3,1,0x11,0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };
|
||||
3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 };
|
||||
s->func(s->context, (void*)head0, sizeof(head0));
|
||||
s->func(s->context, (void*)YTable, sizeof(YTable));
|
||||
stbiw__putc(s, 1);
|
||||
|
|
@ -1413,38 +1492,74 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
|
|||
// Encode 8x8 macroblocks
|
||||
{
|
||||
static const unsigned short fillBits[] = {0x7F, 7};
|
||||
const unsigned char *imageData = (const unsigned char *)data;
|
||||
int DCY=0, DCU=0, DCV=0;
|
||||
int bitBuf=0, bitCnt=0;
|
||||
// comp == 2 is grey+alpha (alpha is ignored)
|
||||
int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0;
|
||||
const unsigned char *dataR = (const unsigned char *)data;
|
||||
const unsigned char *dataG = dataR + ofsG;
|
||||
const unsigned char *dataB = dataR + ofsB;
|
||||
int x, y, pos;
|
||||
for(y = 0; y < height; y += 8) {
|
||||
for(x = 0; x < width; x += 8) {
|
||||
float YDU[64], UDU[64], VDU[64];
|
||||
for(row = y, pos = 0; row < y+8; ++row) {
|
||||
for(col = x; col < x+8; ++col, ++pos) {
|
||||
int p = (stbi__flip_vertically_on_write ? height-1-row : row)*width*comp + col*comp;
|
||||
float r, g, b;
|
||||
if(row >= height) {
|
||||
p -= width*comp*(row+1 - height);
|
||||
}
|
||||
if(col >= width) {
|
||||
p -= comp*(col+1 - width);
|
||||
if(subsample) {
|
||||
for(y = 0; y < height; y += 16) {
|
||||
for(x = 0; x < width; x += 16) {
|
||||
float Y[256], U[256], V[256];
|
||||
for(row = y, pos = 0; row < y+16; ++row) {
|
||||
// row >= height => use last input row
|
||||
int clamped_row = (row < height) ? row : height - 1;
|
||||
int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
|
||||
for(col = x; col < x+16; ++col, ++pos) {
|
||||
// if col >= width => use pixel from last input column
|
||||
int p = base_p + ((col < width) ? col : (width-1))*comp;
|
||||
float r = dataR[p], g = dataG[p], b = dataB[p];
|
||||
Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
|
||||
U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
|
||||
V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
|
||||
}
|
||||
}
|
||||
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
|
||||
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
|
||||
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
|
||||
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT);
|
||||
|
||||
r = imageData[p+0];
|
||||
g = imageData[p+ofsG];
|
||||
b = imageData[p+ofsB];
|
||||
YDU[pos]=+0.29900f*r+0.58700f*g+0.11400f*b-128;
|
||||
UDU[pos]=-0.16874f*r-0.33126f*g+0.50000f*b;
|
||||
VDU[pos]=+0.50000f*r-0.41869f*g-0.08131f*b;
|
||||
// subsample U,V
|
||||
{
|
||||
float subU[64], subV[64];
|
||||
int yy, xx;
|
||||
for(yy = 0, pos = 0; yy < 8; ++yy) {
|
||||
for(xx = 0; xx < 8; ++xx, ++pos) {
|
||||
int j = yy*32+xx*2;
|
||||
subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f;
|
||||
subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f;
|
||||
}
|
||||
}
|
||||
DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
|
||||
DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for(y = 0; y < height; y += 8) {
|
||||
for(x = 0; x < width; x += 8) {
|
||||
float Y[64], U[64], V[64];
|
||||
for(row = y, pos = 0; row < y+8; ++row) {
|
||||
// row >= height => use last input row
|
||||
int clamped_row = (row < height) ? row : height - 1;
|
||||
int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp;
|
||||
for(col = x; col < x+8; ++col, ++pos) {
|
||||
// if col >= width => use pixel from last input column
|
||||
int p = base_p + ((col < width) ? col : (width-1))*comp;
|
||||
float r = dataR[p], g = dataG[p], b = dataB[p];
|
||||
Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128;
|
||||
U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b;
|
||||
V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b;
|
||||
}
|
||||
}
|
||||
|
||||
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, YDU, fdtbl_Y, DCY, YDC_HT, YAC_HT);
|
||||
DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, UDU, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
|
||||
DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, VDU, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
|
||||
DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT);
|
||||
DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT);
|
||||
DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1461,7 +1576,7 @@ static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, in
|
|||
|
||||
STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality)
|
||||
{
|
||||
stbi__write_context s;
|
||||
stbi__write_context s = { 0 };
|
||||
stbi__start_write_callbacks(&s, func, context);
|
||||
return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality);
|
||||
}
|
||||
|
|
@ -1470,7 +1585,7 @@ STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x,
|
|||
#ifndef STBI_WRITE_NO_STDIO
|
||||
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
|
||||
{
|
||||
stbi__write_context s;
|
||||
stbi__write_context s = { 0 };
|
||||
if (stbi__start_write_file(&s,filename)) {
|
||||
int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
|
||||
stbi__end_write_file(&s);
|
||||
|
|
@ -1483,6 +1598,13 @@ STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const
|
|||
#endif // STB_IMAGE_WRITE_IMPLEMENTATION
|
||||
|
||||
/* Revision history
|
||||
1.14 (2020-02-02) updated JPEG writer to downsample chroma channels
|
||||
1.13
|
||||
1.12
|
||||
1.11 (2019-08-11)
|
||||
|
||||
1.10 (2019-02-07)
|
||||
support utf8 filenames in Windows; fix warnings and platform ifdefs
|
||||
1.09 (2018-02-11)
|
||||
fix typo in zlib quality API, improve STB_I_W_STATIC in C++
|
||||
1.08 (2018-01-29)
|
||||
|
|
@ -1531,38 +1653,38 @@ This software is available under 2 licenses -- choose whichever you prefer.
|
|||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE A - MIT License
|
||||
Copyright (c) 2017 Sean Barrett
|
||||
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
|
||||
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
|
||||
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
|
||||
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.
|
||||
------------------------------------------------------------------------------
|
||||
ALTERNATIVE B - Public Domain (www.unlicense.org)
|
||||
This is free and unencumbered software released into the public domain.
|
||||
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
|
||||
software, either in source code form or as a compiled binary, for any purpose,
|
||||
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
|
||||
software, either in source code form or as a compiled binary, for any purpose,
|
||||
commercial or non-commercial, and by any means.
|
||||
In jurisdictions that recognize copyright laws, the author or authors of this
|
||||
software dedicate any and all copyright interest in the software to the public
|
||||
domain. We make this dedication for the benefit of the public at large and to
|
||||
the detriment of our heirs and successors. We intend this dedication to be an
|
||||
overt act of relinquishment in perpetuity of all present and future rights to
|
||||
In jurisdictions that recognize copyright laws, the author or authors of this
|
||||
software dedicate any and all copyright interest in the software to the public
|
||||
domain. We make this dedication for the benefit of the public at large and to
|
||||
the detriment of our heirs and successors. We intend this dedication to be an
|
||||
overt act of relinquishment in perpetuity of all present and future rights to
|
||||
this software under copyright law.
|
||||
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 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
|
||||
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 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.
|
||||
------------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -12,7 +12,10 @@
|
|||
// forwarded to the other, but it is hard to tell in which direction.
|
||||
#ifdef __GNUC__
|
||||
#define printf(...) \
|
||||
(__VA_ARGS__);
|
||||
_Pragma ("GCC diagnostic push") \
|
||||
_Pragma ("GCC diagnostic ignored \"-Wunused-value\"") \
|
||||
(__VA_ARGS__); \
|
||||
_Pragma ("GCC diagnostic pop")
|
||||
#else
|
||||
#define printf
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -72,7 +72,8 @@ int run_press_start_demo_timer(s32 timer) {
|
|||
#ifndef QOL_FIXES
|
||||
extern int gDemoInputListID_2;
|
||||
#else
|
||||
|
||||
extern unsigned int gDemoInputListID_2;
|
||||
#endif
|
||||
extern int gPressedStart;
|
||||
|
||||
int start_demo(int timer)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <ultra64.h>
|
||||
|
||||
#include "controller_api.h"
|
||||
|
|
@ -9,14 +10,20 @@ static void tas_init(void) {
|
|||
fp = fopen("cont.m64", "rb");
|
||||
if (fp != NULL) {
|
||||
uint8_t buf[0x400];
|
||||
fread(buf, 1, sizeof(buf), fp);
|
||||
if (fread(buf, 1, sizeof(buf), fp) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
static void tas_read(OSContPad *pad) {
|
||||
if (fp != NULL) {
|
||||
uint8_t bytes[4] = {0};
|
||||
fread(bytes, 1, 4, fp);
|
||||
if (fread(bytes, 1, 4, fp) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
pad->button = (bytes[0] << 8) | bytes[1];
|
||||
pad->stick_x = bytes[2];
|
||||
pad->stick_y = bytes[3];
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ extern void thread5_game_loop(void *arg);
|
|||
extern void create_next_audio_buffer(s16 *samples, u32 num_samples);
|
||||
void game_loop_one_iteration(void);
|
||||
|
||||
void dispatch_audio_sptask(struct SPTask *spTask) {
|
||||
void dispatch_audio_sptask(UNUSED struct SPTask *spTask) {
|
||||
}
|
||||
|
||||
void set_vblank_handler(UNUSED s32 index, UNUSED struct VblankHandler *handler, UNUSED OSMesgQueue *queue, UNUSED OSMesg *msg) {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
CC := gcc
|
||||
CXX := g++
|
||||
CFLAGS := -I../include -I. -Wall -Wextra -Wno-unused-parameter -pedantic -std=c99 -O2 -s
|
||||
CFLAGS := -I../include -I. -Wall -Wextra -pedantic -std=c99 -O2 -s
|
||||
LDFLAGS := -lm
|
||||
PROGRAMS := n64graphics n64graphics_ci mio0 n64cksum textconv patch_libultra_math aifc_decode aiff_extract_codebook vadpcm_enc tabledesign extract_data_for_mio skyconv
|
||||
|
||||
|
|
@ -25,11 +25,11 @@ aifc_decode_SOURCES := aifc_decode.c
|
|||
aiff_extract_codebook_SOURCES := aiff_extract_codebook.c
|
||||
|
||||
tabledesign_SOURCES := sdk-tools/tabledesign/codebook.c sdk-tools/tabledesign/estimate.c sdk-tools/tabledesign/print.c sdk-tools/tabledesign/tabledesign.c
|
||||
tabledesign_CFLAGS := -Iaudiofile -Wno-uninitialized
|
||||
tabledesign_CFLAGS := -Iaudiofile
|
||||
tabledesign_LDFLAGS := -Laudiofile -laudiofile -lstdc++ -lm
|
||||
|
||||
vadpcm_enc_SOURCES := sdk-tools/adpcm/vadpcm_enc.c sdk-tools/adpcm/vpredictor.c sdk-tools/adpcm/quant.c sdk-tools/adpcm/util.c sdk-tools/adpcm/vencode.c
|
||||
vadpcm_enc_CFLAGS := -Wno-unused-result -Wno-uninitialized -Wno-sign-compare -Wno-absolute-value
|
||||
vadpcm_enc_CFLAGS :=
|
||||
|
||||
extract_data_for_mio_SOURCES := extract_data_for_mio.c
|
||||
|
||||
|
|
|
|||
|
|
@ -122,5 +122,5 @@ int main(int argc, char **argv) {
|
|||
fseek(f, filesize - sizeof(hdr), SEEK_CUR);
|
||||
}
|
||||
fclose(f);
|
||||
return 0;
|
||||
return argc;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ IRIX_CC := $(QEMU_IRIX) -silent -L $(IRIX_ROOT) $(IRIX_ROOT)/usr/bin/cc
|
|||
IRIX_CFLAGS := -fullwarn -woff 515,608,658,799 -Wab,-r4300_mul -g -Xcpluscomm -mips1 -o32
|
||||
|
||||
NATIVE_CC := gcc
|
||||
NATIVE_CFLAGS := -g -Wall -O2 -Wno-unused-result -Wno-uninitialized
|
||||
NATIVE_CFLAGS := -g -Wall -O2
|
||||
|
||||
default: native
|
||||
all: irix native
|
||||
|
|
|
|||
|
|
@ -10,12 +10,12 @@ static u32 getshort(FILE *ifile)
|
|||
u32 c1;
|
||||
u32 c2;
|
||||
|
||||
if ((c1 = getc(ifile)) == -1)
|
||||
if ((c1 = getc(ifile)) == (u32)EOF)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((c2 = getc(ifile)) == -1)
|
||||
if ((c2 = getc(ifile)) == (u32)EOF)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -30,7 +30,7 @@ u32 readbits(u32 nbits, FILE *ifile)
|
|||
u32 left;
|
||||
u32 mask;
|
||||
|
||||
if (nbits <= in_bit_pos + 1)
|
||||
if (nbits <= (u32)in_bit_pos + 1)
|
||||
{
|
||||
mask = (1U << nbits) - 1;
|
||||
b = ((u32) input_word >> (in_bit_pos - nbits + 1)) & mask;
|
||||
|
|
@ -60,13 +60,22 @@ char *ReadPString(FILE *ifile)
|
|||
u8 c;
|
||||
char *st;
|
||||
|
||||
fread(&c, 1, 1, ifile);
|
||||
if (fread(&c, 1, 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
st = malloc(c + 1);
|
||||
fread(st, c, 1, ifile);
|
||||
if (fread(st, c, 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
st[c] = '\0';
|
||||
if ((c & 1) == 0)
|
||||
{
|
||||
fread(&c, 1, 1, ifile);
|
||||
if (fread(&c, 1, 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
}
|
||||
return st;
|
||||
}
|
||||
|
|
@ -91,12 +100,18 @@ ALADPCMloop *readlooppoints(FILE *ifile, s16 *nloops)
|
|||
s32 i;
|
||||
ALADPCMloop *al;
|
||||
|
||||
fread(nloops, sizeof(s16), 1, ifile);
|
||||
if (fread(nloops, sizeof(s16), 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16(*nloops)
|
||||
al = malloc(*nloops * sizeof(ALADPCMloop));
|
||||
for (i = 0; i < *nloops; i++)
|
||||
{
|
||||
fread(&al[i], sizeof(ALADPCMloop), 1, ifile);
|
||||
if (fread(&al[i], sizeof(ALADPCMloop), 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP32(al[i].start)
|
||||
BSWAP32(al[i].end)
|
||||
BSWAP32(al[i].count)
|
||||
|
|
|
|||
|
|
@ -212,8 +212,7 @@ s32 main(s32 argc, char **argv)
|
|||
|
||||
if (coefTable == NULL)
|
||||
{
|
||||
// @bug should use progname; argv[0] may be an option
|
||||
fprintf(stderr, "%s: Codebook missing from bitstream [%s]\n", argv[0], argv[1]);
|
||||
fprintf(stderr, "%s: Codebook missing from bitstream [%s]\n", progname, argv[1]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ int main(int argc, char **argv)
|
|||
s16 numMarkers;
|
||||
s16 *inBuffer;
|
||||
s16 ts;
|
||||
s32 minLoopLength = 800;
|
||||
u32 minLoopLength = 800;
|
||||
s32 ***coefTable = NULL;
|
||||
s32 *state;
|
||||
s32 order;
|
||||
|
|
@ -31,10 +31,10 @@ int main(int argc, char **argv)
|
|||
s32 i;
|
||||
s32 j;
|
||||
s32 k;
|
||||
s32 nFrames;
|
||||
u32 nFrames;
|
||||
s32 offset;
|
||||
s32 cChunkPos;
|
||||
s32 currentPos;
|
||||
u32 currentPos;
|
||||
s32 soundPointer = 0;
|
||||
s32 startPointer = 0;
|
||||
s32 startSoundPointer = 0;
|
||||
|
|
@ -53,8 +53,8 @@ int main(int argc, char **argv)
|
|||
SoundDataChunk SndDChunk;
|
||||
InstrumentChunk InstChunk;
|
||||
Loop *loops = NULL;
|
||||
ALADPCMloop *aloops;
|
||||
Marker *markers;
|
||||
ALADPCMloop *aloops = NULL;
|
||||
Marker *markers = NULL;
|
||||
CodeChunk cChunk;
|
||||
char filename[1024];
|
||||
FILE *fhandle;
|
||||
|
|
@ -92,7 +92,7 @@ int main(int argc, char **argv)
|
|||
break;
|
||||
|
||||
case 'l':
|
||||
sscanf(optarg, "%d", &minLoopLength);
|
||||
sscanf(optarg, "%d", (s32 *)&minLoopLength);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
@ -132,15 +132,19 @@ int main(int argc, char **argv)
|
|||
|
||||
inBuffer = malloc(16 * sizeof(s16));
|
||||
|
||||
fread(&FormChunk, sizeof(Chunk), 1, ifile);
|
||||
if (fread(&FormChunk, sizeof(Chunk), 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP32(FormChunk.ckID)
|
||||
BSWAP32(FormChunk.ckSize)
|
||||
BSWAP32(FormChunk.formType)
|
||||
|
||||
// @bug This doesn't check for FORM for AIFF files, probably due to mistaken operator precedence.
|
||||
if (!((FormChunk.ckID == 0x464f524d && // FORM
|
||||
FormChunk.formType == 0x41494643) || // AIFC
|
||||
FormChunk.formType == 0x41494646)) // AIFF
|
||||
// Fixed below
|
||||
if (!(FormChunk.ckID == 0x464f524d && // FORM
|
||||
(FormChunk.formType == 0x41494643 || // AIFC
|
||||
FormChunk.formType == 0x41494646))) // AIFF
|
||||
{
|
||||
fprintf(stderr, "%s: [%s] is not an AIFF-C File\n", progname, argv[1]);
|
||||
exit(1);
|
||||
|
|
@ -198,7 +202,10 @@ int main(int argc, char **argv)
|
|||
|
||||
case 0x53534e44: // SSND
|
||||
offset = ftell(ifile);
|
||||
fread(&SndDChunk, sizeof(SoundDataChunk), 1, ifile);
|
||||
if (fread(&SndDChunk, sizeof(SoundDataChunk), 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP32(SndDChunk.offset)
|
||||
BSWAP32(SndDChunk.blockSize)
|
||||
// The assert error messages specify line numbers 219/220. Match
|
||||
|
|
@ -214,16 +221,25 @@ int main(int argc, char **argv)
|
|||
|
||||
case 0x4d41524b: // MARK
|
||||
offset = ftell(ifile);
|
||||
fread(&numMarkers, sizeof(s16), 1, ifile);
|
||||
if (fread(&numMarkers, sizeof(s16), 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16(numMarkers)
|
||||
markers = malloc(numMarkers * sizeof(Marker));
|
||||
for (i = 0; i < numMarkers; i++)
|
||||
{
|
||||
fread(&markers[i], sizeof(Marker), 1, ifile);
|
||||
if (fread(&markers[i], sizeof(Marker), 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16(markers[i].MarkerID)
|
||||
BSWAP16(markers[i].positionH)
|
||||
BSWAP16(markers[i].positionL)
|
||||
fread(&strnLen, 1, 1, ifile);
|
||||
if (fread(&strnLen, 1, 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
if ((strnLen & 1) != 0)
|
||||
{
|
||||
fseek(ifile, strnLen, SEEK_CUR);
|
||||
|
|
@ -238,7 +254,10 @@ int main(int argc, char **argv)
|
|||
|
||||
case 0x494e5354: // INST
|
||||
offset = ftell(ifile);
|
||||
fread(&InstChunk, sizeof(InstrumentChunk), 1, ifile);
|
||||
if (fread(&InstChunk, sizeof(InstrumentChunk), 1, ifile) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16(InstChunk.sustainLoop.playMode)
|
||||
BSWAP16(InstChunk.sustainLoop.beginLoop)
|
||||
BSWAP16(InstChunk.sustainLoop.endLoop)
|
||||
|
|
@ -414,10 +433,16 @@ int main(int argc, char **argv)
|
|||
}
|
||||
}
|
||||
left = aloops[i].end - currentPos;
|
||||
fread(inBuffer, sizeof(s16), left, ifile);
|
||||
if (fread(inBuffer, sizeof(s16), left, ifile) != (u32)left) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16_MANY(inBuffer, left)
|
||||
fseek(ifile, startPointer, SEEK_SET);
|
||||
fread(inBuffer + left, sizeof(s16), 16 - left, ifile);
|
||||
if (fread(inBuffer + left, sizeof(s16), 16 - left, ifile) != ((u32)16 - left)) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16_MANY(inBuffer + left, 16 - left)
|
||||
vencodeframe(ofile, inBuffer, state, coefTable, order, npredictors, 16);
|
||||
nBytes += 9;
|
||||
|
|
@ -429,7 +454,7 @@ int main(int argc, char **argv)
|
|||
}
|
||||
|
||||
nFrames = (CommChunk.numFramesH << 16) + CommChunk.numFramesL;
|
||||
if ((nloops > 0U) & truncate)
|
||||
if ((nloops > 0) & truncate)
|
||||
{
|
||||
lookupMarker(&loopEnd, loops[nloops - 1].endLoop, markers, numMarkers);
|
||||
nFrames = (loopEnd + 16 < nFrames ? loopEnd + 16 : nFrames);
|
||||
|
|
@ -446,7 +471,7 @@ int main(int argc, char **argv)
|
|||
nsam = 16;
|
||||
}
|
||||
|
||||
if (fread(inBuffer, 2, nsam, ifile) == nsam)
|
||||
if (fread(inBuffer, 2, (u32)nsam, ifile) == (u32)nsam)
|
||||
{
|
||||
BSWAP16_MANY(inBuffer, nsam)
|
||||
vencodeframe(ofile, inBuffer, state, coefTable, order, npredictors, nsam);
|
||||
|
|
|
|||
|
|
@ -9,8 +9,14 @@ s32 readcodebook(FILE *fhandle, s32 ****table, s32 *order, s32 *npredictors)
|
|||
s32 j;
|
||||
s32 k;
|
||||
|
||||
fscanf(fhandle, "%d", order);
|
||||
fscanf(fhandle, "%d", npredictors);
|
||||
if (fscanf(fhandle, "%d", order) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
if (fscanf(fhandle, "%d", npredictors) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
*table = malloc(*npredictors * sizeof(s32 **));
|
||||
for (i = 0; i < *npredictors; i++)
|
||||
{
|
||||
|
|
@ -28,7 +34,10 @@ s32 readcodebook(FILE *fhandle, s32 ****table, s32 *order, s32 *npredictors)
|
|||
{
|
||||
for (k = 0; k < 8; k++)
|
||||
{
|
||||
fscanf(fhandle, "%d", &table_entry[k][j]);
|
||||
if (fscanf(fhandle, "%d", &table_entry[k][j]) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -63,9 +72,15 @@ s32 readaifccodebook(FILE *fhandle, s32 ****table, s16 *order, s16 *npredictors)
|
|||
s32 k;
|
||||
s16 ts;
|
||||
|
||||
fread(order, sizeof(s16), 1, fhandle);
|
||||
if (fread(order, sizeof(s16), 1, fhandle) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16(*order)
|
||||
fread(npredictors, sizeof(s16), 1, fhandle);
|
||||
if (fread(npredictors, sizeof(s16), 1, fhandle) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16(*npredictors)
|
||||
*table = malloc(*npredictors * sizeof(s32 **));
|
||||
for (i = 0; i < *npredictors; i++)
|
||||
|
|
@ -84,7 +99,10 @@ s32 readaifccodebook(FILE *fhandle, s32 ****table, s16 *order, s16 *npredictors)
|
|||
{
|
||||
for (k = 0; k < 8; k++)
|
||||
{
|
||||
fread(&ts, sizeof(s16), 1, fhandle);
|
||||
if (fread(&ts, sizeof(s16), 1, fhandle) != 1) {
|
||||
printf("I/O error occurred.");
|
||||
exit(1);
|
||||
};
|
||||
BSWAP16(ts)
|
||||
table_entry[k][j] = ts;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@ IRIX_CC := $(QEMU_IRIX) -silent -L $(IRIX_ROOT) $(IRIX_ROOT)/usr/bin/cc
|
|||
IRIX_CFLAGS := -fullwarn -Wab,-r4300_mul -Xcpluscomm -mips1 -O2
|
||||
|
||||
NATIVE_CC := gcc
|
||||
NATIVE_CFLAGS := -Wall -Wno-uninitialized -O2
|
||||
NATIVE_CFLAGS := -Wall -O2
|
||||
|
||||
LDFLAGS := -lm -laudiofile
|
||||
|
||||
|
|
|
|||
|
|
@ -244,7 +244,7 @@ void acvect(short *in, int n, int m, double *out)
|
|||
*/
|
||||
int lud(double **a, int n, int *indx, int *d)
|
||||
{
|
||||
int i,imax,j,k;
|
||||
int i,imax=0,j,k;
|
||||
double big,dum,sum,temp;
|
||||
double min,max;
|
||||
double *vv;
|
||||
|
|
|
|||
Loading…
Reference in New Issue