libretro/libretro-common
1
0
Fork 0
mirror of https://github.com/libretro/libretro-common.git synced 2025-04-03 03:51:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update

Browse Source
This commit is contained in:
twinaphex 2016-05-21 13:39:13 +02:00
parent 67f929d652
commit b313b47d8e
20 changed files with 828 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
conversion/float_to_s16.c
View File

@ -28,6 +28,9 @@
#include <altivec.h>
#endif
#include <features/features_cpu.h>
#include <conversion/float_to_s16.h>
/**
* convert_float_to_s16_C:
* @out : output buffer
@ -195,3 +198,20 @@ void convert_float_to_s16_ALLEGREX(int16_t *out,
}
}
#endif
/**
* convert_float_to_s16_init_simd:
*
* Sets up function pointers for conversion
* functions based on CPU features.
**/
void convert_float_to_s16_init_simd(void)
{
unsigned cpu = cpu_features_get();
(void)cpu;
#if defined(__ARM_NEON__) && !defined(VITA)
convert_float_to_s16_arm = (cpu & RETRO_SIMD_NEON) ?
convert_float_to_s16_neon : convert_float_to_s16_C;
#endif
}

15
conversion/s16_to_float.c
View File

@ -21,7 +21,7 @@
#include <boolean.h>
#include <features/features_cpu.h>
#include <conversion/float_to_s16.h>
#include <conversion/s16_to_float.h>
/**
* convert_s16_to_float_C:
@ -224,26 +224,19 @@ void convert_s16_to_float_ALLEGREX(float *out,
}
#endif
static unsigned convert_get_cpu_features(void)
{
return cpu_features_get();
}
/**
* convert_init_simd:
* convert_s16_to_float_init_simd:
*
* Sets up function pointers for conversion
* functions based on CPU features.
**/
void convert_init_simd(void)
void convert_s16_to_float_init_simd(void)
{
unsigned cpu = convert_get_cpu_features();
unsigned cpu = cpu_features_get();
(void)cpu;
#if defined(__ARM_NEON__) && !defined(VITA)
convert_s16_to_float_arm = (cpu & RETRO_SIMD_NEON) ?
convert_s16_to_float_neon : convert_s16_to_float_C;
convert_float_to_s16_arm = (cpu & RETRO_SIMD_NEON) ?
convert_float_to_s16_neon : convert_float_to_s16_C;
#endif
}

157
formats/image_transfer.c
View File

@ -1,3 +1,25 @@
/* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (image_transfer.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdint.h>
#include <string.h>
#include <errno.h>
@ -8,21 +30,24 @@
#ifdef HAVE_RJPEG
#include <formats/rjpeg.h>
#endif
#ifdef HAVE_RTGA
#include <formats/rtga.h>
#endif
#ifdef HAVE_RBMP
#include <formats/rbmp.h>
#endif
#include <formats/image.h>
#if 0
#define DEBUG
#endif
void image_transfer_free(void *data, enum image_type_enum type)
{
#ifdef DEBUG
printf("image_transfer_free\n");
#endif
switch (type)
{
case IMAGE_TYPE_TGA:
#ifdef HAVE_RTGA
rtga_free((rtga_t*)data);
#endif
break;
case IMAGE_TYPE_PNG:
#ifdef HAVE_RPNG
rpng_free((rpng_t*)data);
@ -33,15 +58,18 @@ void image_transfer_free(void *data, enum image_type_enum type)
rjpeg_free((rjpeg_t*)data);
#endif
break;
case IMAGE_TYPE_BMP:
#ifdef HAVE_RBMP
rbmp_free((rbmp_t*)data);
#endif
break;
case IMAGE_TYPE_NONE:
break;
}
}
void *image_transfer_new(enum image_type_enum type)
{
#ifdef DEBUG
printf("image_transfer_new\n");
#endif
switch (type)
{
case IMAGE_TYPE_PNG:
@ -55,6 +83,12 @@ void *image_transfer_new(enum image_type_enum type)
return rjpeg_alloc();
#else
break;
#endif
case IMAGE_TYPE_BMP:
#ifdef HAVE_RBMP
return rbmp_alloc();
#else
break;
#endif
default:
break;
@ -65,25 +99,67 @@ void *image_transfer_new(enum image_type_enum type)
bool image_transfer_start(void *data, enum image_type_enum type)
{
#ifdef DEBUG
printf("image_transfer_start\n");
#endif
switch (type)
{
case IMAGE_TYPE_PNG:
#ifdef HAVE_RPNG
if (!rpng_start((rpng_t*)data))
return false;
#endif
break;
return true;
#else
break;
#endif
case IMAGE_TYPE_JPEG:
#ifdef HAVE_RJPEG
return true;
#endif
break;
case IMAGE_TYPE_TGA:
#ifdef HAVE_RTGA
return true;
#endif
break;
case IMAGE_TYPE_BMP:
return true;
case IMAGE_TYPE_NONE:
break;
}
return true;
return false;
}
bool image_transfer_is_valid(
void *data,
enum image_type_enum type)
{
switch (type)
{
case IMAGE_TYPE_PNG:
#ifdef HAVE_RPNG
return rpng_is_valid((rpng_t*)data);
#else
break;
#endif
case IMAGE_TYPE_JPEG:
#ifdef HAVE_RJPEG
return true;
#else
break;
#endif
case IMAGE_TYPE_TGA:
#ifdef HAVE_RTGA
return true;
#else
break;
#endif
case IMAGE_TYPE_BMP:
return true;
case IMAGE_TYPE_NONE:
break;
}
return false;
}
void image_transfer_set_buffer_ptr(
@ -103,6 +179,18 @@ void image_transfer_set_buffer_ptr(
rjpeg_set_buf_ptr((rjpeg_t*)data, (uint8_t*)ptr);
#endif
break;
case IMAGE_TYPE_TGA:
#ifdef HAVE_RTGA
rtga_set_buf_ptr((rtga_t*)data, (uint8_t*)ptr);
#endif
break;
case IMAGE_TYPE_BMP:
#ifdef HAVE_RBMP
rbmp_set_buf_ptr((rbmp_t*)data, (uint8_t*)ptr);
#endif
break;
case IMAGE_TYPE_NONE:
break;
}
}
@ -112,10 +200,6 @@ int image_transfer_process(
uint32_t **buf, size_t len,
unsigned *width, unsigned *height)
{
#ifdef DEBUG
printf("image_transfer_process\n");
#endif
switch (type)
{
case IMAGE_TYPE_PNG:
@ -136,6 +220,22 @@ int image_transfer_process(
#else
break;
#endif
case IMAGE_TYPE_TGA:
#ifdef HAVE_RTGA
return rtga_process_image((rtga_t*)data,
(void**)buf, len, width, height);
#else
break;
#endif
case IMAGE_TYPE_BMP:
#ifdef HAVE_RBMP
return rbmp_process_image((rbmp_t*)data,
(void**)buf, len, width, height);
#else
break;
#endif
case IMAGE_TYPE_NONE:
break;
}
return 0;
@ -143,9 +243,6 @@ int image_transfer_process(
bool image_transfer_iterate(void *data, enum image_type_enum type)
{
#ifdef DEBUG
printf("image_transfer_iterate\n");
#endif
switch (type)
{
@ -161,6 +258,16 @@ bool image_transfer_iterate(void *data, enum image_type_enum type)
#else
break;
#endif
case IMAGE_TYPE_TGA:
#ifdef HAVE_RTGA
return false;
#else
break;
#endif
case IMAGE_TYPE_BMP:
return false;
case IMAGE_TYPE_NONE:
return false;
}
return true;

115
formats/jpeg/rjpeg.c
View File

@ -20,8 +20,7 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* Modified version of stb_image's JPEG sources.
*/
/* Modified version of stb_image's JPEG sources. */
#include <stdint.h>
#include <stdarg.h>
@ -157,47 +156,18 @@ typedef struct
uint8_t *img_buffer_original;
} rjpeg__context;
/* initialize a memory-decode context */
static void rjpeg__start_mem(rjpeg__context *s, const uint8_t *buffer, int len)
{
s->io.read = NULL;
s->read_from_callbacks = 0;
s->img_buffer = s->img_buffer_original = (uint8_t *) buffer;
s->img_buffer_end = (uint8_t *) buffer+len;
}
static uint8_t *rjpeg__jpeg_load(rjpeg__context *s, unsigned *x, unsigned *y, int *comp, int req_comp);
/* this is not threadsafe */
static const char *rjpeg__g_failure_reason;
static INLINE int rjpeg__err(const char *str)
{
rjpeg__g_failure_reason = str;
return 0;
}
#ifdef RJPEG_NO_FAILURE_STRINGS
#define rjpeg__err(x,y) 0
#elif defined(RJPEG_FAILURE_USERMSG)
#define rjpeg__err(x,y) rjpeg__err(y)
#else
#define rjpeg__err(x,y) rjpeg__err(x)
#endif
#define rjpeg__err(x,y) 0
#define rjpeg__errpf(x,y) ((float *) (rjpeg__err(x,y)?NULL:NULL))
#define rjpeg__errpuc(x,y) ((unsigned char *) (rjpeg__err(x,y)?NULL:NULL))
static int rjpeg__vertically_flip_on_load = 0;
static unsigned char *rjpeg__load_main(rjpeg__context *s, unsigned *x, unsigned *y, int *comp, int req_comp)
{
return rjpeg__jpeg_load(s,x,y,comp,req_comp);
}
static unsigned char *rjpeg__load_flip(rjpeg__context *s, unsigned *x, unsigned *y, int *comp, int req_comp)
{
unsigned char *result = rjpeg__load_main(s, x, y, comp, req_comp);
unsigned char *result = rjpeg__jpeg_load(s,x,y,comp,req_comp);
if (rjpeg__vertically_flip_on_load && result != NULL)
{
@ -225,7 +195,10 @@ static unsigned char *rjpeg__load_flip(rjpeg__context *s, unsigned *x, unsigned
static uint8_t *rjpeg_load_from_memory(const uint8_t *buffer, int len, unsigned *x, unsigned *y, int *comp, int req_comp)
{
rjpeg__context s;
rjpeg__start_mem(&s,buffer,len);
s.io.read = NULL;
s.read_from_callbacks = 0;
s.img_buffer = s.img_buffer_original = (uint8_t *) buffer;
s.img_buffer_end = (uint8_t *) buffer+len;
return rjpeg__load_flip(&s,x,y,comp,req_comp);
}
@ -398,15 +371,14 @@ typedef struct
#define RJPEG__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7)
/* use comparisons since in some cases we handle more than one case (e.g. SOF) */
#define rjpeg__DNL(x) ((x) == 0xdc)
#define rjpeg__SOI(x) ((x) == 0xd8)
#define rjpeg__EOI(x) ((x) == 0xd9)
#define rjpeg__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2)
#define rjpeg__SOS(x) ((x) == 0xda)
#define rjpeg__SOF_progressive(x) ((x) == 0xc2)
#define rjpeg__div4(x) ((uint8_t) ((x) >> 2))
#define rjpeg__div16(x) ((uint8_t) ((x) >> 4))
#define rjpeg__div4(x) ((uint8_t) ((x) >> 2))
#define rjpeg__div16(x) ((uint8_t) ((x) >> 4))
static int rjpeg__build_huffman(rjpeg__huffman *h, int *count)
{
@ -464,6 +436,7 @@ static void rjpeg__build_fast_ac(int16_t *fast_ac, rjpeg__huffman *h)
for (i=0; i < (1 << FAST_BITS); ++i)
{
uint8_t fast = h->fast[i];
fast_ac[i] = 0;
if (fast < 255)
@ -478,7 +451,9 @@ static void rjpeg__build_fast_ac(int16_t *fast_ac, rjpeg__huffman *h)
/* magnitude code followed by receive_extend code */
int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits);
int m = 1 << (magbits - 1);
if (k < m) k += (-1 << magbits) + 1;
if (k < m)
k += (-1 << magbits) + 1;
/* if the result is small enough, we can fit it in fast_ac table */
if (k >= -128 && k <= 127)
fast_ac[i] = (int16_t) ((k << 8) + (run << 4) + (len + magbits));
@ -638,7 +613,8 @@ static int rjpeg__jpeg_decode_block(
int diff,dc,k;
int t;
if (j->code_bits < 16) rjpeg__grow_buffer_unsafe(j);
if (j->code_bits < 16)
rjpeg__grow_buffer_unsafe(j);
t = rjpeg__jpeg_huff_decode(j, hdc);
if (t < 0)
return rjpeg__err("bad huffman code","Corrupt JPEG");
@ -675,12 +651,14 @@ static int rjpeg__jpeg_decode_block(
else
{
int rs = rjpeg__jpeg_huff_decode(j, hac);
if (rs < 0) return rjpeg__err("bad huffman code","Corrupt JPEG");
if (rs < 0)
return rjpeg__err("bad huffman code","Corrupt JPEG");
s = rs & 15;
r = rs >> 4;
if (s == 0)
{
if (rs != 0xf0) break; /* end block */
if (rs != 0xf0)
break; /* end block */
k += 16;
}
else
@ -709,8 +687,8 @@ static int rjpeg__jpeg_decode_block_prog_dc(
if (j->succ_high == 0)
{
int diff,dc;
int t;
int diff,dc;
/* first scan for DC coefficient, must be first */
memset(data,0,64*sizeof(data[0])); /* 0 all the ac values now */
@ -1871,8 +1849,13 @@ static int rjpeg__decode_jpeg_header(rjpeg__jpeg *z, int scan)
int m;
z->marker = RJPEG__MARKER_none; /* initialize cached marker to empty */
m = rjpeg__get_marker(z);
if (!rjpeg__SOI(m)) return rjpeg__err("no SOI","Corrupt JPEG");
if (scan == RJPEG_SCAN_TYPE) return 1;
if (!rjpeg__SOI(m))
return rjpeg__err("no SOI","Corrupt JPEG");
if (scan == RJPEG_SCAN_TYPE)
return 1;
m = rjpeg__get_marker(z);
while (!rjpeg__SOF(m))
{
@ -1882,7 +1865,8 @@ static int rjpeg__decode_jpeg_header(rjpeg__jpeg *z, int scan)
while (m == RJPEG__MARKER_none)
{
/* some files have extra padding after their blocks, so ok, we'll scan */
if (rjpeg__at_eof(z->s)) return rjpeg__err("no SOF", "Corrupt JPEG");
if (rjpeg__at_eof(z->s))
return rjpeg__err("no SOF", "Corrupt JPEG");
m = rjpeg__get_marker(z);
}
}
@ -1945,8 +1929,6 @@ static int rjpeg__decode_jpeg_image(rjpeg__jpeg *j)
/* static jfif-centered resampling (across block boundaries) */
static uint8_t *rjpeg_resample_row_1(uint8_t *out, uint8_t *in_near, uint8_t *in_far, int w, int hs)
{
(void)out;
@ -2070,7 +2052,7 @@ static uint8_t *rjpeg__resample_row_hv_2_simd(uint8_t *out, uint8_t *in_near, ui
* even pixels = 3*cur + prev = cur*4 + (prev - cur)
* odd pixels = 3*cur + next = cur*4 + (next - cur)
* note the shared term. */
__m128i bias = _mm_set1_epi16(8);
__m128i bias = _mm_set1_epi16(8);
__m128i curs = _mm_slli_epi16(curr, 2);
__m128i prvd = _mm_sub_epi16(prev, curr);
__m128i nxtd = _mm_sub_epi16(next, curr);
@ -2171,12 +2153,11 @@ static void rjpeg__YCbCr_to_RGB_row(uint8_t *out, const uint8_t *y, const uint8_
for (i=0; i < count; ++i)
{
int y_fixed = (y[i] << 20) + (1<<19); /* rounding */
int r,g,b;
int cr = pcr[i] - 128;
int cb = pcb[i] - 128;
r = y_fixed + cr* float2fixed(1.40200f);
g = y_fixed + (cr*-float2fixed(0.71414f)) + ((cb*-float2fixed(0.34414f)) & 0xffff0000);
b = y_fixed + cb* float2fixed(1.77200f);
int r = y_fixed + cr* float2fixed(1.40200f);
int g = y_fixed + (cr*-float2fixed(0.71414f)) + ((cb*-float2fixed(0.34414f)) & 0xffff0000);
int b = y_fixed + cb* float2fixed(1.77200f);
r >>= 20;
g >>= 20;
b >>= 20;
@ -2580,36 +2561,6 @@ int rjpeg_process_image(rjpeg_t *rjpeg, void **buf_data,
return IMAGE_PROCESS_END;
}
bool rjpeg_image_load(uint8_t *buf, void *data, size_t size,
unsigned a_shift, unsigned r_shift,
unsigned g_shift, unsigned b_shift)
{
unsigned width = 0;
unsigned height = 0;
struct texture_image *out_img = (struct texture_image*)data;
rjpeg_t *rjpeg = rjpeg_alloc();
if (!rjpeg)
goto error;
if (!rjpeg_set_buf_ptr(rjpeg, &buf))
goto error;
if (rjpeg_process_image(rjpeg, (void**)&buf, size, &width, &height) != IMAGE_PROCESS_END)
goto error;
out_img->pixels = (uint32_t*)rjpeg->output_image;
out_img->width = width;
out_img->height = height;
return true;
error:
if (rjpeg)
free(rjpeg);
return false;
}
bool rjpeg_set_buf_ptr(rjpeg_t *rjpeg, void *data)
{
if (!rjpeg)

174
formats/png/rpng.c
View File

@ -30,6 +30,7 @@
#endif
#include <boolean.h>
#include <formats/image.h>
#include <formats/rpng.h>
#include <file/archive_file.h>
@ -84,9 +85,8 @@ struct png_chunk
uint8_t *data;
};
struct rpng_process_t
struct rpng_process
{
bool initialized;
bool inflate_initialized;
bool adam7_pass_initialized;
bool pass_initialized;
@ -116,7 +116,7 @@ struct rpng_process_t
struct rpng
{
struct rpng_process_t process;
struct rpng_process *process;
bool has_ihdr;
bool has_idat;
bool has_iend;
@ -127,14 +127,6 @@ struct rpng
uint32_t palette[256];
};
enum png_process_code
{
PNG_PROCESS_ERROR = -2,
PNG_PROCESS_ERROR_END = -1,
PNG_PROCESS_NEXT = 0,
PNG_PROCESS_END = 1
};
static INLINE uint32_t dword_be(const uint8_t *buf)
{
return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | (buf[3] << 0);
@ -409,7 +401,7 @@ static void png_reverse_filter_adam7_deinterlace_pass(uint32_t *data,
}
}
static void png_reverse_filter_deinit(struct rpng_process_t *pngp)
static void png_reverse_filter_deinit(struct rpng_process *pngp)
{
if (pngp->decoded_scanline)
free(pngp->decoded_scanline);
@ -433,7 +425,7 @@ static const struct adam7_pass passes[] = {
};
static int png_reverse_filter_init(const struct png_ihdr *ihdr,
struct rpng_process_t *pngp)
struct rpng_process *pngp)
{
size_t pass_size;
@ -499,7 +491,7 @@ error:
}
static int png_reverse_filter_copy_line(uint32_t *data, const struct png_ihdr *ihdr,
struct rpng_process_t *pngp, unsigned filter)
struct rpng_process *pngp, unsigned filter)
{
unsigned i;
@ -539,7 +531,7 @@ static int png_reverse_filter_copy_line(uint32_t *data, const struct png_ihdr *i
break;
default:
return PNG_PROCESS_ERROR_END;
return IMAGE_PROCESS_ERROR_END;
}
switch (ihdr->color_type)
@ -565,13 +557,13 @@ static int png_reverse_filter_copy_line(uint32_t *data, const struct png_ihdr *i
memcpy(pngp->prev_scanline, pngp->decoded_scanline, pngp->pitch);
return PNG_PROCESS_NEXT;
return IMAGE_PROCESS_NEXT;
}
static int png_reverse_filter_regular_iterate(uint32_t **data, const struct png_ihdr *ihdr,
struct rpng_process_t *pngp)
struct rpng_process *pngp)
{
int ret = PNG_PROCESS_END;
int ret = IMAGE_PROCESS_END;
if (pngp->h < ihdr->height)
{
@ -581,7 +573,7 @@ static int png_reverse_filter_regular_iterate(uint32_t **data, const struct png_
ihdr, pngp, filter);
}
if (ret == PNG_PROCESS_END || ret == PNG_PROCESS_ERROR_END)
if (ret == IMAGE_PROCESS_END || ret == IMAGE_PROCESS_ERROR_END)
goto end;
pngp->h++;
@ -591,7 +583,7 @@ static int png_reverse_filter_regular_iterate(uint32_t **data, const struct png_
*data += ihdr->width;
pngp->data_restore_buf_size += ihdr->width;
return PNG_PROCESS_NEXT;
return IMAGE_PROCESS_NEXT;
end:
png_reverse_filter_deinit(pngp);
@ -604,32 +596,32 @@ end:
static int png_reverse_filter_adam7_iterate(uint32_t **data_,
const struct png_ihdr *ihdr,
struct rpng_process_t *pngp)
struct rpng_process *pngp)
{
int ret = 0;
bool to_next = pngp->pass.pos < ARRAY_SIZE(passes);
uint32_t *data = *data_;
if (!to_next)
return PNG_PROCESS_END;
return IMAGE_PROCESS_END;
ret = png_reverse_filter_init(ihdr, pngp);
if (ret == 1)
return PNG_PROCESS_NEXT;
return IMAGE_PROCESS_NEXT;
if (ret == -1)
return PNG_PROCESS_ERROR_END;
return IMAGE_PROCESS_ERROR_END;
if (png_reverse_filter_init(&pngp->ihdr, pngp) == -1)
return PNG_PROCESS_ERROR;
return IMAGE_PROCESS_ERROR;
do{
ret = png_reverse_filter_regular_iterate(&pngp->data,
&pngp->ihdr, pngp);
}while(ret == PNG_PROCESS_NEXT);
}while(ret == IMAGE_PROCESS_NEXT);
if (ret == PNG_PROCESS_ERROR || ret == PNG_PROCESS_ERROR_END)
return PNG_PROCESS_ERROR;
if (ret == IMAGE_PROCESS_ERROR || ret == IMAGE_PROCESS_ERROR_END)
return IMAGE_PROCESS_ERROR;
pngp->inflate_buf += pngp->pass.size;
pngp->adam7_restore_buf_size += pngp->pass.size;
@ -646,25 +638,25 @@ static int png_reverse_filter_adam7_iterate(uint32_t **data_,
pngp->pass.size = 0;
pngp->adam7_pass_initialized = false;
return PNG_PROCESS_NEXT;
return IMAGE_PROCESS_NEXT;
}
static int png_reverse_filter_adam7(uint32_t **data_,
const struct png_ihdr *ihdr,
struct rpng_process_t *pngp)
struct rpng_process *pngp)
{
int ret = png_reverse_filter_adam7_iterate(data_,
ihdr, pngp);
switch (ret)
{
case PNG_PROCESS_ERROR_END:
case PNG_PROCESS_END:
case IMAGE_PROCESS_ERROR_END:
case IMAGE_PROCESS_END:
break;
case PNG_PROCESS_NEXT:
case IMAGE_PROCESS_NEXT:
pngp->pass.pos++;
return 0;
case PNG_PROCESS_ERROR:
case IMAGE_PROCESS_ERROR:
if (pngp->data)
free(pngp->data);
pngp->inflate_buf -= pngp->adam7_restore_buf_size;
@ -683,22 +675,23 @@ static int png_reverse_filter_iterate(rpng_t *rpng, uint32_t **data)
return false;
if (rpng->ihdr.interlace)
return png_reverse_filter_adam7(data, &rpng->ihdr, &rpng->process);
return png_reverse_filter_adam7(data, &rpng->ihdr, rpng->process);
return png_reverse_filter_regular_iterate(data, &rpng->ihdr, &rpng->process);
return png_reverse_filter_regular_iterate(data, &rpng->ihdr, rpng->process);
}
static int rpng_load_image_argb_process_inflate_init(rpng_t *rpng,
uint32_t **data, unsigned *width, unsigned *height)
{
int zstatus;
bool to_continue = (rpng->process.stream_backend->stream_get_avail_in(rpng->process.stream) > 0
&& rpng->process.stream_backend->stream_get_avail_out(rpng->process.stream) > 0);
struct rpng_process *process = (struct rpng_process*)rpng->process;
bool to_continue = (process->stream_backend->stream_get_avail_in(process->stream) > 0
&& process->stream_backend->stream_get_avail_out(process->stream) > 0);
if (!to_continue)
goto end;
zstatus = rpng->process.stream_backend->stream_decompress_data_to_file_iterate(rpng->process.stream);
zstatus = process->stream_backend->stream_decompress_data_to_file_iterate(process->stream);
switch (zstatus)
{
@ -713,7 +706,7 @@ static int rpng_load_image_argb_process_inflate_init(rpng_t *rpng,
return 0;
end:
rpng->process.stream_backend->stream_free(rpng->process.stream);
process->stream_backend->stream_free(process->stream);
*width = rpng->ihdr.width;
*height = rpng->ihdr.height;
@ -728,22 +721,20 @@ end:
if (!*data)
goto false_end;
rpng->process.adam7_restore_buf_size = 0;
rpng->process.restore_buf_size = 0;
rpng->process.palette = rpng->palette;
process->adam7_restore_buf_size = 0;
process->restore_buf_size = 0;
process->palette = rpng->palette;
if (rpng->ihdr.interlace != 1)
if (png_reverse_filter_init(&rpng->ihdr, &rpng->process) == -1)
if (png_reverse_filter_init(&rpng->ihdr, process) == -1)
goto false_end;
rpng->process.inflate_initialized = true;
process->inflate_initialized = true;
return 1;
error:
rpng->process.stream_backend->stream_free(rpng->process.stream);
false_end:
rpng->process.inflate_initialized = false;
process->inflate_initialized = false;
return -1;
}
@ -774,39 +765,43 @@ bool png_realloc_idat(const struct png_chunk *chunk, struct idat_buffer *buf)
return true;
}
static bool rpng_load_image_argb_process_init(rpng_t *rpng,
static struct rpng_process *rpng_process_init(rpng_t *rpng,
uint32_t **data, unsigned *width, unsigned *height)
{
rpng->process.inflate_buf_size = 0;
rpng->process.inflate_buf = NULL;
uint8_t *inflate_buf = NULL;
struct rpng_process *process = (struct rpng_process*)calloc(1, sizeof(*process));
if (!process)
return NULL;
process->stream_backend = file_archive_get_default_file_backend();
png_pass_geom(&rpng->ihdr, rpng->ihdr.width,
rpng->ihdr.height, NULL, NULL, &rpng->process.inflate_buf_size);
rpng->ihdr.height, NULL, NULL, &process->inflate_buf_size);
if (rpng->ihdr.interlace == 1) /* To be sure. */
rpng->process.inflate_buf_size *= 2;
process->inflate_buf_size *= 2;
rpng->process.stream = rpng->process.stream_backend->stream_new();
process->stream = process->stream_backend->stream_new();
if (!rpng->process.stream)
return false;
if (!process->stream)
return NULL;
if (!rpng->process.stream_backend->stream_decompress_init(rpng->process.stream))
return false;
if (!process->stream_backend->stream_decompress_init(process->stream))
return NULL;
rpng->process.inflate_buf = (uint8_t*)malloc(rpng->process.inflate_buf_size);
if (!rpng->process.inflate_buf)
return false;
inflate_buf = (uint8_t*)malloc(process->inflate_buf_size);
if (!inflate_buf)
return NULL;
rpng->process.stream_backend->stream_set(
rpng->process.stream,
process->inflate_buf = inflate_buf;
process->stream_backend->stream_set(
process->stream,
rpng->idat_buf.size,
rpng->process.inflate_buf_size,
process->inflate_buf_size,
rpng->idat_buf.data,
rpng->process.inflate_buf);
process->inflate_buf);
rpng->process.initialized = true;
return true;
return process;
}
static bool read_chunk_header(uint8_t *buf, struct png_chunk *chunk)
@ -949,26 +944,38 @@ int rpng_process_image(rpng_t *rpng,
(void)size;
if (!rpng->process.initialized)
if (!rpng->process)
{
if (!rpng->process.stream_backend)
rpng->process.stream_backend = file_archive_get_default_file_backend();
struct rpng_process *process = rpng_process_init(
rpng, data, width, height);
if (!rpng_load_image_argb_process_init(rpng, data, width,
height))
return PNG_PROCESS_ERROR;
if (!process)
goto error;
rpng->process = process;
return 0;
}
if (!rpng->process.inflate_initialized)
if (!rpng->process->inflate_initialized)
{
if (rpng_load_image_argb_process_inflate_init(rpng, data,
width, height) == -1)
return PNG_PROCESS_ERROR;
goto error;
return 0;
}
return png_reverse_filter_iterate(rpng, data);
error:
if (rpng->process)
{
if (rpng->process->inflate_buf)
free(rpng->process->inflate_buf);
if (rpng->process->stream)
rpng->process->stream_backend->stream_free(rpng->process->stream);
free(rpng->process);
}
return IMAGE_PROCESS_ERROR;
}
void rpng_free(rpng_t *rpng)
@ -978,12 +985,17 @@ void rpng_free(rpng_t *rpng)
if (rpng->idat_buf.data)
free(rpng->idat_buf.data);
if (rpng->process.inflate_buf)
free(rpng->process.inflate_buf);
if (rpng->process.stream)
if (rpng->process)
{
rpng->process.stream_backend->stream_free(rpng->process.stream);
free(rpng->process.stream);
if (rpng->process->inflate_buf)
free(rpng->process->inflate_buf);
if (rpng->process->stream)
{
if (rpng->process->stream_backend)
rpng->process->stream_backend->stream_free(rpng->process->stream);
free(rpng->process->stream);
}
free(rpng->process);
}
free(rpng);

1
formats/png/rpng_encode.c
View File

@ -25,6 +25,7 @@
#include <string.h>
#include <streams/file_stream.h>
#include <file/archive_file.h>
#include "rpng_internal.h"

529
formats/tga/rtga.c
View File

@ -1,103 +1,482 @@
/* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (rtga.c).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdarg.h>
#include <stddef.h> /* ptrdiff_t on osx */
#include <stdlib.h>
#include <string.h>
#include <formats/tga.h>
#include <retro_assert.h>
#include <retro_inline.h>
#include <formats/image.h>
#include <formats/rtga.h>
bool rtga_image_load_shift(uint8_t *buf,
void *data,
unsigned a_shift, unsigned r_shift,
unsigned g_shift, unsigned b_shift)
struct rtga
{
unsigned i, bits, size, bits_mul;
uint8_t info[6] = {0};
unsigned width = 0;
unsigned height = 0;
const uint8_t *tmp = NULL;
struct texture_image *out_img = (struct texture_image*)data;
uint8_t *buff_data;
uint32_t *output_image;
void *empty;
};
if (!buf || buf[2] != 2)
typedef struct
{
int (*read) (void *user,char *data,int size); /* fill 'data' with 'size' bytes. return number of bytes actually read */
void (*skip) (void *user,int n); /* skip the next 'n' bytes, or 'unget' the last -n bytes if negative */
int (*eof) (void *user); /* returns nonzero if we are at end of file/data */
} rtga_io_callbacks;
typedef struct
{
uint32_t img_x, img_y;
int img_n, img_out_n;
rtga_io_callbacks io;
void *io_user_data;
int read_from_callbacks;
int buflen;
uint8_t buffer_start[128];
uint8_t *img_buffer, *img_buffer_end;
uint8_t *img_buffer_original;
} rtga__context;
static void rtga__refill_buffer(rtga__context *s);
static void rtga__start_mem(rtga__context *s, uint8_t const *buffer, int len)
{
s->io.read = NULL;
s->read_from_callbacks = 0;
s->img_buffer = s->img_buffer_original = (uint8_t *) buffer;
s->img_buffer_end = (uint8_t *) buffer+len;
}
static uint8_t *rtga__tga_load(rtga__context *s, unsigned *x, unsigned *y, int *comp, int req_comp);
#define rtga__err(x,y) 0
#define rtga__errpf(x,y) ((float *) (rtga__err(x,y)?NULL:NULL))
#define rtga__errpuc(x,y) ((unsigned char *) (rtga__err(x,y)?NULL:NULL))
static uint8_t *rtga_load_from_memory(uint8_t const *buffer, int len, unsigned *x, unsigned *y, int *comp, int req_comp)
{
rtga__context s;
rtga__start_mem(&s,buffer,len);
return rtga__tga_load(&s,x,y,comp,req_comp);
}
static void rtga__refill_buffer(rtga__context *s)
{
int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
if (n == 0)
{
fprintf(stderr, "TGA image is not uncompressed RGB.\n");
goto error;
/* at end of file, treat same as if from memory, but need to handle case
* where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file */
s->read_from_callbacks = 0;
s->img_buffer = s->buffer_start;
s->img_buffer_end = s->buffer_start+1;
*s->img_buffer = 0;
} else {
s->img_buffer = s->buffer_start;
s->img_buffer_end = s->buffer_start + n;
}
}
static INLINE uint8_t rtga__get8(rtga__context *s)
{
if (s->img_buffer < s->img_buffer_end)
return *s->img_buffer++;
if (s->read_from_callbacks) {
rtga__refill_buffer(s);
return *s->img_buffer++;
}
return 0;
}
static void rtga__skip(rtga__context *s, int n)
{
if (n < 0) {
s->img_buffer = s->img_buffer_end;
return;
}
if (s->io.read) {
int blen = (int) (s->img_buffer_end - s->img_buffer);
if (blen < n) {
s->img_buffer = s->img_buffer_end;
(s->io.skip)(s->io_user_data, n - blen);
return;
}
}
s->img_buffer += n;
}
static int rtga__getn(rtga__context *s, uint8_t *buffer, int n)
{
if (s->io.read) {
int blen = (int) (s->img_buffer_end - s->img_buffer);
if (blen < n) {
int res, count;
memcpy(buffer, s->img_buffer, blen);
count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
res = (count == (n-blen));
s->img_buffer = s->img_buffer_end;
return res;
}
}
memcpy(info, buf + 12, 6);
if (s->img_buffer+n <= s->img_buffer_end) {
memcpy(buffer, s->img_buffer, n);
s->img_buffer += n;
return 1;
} else
return 0;
}
width = info[0] + ((unsigned)info[1] * 256);
height = info[2] + ((unsigned)info[3] * 256);
bits = info[4];
static int rtga__get16le(rtga__context *s)
{
int z = rtga__get8(s);
return z + (rtga__get8(s) << 8);
}
fprintf(stderr, "Loaded TGA: (%ux%u @ %u bpp)\n", width, height, bits);
static uint8_t rtga__compute_y(int r, int g, int b)
{
return (uint8_t) (((r*77) + (g*150) + (29*b)) >> 8);
}
size = width * height * sizeof(uint32_t);
out_img->pixels = (uint32_t*)malloc(size);
out_img->width = width;
out_img->height = height;
static unsigned char *rtga__convert_format(
unsigned char *data,
int img_n,
int req_comp,
unsigned int x,
unsigned int y)
{
int i,j;
unsigned char *good;
if (!out_img->pixels)
if (req_comp == img_n) return data;
retro_assert(req_comp >= 1 && req_comp <= 4);
good = (unsigned char *) malloc(req_comp * x * y);
if (good == NULL)
{
fprintf(stderr, "Failed to allocate TGA pixels.\n");
goto error;
free(data);
return rtga__errpuc("outofmem", "Out of memory");
}
tmp = buf + 18;
bits_mul = 3;
if (bits != 32 && bits != 24)
for (j=0; j < (int) y; ++j)
{
fprintf(stderr, "Bit depth of TGA image is wrong. Only 32-bit and 24-bit supported.\n");
goto error;
unsigned char *src = data + j * x * img_n ;
unsigned char *dest = good + j * x * req_comp;
switch (((img_n)*8+(req_comp)))
{
case ((1)*8+(2)):
for(i=x-1; i >= 0; --i, src += 1, dest += 2)
dest[0]=src[0], dest[1]=255;
break;
case ((1)*8+(3)):
for(i=x-1; i >= 0; --i, src += 1, dest += 3)
dest[0]=dest[1]=dest[2]=src[0];
break;
case ((1)*8+(4)):
for(i=x-1; i >= 0; --i, src += 1, dest += 4)
dest[0]=dest[1]=dest[2]=src[0], dest[3]=255;
break;
case ((2)*8+(1)):
for(i=x-1; i >= 0; --i, src += 2, dest += 1)
dest[0]=src[0];
break;
case ((2)*8+(3)):
for(i=x-1; i >= 0; --i, src += 2, dest += 3)
dest[0]=dest[1]=dest[2]=src[0];
break;
case ((2)*8+(4)):
for(i=x-1; i >= 0; --i, src += 2, dest += 4)
dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1];
break;
case ((3)*8+(4)):
for(i=x-1; i >= 0; --i, src += 3, dest += 4)
dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255;
break;
case ((3)*8+(1)):
for(i=x-1; i >= 0; --i, src += 3, dest += 1)
dest[0]=rtga__compute_y(src[0],src[1],src[2]);
break;
case ((3)*8+(2)):
for(i=x-1; i >= 0; --i, src += 3, dest += 2)
dest[0]=rtga__compute_y(src[0],src[1],src[2]), dest[1] = 255;
break;
case ((4)*8+(1)):
for(i=x-1; i >= 0; --i, src += 4, dest += 1)
dest[0]=rtga__compute_y(src[0],src[1],src[2]);
break;
case ((4)*8+(2)):
for(i=x-1; i >= 0; --i, src += 4, dest += 2)
dest[0]=rtga__compute_y(src[0],src[1],src[2]), dest[1] = src[3];
break;
case ((4)*8+(3)):
for(i=x-1; i >= 0; --i, src += 4, dest += 3)
dest[0]=src[0],dest[1]=src[1],dest[2]=src[2];
break;
default:
retro_assert(0);
break;
}
}
if (bits == 32)
bits_mul = 4;
free(data);
return good;
}
for (i = 0; i < width * height; i++)
static uint8_t *rtga__tga_load(rtga__context *s, unsigned *x, unsigned *y, int *comp, int req_comp)
{
/* Read in the TGA header stuff */
int tga_offset = rtga__get8(s);
int tga_indexed = rtga__get8(s);
int tga_image_type = rtga__get8(s);
int tga_is_RLE = 0;
int tga_palette_start = rtga__get16le(s);
int tga_palette_len = rtga__get16le(s);
int tga_palette_bits = rtga__get8(s);
int tga_x_origin = rtga__get16le(s);
int tga_y_origin = rtga__get16le(s);
int tga_width = rtga__get16le(s);
int tga_height = rtga__get16le(s);
int tga_bits_per_pixel = rtga__get8(s);
int tga_comp = tga_bits_per_pixel / 8;
int tga_inverted = rtga__get8(s);
/* image data */
unsigned char *tga_data;
unsigned char *tga_palette = NULL;
int i, j;
unsigned char raw_data[4] = {0};
int RLE_count = 0;
int RLE_repeating = 0;
int read_next_pixel = 1;
/* do a tiny bit of precessing */
if ( tga_image_type >= 8 )
{
uint32_t b = tmp[i * bits_mul + 0];
uint32_t g = tmp[i * bits_mul + 1];
uint32_t r = tmp[i * bits_mul + 2];
uint32_t a = tmp[i * bits_mul + 3];
if (bits == 24)
a = 0xff;
out_img->pixels[i] = (a << a_shift) |
(r << r_shift) | (g << g_shift) | (b << b_shift);
tga_image_type -= 8;
tga_is_RLE = 1;
}
/* int tga_alpha_bits = tga_inverted & 15; */
tga_inverted = 1 - ((tga_inverted >> 5) & 1);
/* error check */
if (
(tga_width < 1) || (tga_height < 1) ||
(tga_image_type < 1) || (tga_image_type > 3) ||
((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) &&
(tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32))
)
return NULL; /* we don't report this as a bad TGA because we don't even know if it's TGA */
/* If paletted, then we will use the number of bits from the palette */
if ( tga_indexed )
tga_comp = tga_palette_bits / 8;
/* TGA info */
*x = tga_width;
*y = tga_height;
if (comp) *comp = tga_comp;
tga_data = (unsigned char*)malloc( (size_t)tga_width * tga_height * tga_comp );
if (!tga_data)
return rtga__errpuc("outofmem", "Out of memory");
/* skip to the data's starting position (offset usually = 0) */
rtga__skip(s, tga_offset );
if ( !tga_indexed && !tga_is_RLE)
{
for (i=0; i < tga_height; ++i)
{
int y = tga_inverted ? tga_height -i - 1 : i;
uint8_t *tga_row = tga_data + y*tga_width*tga_comp;
rtga__getn(s, tga_row, tga_width * tga_comp);
}
}
else
{
/* Do I need to load a palette? */
if ( tga_indexed)
{
/* any data to skip? (offset usually = 0) */
rtga__skip(s, tga_palette_start );
/* load the palette */
tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 );
if (!tga_palette)
{
free(tga_data);
return rtga__errpuc("outofmem", "Out of memory");
}
if (!rtga__getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) {
free(tga_data);
free(tga_palette);
return rtga__errpuc("bad palette", "Corrupt TGA");
}
}
/* load the data */
for (i=0; i < tga_width * tga_height; ++i)
{
/* if I'm in RLE mode, do I need to get a RLE rtga__pngchunk? */
if ( tga_is_RLE )
{
if ( RLE_count == 0 )
{
/* yep, get the next byte as a RLE command */
int RLE_cmd = rtga__get8(s);
RLE_count = 1 + (RLE_cmd & 127);
RLE_repeating = RLE_cmd >> 7;
read_next_pixel = 1;
}
else if ( !RLE_repeating )
read_next_pixel = 1;
}
else
read_next_pixel = 1;
/* OK, if I need to read a pixel, do it now */
if ( read_next_pixel )
{
/* load however much data we did have */
if ( tga_indexed )
{
/* read in 1 byte, then perform the lookup */
int pal_idx = rtga__get8(s);
if ( pal_idx >= tga_palette_len ) /* invalid index */
pal_idx = 0;
pal_idx *= tga_bits_per_pixel / 8;
for (j = 0; j*8 < tga_bits_per_pixel; ++j)
raw_data[j] = tga_palette[pal_idx+j];
}
else
{
/* read in the data raw */
for (j = 0; j*8 < tga_bits_per_pixel; ++j)
raw_data[j] = rtga__get8(s);
}
/* clear the reading flag for the next pixel */
read_next_pixel = 0;
} /* end of reading a pixel */
/* copy data */
for (j = 0; j < tga_comp; ++j)
tga_data[i*tga_comp+j] = raw_data[j];
/* in case we're in RLE mode, keep counting down */
--RLE_count;
}
/* do I need to invert the image? */
if ( tga_inverted )
{
for (j = 0; j*2 < tga_height; ++j)
{
int index1 = j * tga_width * tga_comp;
int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
for (i = tga_width * tga_comp; i > 0; --i)
{
unsigned char temp = tga_data[index1];
tga_data[index1] = tga_data[index2];
tga_data[index2] = temp;
++index1;
++index2;
}
}
}
/* Clear my palette, if I had one */
if ( tga_palette != NULL )
free( tga_palette );
}
/* swap RGB */
if (tga_comp >= 3)
{
unsigned char* tga_pixel = tga_data;
for (i=0; i < tga_width * tga_height; ++i)
{
unsigned char temp = tga_pixel[0];
tga_pixel[0] = tga_pixel[2];
tga_pixel[2] = temp;
tga_pixel += tga_comp;
}
}
/* convert to target component count */
if (req_comp && req_comp != tga_comp)
tga_data = rtga__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height);
tga_palette_start = tga_palette_len = tga_palette_bits =
tga_x_origin = tga_y_origin = 0;
return tga_data;
}
int rtga_process_image(rtga_t *rtga, void **buf_data,
size_t size, unsigned *width, unsigned *height)
{
int comp;
#if 0
unsigned size_tex = 0;
#endif
if (!rtga)
return IMAGE_PROCESS_ERROR;
rtga->output_image = (uint32_t*)rtga_load_from_memory(rtga->buff_data, size, width, height, &comp, 4);
*buf_data = rtga->output_image;
#if 0
size_tex = (*width) * (*height);
printf("GETS HERE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
/* Convert RGBA to ARGB */
do
{
unsigned int texel = rtga->output_image[size_tex];
unsigned int A = texel & 0xFF000000;
unsigned int B = texel & 0x00FF0000;
unsigned int G = texel & 0x0000FF00;
unsigned int R = texel & 0x000000FF;
((unsigned int*)rtga->output_image)[size_tex] = A | (R << 16) | G | (B >> 16);
}while(size_tex--);
#endif
return IMAGE_PROCESS_END;
}
bool rtga_set_buf_ptr(rtga_t *rtga, void *data)
{
if (!rtga)
return false;
rtga->buff_data = (uint8_t*)data;
return true;
error:
if (out_img->pixels)
free(out_img->pixels);
out_img->pixels = NULL;
out_img->width = out_img->height = 0;
return false;
}
void rtga_free(rtga_t *rtga)
{
if (!rtga)
return;
free(rtga);
}
rtga_t *rtga_alloc(void)
{
rtga_t *rtga = (rtga_t*)calloc(1, sizeof(*rtga));
if (!rtga)
return NULL;
return rtga;
}

9
gfx/math/matrix_4x4.c
View File

@ -25,6 +25,15 @@
#include <gfx/math/matrix_4x4.h>
void matrix_4x4_copy(math_matrix_4x4 *dst, const math_matrix_4x4 *src)
{
unsigned i, j;
for (i = 0; i < 4; i++)
for (j = 0; j < 4; j++)
MAT_ELEM_4X4(*dst, i, j) = MAT_ELEM_4X4(*src, i, j);
}
/*
* Sets mat to an identity matrix
*/

28
include/conversion/float_to_s16.h
View File

@ -23,13 +23,13 @@
#ifndef __LIBRETRO_SDK_CONVERSION_FLOAT_TO_S16_H__
#define __LIBRETRO_SDK_CONVERSION_FLOAT_TO_S16_H__
#include <stdint.h>
#include <stddef.h>
#include <retro_common_api.h>
RETRO_BEGIN_DECLS
#include <stdint.h>
#include <stddef.h>
/**
* convert_float_to_s16_C:
* @out : output buffer
@ -81,20 +81,6 @@ void (*convert_float_to_s16_arm)(int16_t *out,
const float *in, size_t samples);
void convert_float_s16_asm(int16_t *out, const float *in, size_t samples);
/**
* convert_float_to_s16_neon:
* @out : output buffer
* @in : input buffer
* @samples : size of samples to be converted
*
* Converts floating point
* to signed integer 16-bit.
*
* ARM NEON implementation callback function.
**/
static void convert_float_to_s16_neon(int16_t *out,
const float *in, size_t samples);
#elif defined(_MIPS_ARCH_ALLEGREX)
#define convert_float_to_s16 convert_float_to_s16_ALLEGREX
/**
@ -114,6 +100,14 @@ void convert_float_to_s16_ALLEGREX(int16_t *out,
#define convert_float_to_s16 convert_float_to_s16_C
#endif
/**
* convert_float_to_s16_init_simd:
*
* Sets up function pointers for conversion
* functions based on CPU features.
**/
void convert_float_to_s16_init_simd(void);
RETRO_END_DECLS
#endif

4
include/conversion/s16_to_float.h
View File

@ -108,12 +108,12 @@ void convert_s16_to_float_C(float *out,
const int16_t *in, size_t samples, float gain);
/**
* convert_init_simd:
* convert_s16_to_float_init_simd:
*
* Sets up function pointers for conversion
* functions based on CPU features.
**/
void convert_init_simd(void);
void convert_s16_to_float_init_simd(void);
RETRO_END_DECLS

19
include/formats/image.h
View File

@ -42,19 +42,24 @@ struct texture_image
enum image_type_enum
{
IMAGE_TYPE_PNG = 0,
IMAGE_TYPE_JPEG
IMAGE_TYPE_NONE = 0,
IMAGE_TYPE_PNG,
IMAGE_TYPE_JPEG,
IMAGE_TYPE_BMP,
IMAGE_TYPE_TGA
};
bool video_texture_image_set_color_shifts(unsigned *r_shift, unsigned *g_shift,
bool image_texture_set_color_shifts(unsigned *r_shift, unsigned *g_shift,
unsigned *b_shift, unsigned *a_shift);
bool video_texture_image_color_convert(unsigned r_shift,
bool image_texture_color_convert(unsigned r_shift,
unsigned g_shift, unsigned b_shift, unsigned a_shift,
struct texture_image *out_img);
bool video_texture_image_load(struct texture_image *img, const char *path);
void video_texture_image_free(struct texture_image *img);
bool image_texture_load(struct texture_image *img, const char *path);
void image_texture_free(struct texture_image *img);
void image_texture_set_rgba(void);
void image_texture_unset_rgba(void);
/* Image transfer */
@ -77,6 +82,8 @@ int image_transfer_process(
bool image_transfer_iterate(void *data, enum image_type_enum type);
bool image_transfer_is_valid(void *data, enum image_type_enum type);
RETRO_END_DECLS
#endif

11
include/formats/rbmp.h
View File

@ -38,6 +38,8 @@ enum rbmp_source_type
RBMP_SOURCE_TYPE_ARGB8888
};
typedef struct rbmp rbmp_t;
bool rbmp_save_image(
const char *filename,
const void *frame,
@ -46,6 +48,15 @@ bool rbmp_save_image(
unsigned pitch,
enum rbmp_source_type type);
int rbmp_process_image(rbmp_t *rbmp, void **buf,
size_t size, unsigned *width, unsigned *height);
bool rbmp_set_buf_ptr(rbmp_t *rbmp, void *data);
void rbmp_free(rbmp_t *rbmp);
rbmp_t *rbmp_alloc(void);
RETRO_END_DECLS
#endif

3
include/formats/rjpeg.h
View File

@ -37,9 +37,6 @@ typedef struct rjpeg rjpeg_t;
int rjpeg_process_image(rjpeg_t *rjpeg, void **buf,
size_t size, unsigned *width, unsigned *height);
bool rjpeg_image_load(uint8_t *buf, void *data, size_t size,
unsigned a_shift, unsigned r_shift, unsigned g_shift, unsigned b_shift);
bool rjpeg_set_buf_ptr(rjpeg_t *rjpeg, void *data);
void rjpeg_free(rjpeg_t *rjpeg);

1
include/formats/rpng.h
View File

@ -29,7 +29,6 @@
#include <retro_common_api.h>
#include <boolean.h>
#include <file/archive_file.h>
RETRO_BEGIN_DECLS

1
include/gfx/math/matrix_4x4.h
View File

@ -35,6 +35,7 @@ typedef struct math_matrix_4x4
#define MAT_ELEM_4X4(mat, r, c) ((mat).data[4 * (c) + (r)])
void matrix_4x4_copy(math_matrix_4x4 *dst, const math_matrix_4x4 *src);
void matrix_4x4_identity(math_matrix_4x4 *mat);
void matrix_4x4_transpose(math_matrix_4x4 *out, const math_matrix_4x4 *in);

29
include/libretro.h
View File

@ -1010,9 +1010,9 @@ struct retro_memory_descriptor
/* To go from emulated address to physical address, the following
* order applies:
* Subtract 'start', pick off 'disconnect', apply 'len', add 'offset'.
*
* The address space name must consist of only a-zA-Z0-9_-,
* Subtract 'start', pick off 'disconnect', apply 'len', add 'offset'. */
/* The address space name must consist of only a-zA-Z0-9_-,
* should be as short as feasible (maximum length is 8 plus the NUL),
* and may not be any other address space plus one or more 0-9A-F
* at the end.
@ -1032,12 +1032,31 @@ struct retro_memory_descriptor
* 'a'+'A' - valid (neither is a prefix of each other)
* 'AR'+blank - valid ('R' is not in 0-9A-F)
* 'ARB'+blank - valid (the B can't be part of the address either, because
* there is no namespace 'AR')
* there is no namespace 'AR')
* blank+'B' - not valid, because it's ambigous which address space B1234
* would refer to.
* would refer to.
* The length can't be used for that purpose; the frontend may want
* to append arbitrary data to an address, without a separator. */
const char *addrspace;
/* TODO: When finalizing this one, add a description field, which should be
* "WRAM" or something roughly equally long. */
/* TODO: When finalizing this one, replace 'select' with 'limit', which tells
* which bits can vary and still refer to the same address (limit = ~select).
* TODO: limit? range? vary? something else? */
/* TODO: When finalizing this one, if 'len' is above what 'select' (or
* 'limit') allows, it's bankswitched. Bankswitched data must have both 'len'
* and 'select' != 0, and the mappings don't tell how the system switches the
* banks. */
/* TODO: When finalizing this one, fix the 'len' bit removal order.
* For len=0x1800, pointer 0x1C00 should go to 0x1400, not 0x0C00.
* Algorithm: Take bits highest to lowest, but if it goes above len, clear
* the most recent addition and continue on the next bit.
* TODO: Can the above be optimized? Is "remove the lowest bit set in both
* pointer and 'len'" equivalent? */
};
/* The frontend may use the largest value of 'start'+'select' in a

2
include/memalign.h
View File

@ -31,6 +31,8 @@ RETRO_BEGIN_DECLS
void *memalign_alloc(size_t boundary, size_t size);
void *memalign_alloc_aligned(size_t size);
void memalign_free(void *ptr);
RETRO_END_DECLS

4
lists/dir_list.c
View File

@ -181,8 +181,8 @@ struct string_list *dir_list_new(const char *dir,
while (retro_readdir(entry))
{
char file_path[PATH_MAX_LENGTH];
bool is_dir;
bool is_dir = false;
char file_path[PATH_MAX_LENGTH] = {0};
int ret = 0;
const char *name = retro_dirent_get_name(entry);
const char *file_ext = path_get_extension(name);

12
memmap/memalign.c
View File

@ -25,6 +25,7 @@
#include <memalign.h>
void *memalign_alloc(size_t boundary, size_t size)
{
void **place = NULL;
@ -50,3 +51,14 @@ void memalign_free(void *ptr)
p = (void**)ptr;
free(p[-1]);
}
void *memalign_alloc_aligned(size_t size)
{
#if defined(__x86_64__) || defined(__LP64) || defined(__IA64__) || defined(_M_X64) || defined(_WIN64)
return memalign_alloc(64, size);
#elif defined(__i386__) || defined(__i486__) || defined(__i686__) || defined(GEKKO)
return memalign_alloc(32, size);
#else
return memalign_alloc(32, size);
#endif
}

4
rthreads/rthreads.c
View File

@ -43,11 +43,15 @@
#include "gx_pthread.h"
#elif defined(PSP)
#include "psp_pthread.h"
#elif defined(__CELLOS_LV2__)
#include <pthread.h>
#include <sys/sys_time.h>
#else
#include <pthread.h>
#include <time.h>
#endif
#ifdef __MACH__
#include <mach/clock.h>
#include <mach/mach.h>