admin/ci-libretro-fceumm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update memory_stream

Browse Source
This commit is contained in:
twinaphex
2016-04-07 03:17:52 +02:00
parent 27c41263b9
commit 3e12850dd6
9 changed files with 250 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/drivers/libretro/griffin.c
View File

@@ -3,7 +3,7 @@
#include "drivers/libretro/libretro.c"
#ifndef STATIC_LINKING
#include "../../memstream.c"
#include "drivers/libretro/libretro-common/streams/memory_stream.c"
#endif
#include "cart.c"

55
src/drivers/libretro/libretro-common/include/streams/memory_stream.h Normal file
View File

@@ -0,0 +1,55 @@
/* Copyright (C) 2010-2015 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (memory_stream.h).
* ---------------------------------------------------------------------------------------
*
* Permission is hereby granted, free of charge,
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef _LIBRETRO_SDK_FILE_MEMORY_STREAM_H
#define _LIBRETRO_SDK_FILE_MEMORY_STREAM_H
#include <stdint.h>
#include <stddef.h>
typedef struct memstream memstream_t;
memstream_t *memstream_open(unsigned writing);
void memstream_close(memstream_t *stream);
size_t memstream_read(memstream_t *stream, void *data, size_t bytes);
size_t memstream_write(memstream_t *stream, const void *data, size_t bytes);
int memstream_getc(memstream_t *stream);
void memstream_putc(memstream_t *stream, int c);
char *memstream_gets(memstream_t *stream, char *buffer, size_t len);
size_t memstream_pos(memstream_t *stream);
void memstream_rewind(memstream_t *stream);
int memstream_seek(memstream_t *stream, int offset, int whence);
void memstream_set_buffer(uint8_t *buffer, size_t size);
size_t memstream_get_last_size(void);
#endif

190
src/drivers/libretro/libretro-common/streams/memory_stream.c Normal file
View File

@@ -0,0 +1,190 @@
/* Copyright (C) 2010-2016 The RetroArch team
*
* ---------------------------------------------------------------------------------------
* The following license statement only applies to this file (memory_stream.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 <stdlib.h>
#include <string.h>
#include "../include/streams/memory_stream.h"
static uint8_t* g_buffer = NULL;
static size_t g_size = 0;
static size_t last_file_size = 0;
struct memstream
{
uint8_t *buf;
size_t size;
size_t ptr;
size_t max_ptr;
unsigned writing;
};
static void memstream_update_pos(memstream_t *stream)
{
if (stream->ptr > stream->max_ptr)
stream->max_ptr = stream->ptr;
}
void memstream_set_buffer(uint8_t *buffer, size_t size)
{
g_buffer = buffer;
g_size = size;
}
size_t memstream_get_last_size(void)
{
return last_file_size;
}
static void memstream_init(memstream_t *stream,
uint8_t *buffer, size_t max_size, unsigned writing)
{
if (!stream)
return;
stream->buf = buffer;
stream->size = max_size;
stream->ptr = 0;
stream->max_ptr = 0;
stream->writing = writing;
}
memstream_t *memstream_open(unsigned writing)
{
memstream_t *stream;
if (!g_buffer || !g_size)
return NULL;
stream = (memstream_t*)calloc(1, sizeof(*stream));
memstream_init(stream, g_buffer, g_size, writing);
g_buffer = NULL;
g_size = 0;
return stream;
}
void memstream_close(memstream_t *stream)
{
if (!stream)
return;
last_file_size = stream->writing ? stream->max_ptr : stream->size;
free(stream);
}
size_t memstream_read(memstream_t *stream, void *data, size_t bytes)
{
size_t avail = 0;
if (!stream)
return 0;
avail = stream->size - stream->ptr;
if (bytes > avail)
bytes = avail;
memcpy(data, stream->buf + stream->ptr, bytes);
stream->ptr += bytes;
memstream_update_pos(stream);
return bytes;
}
size_t memstream_write(memstream_t *stream, const void *data, size_t bytes)
{
size_t avail = 0;
if (!stream)
return 0;
avail = stream->size - stream->ptr;
if (bytes > avail)
bytes = avail;
memcpy(stream->buf + stream->ptr, data, bytes);
stream->ptr += bytes;
memstream_update_pos(stream);
return bytes;
}
int memstream_seek(memstream_t *stream, int offset, int whence)
{
size_t ptr;
switch (whence)
{
case SEEK_SET:
ptr = offset;
break;
case SEEK_CUR:
ptr = stream->ptr + offset;
break;
case SEEK_END:
ptr = (stream->writing ? stream->max_ptr : stream->size) + offset;
break;
default:
return -1;
}
if (ptr <= stream->size)
{
stream->ptr = ptr;
return 0;
}
return -1;
}
void memstream_rewind(memstream_t *stream)
{
memstream_seek(stream, 0L, SEEK_SET);
}
size_t memstream_pos(memstream_t *stream)
{
return stream->ptr;
}
char *memstream_gets(memstream_t *stream, char *buffer, size_t len)
{
return NULL;
}
int memstream_getc(memstream_t *stream)
{
int ret = 0;
if (stream->ptr >= stream->size)
return EOF;
ret = stream->buf[stream->ptr++];
memstream_update_pos(stream);
return ret;
}
void memstream_putc(memstream_t *stream, int c)
{
if (stream->ptr < stream->size)
stream->buf[stream->ptr++] = c;
memstream_update_pos(stream);
}

2
src/drivers/libretro/libretro.c
View File

@@ -24,7 +24,7 @@
#include "../../vsuni.h"
#include "../../video.h"
#include "../../memstream.h"
#include "libretro-common/include/streams/memory_stream.h"
#if defined(_3DS)
void* linearMemAlign(size_t size, size_t alignment);

2
src/fceu-endian.h
View File

@@ -2,7 +2,7 @@
#define _FCEU_ENDIAN_H
#include "fceu-memory.h"
#include "memstream.h"
#include "drivers/libretro/libretro-common/include/streams/memory_stream.h"
int write32le_mem(uint32 b, memstream_t *mem);
int read32le_mem(uint32 *Bufo, memstream_t *mem);

2
src/fceu-memory.h
View File

@@ -30,7 +30,7 @@
#define FCEU_dwmemset(d, c, n) { int _x; for (_x = n - 4; _x >= 0; _x -= 4) *(uint32*)& (d)[_x] = c; }
#if defined(STATE_LIBRETRO) || defined(ENDIAN_LIBRETRO) || defined(GENERAL_LIBRETRO)
#include "memstream.h"
#include "drivres/libretro/libretro-common/include/streams/memstream.h"
#define HAVE_MEMSTREAM
#define MEM_TYPE memstream_t

133
src/memstream.c
View File

@@ -1,133 +0,0 @@
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include "memstream.h"
static uint8_t *g_buffer = NULL;
static size_t g_size = 0;
static size_t g_last_file_size = 0;
struct memstream
{
uint8_t *m_buf;
size_t m_size;
size_t m_ptr;
size_t m_max_ptr;
unsigned writing;
};
static void memstream_update_ptr(memstream_t *stream)
{
if (stream->m_ptr > stream->m_max_ptr)
stream->m_max_ptr = stream->m_ptr;
}
static void memstream_init(memstream_t *stream, uint8_t *buffer, size_t max_size, unsigned writing)
{
stream->m_buf = buffer;
stream->m_size = max_size;
stream->m_ptr = 0;
stream->m_max_ptr = 0;
stream->writing = writing;
}
void memstream_set_buffer(uint8_t *buffer, size_t size)
{
g_buffer = buffer;
g_size = size;
}
size_t memstream_get_last_size(void)
{
return g_last_file_size;
}
memstream_t *memstream_open(unsigned writing)
{
memstream_t *stream;
if (!g_buffer || !g_size)
return NULL;
stream = (memstream_t*)calloc(1, sizeof(*stream));
memstream_init(stream, g_buffer, g_size, writing);
g_buffer = NULL;
g_size = 0;
return stream;
}
void memstream_close(memstream_t *stream)
{
g_last_file_size = stream->writing ? stream->m_max_ptr : stream->m_size;
free(stream);
}
size_t memstream_read(memstream_t *stream, void *data, size_t bytes)
{
size_t avail = stream->m_size - stream->m_ptr;
if (bytes > avail)
bytes = avail;
memcpy(data, stream->m_buf + stream->m_ptr, bytes);
stream->m_ptr += bytes;
memstream_update_ptr(stream);
return bytes;
}
size_t memstream_write(memstream_t *stream, const void *data, size_t bytes)
{
size_t avail = stream->m_size - stream->m_ptr;
if (bytes > avail)
bytes = avail;
memcpy(stream->m_buf + stream->m_ptr, data, bytes);
stream->m_ptr += bytes;
memstream_update_ptr(stream);
return bytes;
}
int memstream_seek(memstream_t *stream, int offset, int whence)
{
size_t ptr;
if (whence == SEEK_SET)
ptr = offset;
else if (whence == SEEK_CUR)
ptr = stream->m_ptr + offset;
else if (whence == SEEK_END)
ptr = (stream->writing ? stream->m_max_ptr : stream->m_size) + offset;
else
return -1;
if (ptr <= stream->m_size)
{
stream->m_ptr = ptr;
return 0;
}
else
return -1;
}
size_t memstream_pos(memstream_t *stream)
{
return stream->m_ptr;
}
int memstream_getc(memstream_t *stream)
{
if (stream->m_ptr >= stream->m_size)
return EOF;
else
return stream->m_buf[stream->m_ptr++];
memstream_update_ptr(stream);
}
void memstream_putc(memstream_t *stream, int c)
{
if (stream->m_ptr < stream->m_size)
stream->m_buf[stream->m_ptr++] = c;
memstream_update_ptr(stream);
}

29
src/memstream.h
View File

@@ -1,29 +0,0 @@
#ifndef __MEMSTREAM_H
#define __MEMSTREAM_H
#include <stddef.h>
#include <stdint.h>
#ifndef _MSC_VER
#include <stdbool.h>
#else
#define TRUE 1
#define FALSE 0
#endif
typedef struct memstream memstream_t;
memstream_t *memstream_open(unsigned writing);
void memstream_close(memstream_t *stream);
size_t memstream_read(memstream_t *stream, void *data, size_t bytes);
size_t memstream_write(memstream_t *stream, const void *data, size_t bytes);
int memstream_getc(memstream_t *stream);
void memstream_putc(memstream_t *stream, int c);
char *memstream_gets(memstream_t *stream, char *buffer, size_t len);
size_t memstream_pos(memstream_t *stream);
int memstream_seek(memstream_t *stream, int offset, int whence);
void memstream_set_buffer(uint8_t *buffer, size_t size);
size_t memstream_get_last_size(void);
#endif