Re3/src/core/CdStreamPosix.cpp

552 lines
12 KiB
C++
Raw Normal View History

2020-05-10 22:55:57 -04:00
#ifndef _WIN32
#include "common.h"
#include "crossplatform.h"
#include <pthread.h>
#include <signal.h>
#include <semaphore.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/statvfs.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include "CdStream.h"
#include "rwcore.h"
2020-11-28 10:16:15 -05:00
#include "MemoryMgr.h"
2020-05-10 22:55:57 -04:00
#define CDDEBUG(f, ...) debug ("%s: " f "\n", "cdvd_stream", ## __VA_ARGS__)
#define CDTRACE(f, ...) printf("%s: " f "\n", "cdvd_stream", ## __VA_ARGS__)
2021-01-27 10:26:08 -05:00
#ifdef FLUSHABLE_STREAMING
2020-05-10 22:55:57 -04:00
bool flushStream[MAX_CDCHANNELS];
2021-01-27 10:26:08 -05:00
#endif
2020-05-10 22:55:57 -04:00
struct CdReadInfo
{
uint32 nSectorOffset;
uint32 nSectorsToRead;
void *pBuffer;
bool bLocked;
bool bReading;
int32 nStatus;
#ifdef ONE_THREAD_PER_CHANNEL
int8 nThreadStatus; // 0: created 1:priority set up 2:abort now
pthread_t pChannelThread;
sem_t *pStartSemaphore;
2020-05-10 22:55:57 -04:00
#endif
sem_t *pDoneSemaphore; // used for CdStreamSync
int32 hFile;
2020-05-10 22:55:57 -04:00
};
char gCdImageNames[MAX_CDIMAGES+1][64];
int32 gNumImages;
int32 gNumChannels;
int32 gImgFiles[MAX_CDIMAGES]; // -1: error 0:unused otherwise: fd
char *gImgNames[MAX_CDIMAGES];
#ifndef ONE_THREAD_PER_CHANNEL
pthread_t _gCdStreamThread;
sem_t *gCdStreamSema; // released when we have new thing to read(so channel is set)
int8 gCdStreamThreadStatus; // 0: created 1:priority set up 2:abort now
2020-05-10 22:55:57 -04:00
Queue gChannelRequestQ;
bool _gbCdStreamOverlapped;
#endif
CdReadInfo *gpReadInfo;
int32 lastPosnRead;
int _gdwCdStreamFlags;
void *CdStreamThread(void* channelId);
void
CdStreamInitThread(void)
{
int status;
char semName[20];
2020-05-10 22:55:57 -04:00
#ifndef ONE_THREAD_PER_CHANNEL
gChannelRequestQ.items = (int32 *)calloc(gNumChannels + 1, sizeof(int32));
gChannelRequestQ.head = 0;
gChannelRequestQ.tail = 0;
gChannelRequestQ.size = gNumChannels + 1;
ASSERT(gChannelRequestQ.items != nil );
gCdStreamSema = sem_open("/semaphore_cd_stream", O_CREAT, 0644, 1);
2020-05-10 22:55:57 -04:00
if (gCdStreamSema == SEM_FAILED) {
2020-05-10 22:55:57 -04:00
CDTRACE("failed to create stream semaphore");
ASSERT(0);
return;
}
#endif
2020-05-10 22:55:57 -04:00
if ( gNumChannels > 0 )
{
for ( int32 i = 0; i < gNumChannels; i++ )
{
sprintf(semName,"/semaphore_done%d",i);
gpReadInfo[i].pDoneSemaphore = sem_open(semName, O_CREAT, 0644, 1);
2020-05-10 22:55:57 -04:00
if (gpReadInfo[i].pDoneSemaphore == SEM_FAILED)
2020-05-10 22:55:57 -04:00
{
CDTRACE("failed to create sync semaphore");
ASSERT(0);
return;
}
2021-01-27 10:26:08 -05:00
2020-05-10 22:55:57 -04:00
#ifdef ONE_THREAD_PER_CHANNEL
sprintf(semName,"/semaphore_start%d",i);
gpReadInfo[i].pStartSemaphore = sem_open(semName, O_CREAT, 0644, 1);
2020-05-10 22:55:57 -04:00
if (gpReadInfo[i].pStartSemaphore == SEM_FAILED)
2020-05-10 22:55:57 -04:00
{
CDTRACE("failed to create start semaphore");
ASSERT(0);
return;
}
gpReadInfo[i].nThreadStatus = 0;
2020-05-10 22:55:57 -04:00
int *channelI = (int*)malloc(sizeof(int));
*channelI = i;
status = pthread_create(&gpReadInfo[i].pChannelThread, NULL, CdStreamThread, (void*)channelI);
2020-05-10 22:55:57 -04:00
if (status == -1)
{
CDTRACE("failed to create sync thread");
ASSERT(0);
return;
}
#endif
}
}
#ifndef ONE_THREAD_PER_CHANNEL
debug("Using one streaming thread for all channels\n");
gCdStreamThreadStatus = 0;
status = pthread_create(&_gCdStreamThread, NULL, CdStreamThread, nil);
if (status == -1)
{
CDTRACE("failed to create sync thread");
ASSERT(0);
return;
}
2020-05-10 22:55:57 -04:00
#else
debug("Using separate streaming threads for each channel\n");
2020-05-10 22:55:57 -04:00
#endif
}
void
CdStreamInit(int32 numChannels)
{
struct statvfs fsInfo;
if((statvfs("models/gta3.img", &fsInfo)) < 0)
{
CDTRACE("can't get filesystem info");
ASSERT(0);
return;
}
2020-08-05 08:32:37 -04:00
#ifdef __linux__
2020-05-10 22:55:57 -04:00
_gdwCdStreamFlags = O_RDONLY | O_NOATIME;
2020-08-07 11:51:15 -04:00
#else
2020-08-05 08:32:37 -04:00
_gdwCdStreamFlags = O_RDONLY;
#endif
2020-05-10 22:55:57 -04:00
// People say it's slower
/*
if ( fsInfo.f_bsize <= CDSTREAM_SECTOR_SIZE )
{
_gdwCdStreamFlags |= O_DIRECT;
debug("Using no buffered loading for streaming\n");
}
*/
2020-10-01 20:45:38 -04:00
void *pBuffer = (void *)RwMallocAlign(CDSTREAM_SECTOR_SIZE, (RwUInt32)fsInfo.f_bsize);
2020-05-10 22:55:57 -04:00
ASSERT( pBuffer != nil );
gNumImages = 0;
gNumChannels = numChannels;
2020-05-13 11:48:07 -04:00
gpReadInfo = (CdReadInfo *)calloc(numChannels, sizeof(CdReadInfo));
2020-05-10 22:55:57 -04:00
ASSERT( gpReadInfo != nil );
CDDEBUG("read info %p", gpReadInfo);
CdStreamInitThread();
ASSERT( pBuffer != nil );
RwFreeAlign(pBuffer);
}
uint32
GetGTA3ImgSize(void)
{
ASSERT( gImgFiles[0] > 0 );
struct stat statbuf;
2020-05-10 22:55:57 -04:00
char path[PATH_MAX];
realpath(gImgNames[0], path);
if (stat(path, &statbuf) == -1) {
2020-05-10 22:55:57 -04:00
// Try case-insensitivity
2020-07-26 13:59:58 -04:00
char* real = casepath(gImgNames[0], false);
if (real)
2020-05-10 22:55:57 -04:00
{
2020-07-26 13:59:58 -04:00
realpath(real, path);
free(real);
if (stat(path, &statbuf) != -1)
2020-05-10 22:55:57 -04:00
goto ok;
}
CDTRACE("can't get size of gta3.img");
ASSERT(0);
return 0;
}
ok:
2020-10-01 20:45:38 -04:00
return (uint32)statbuf.st_size;
2020-05-10 22:55:57 -04:00
}
void
CdStreamShutdown(void)
{
// Destroying semaphores and free(gpReadInfo) will be done at threads
#ifndef ONE_THREAD_PER_CHANNEL
gCdStreamThreadStatus = 2;
sem_post(gCdStreamSema);
pthread_join(_gCdStreamThread, nil);
#else
for ( int32 i = 0; i < gNumChannels; i++ ) {
gpReadInfo[i].nThreadStatus = 2;
sem_post(gpReadInfo[i].pStartSemaphore);
pthread_join(gpReadInfo[i].pChannelThread, nil);
}
2020-05-10 22:55:57 -04:00
#endif
}
int32
CdStreamRead(int32 channel, void *buffer, uint32 offset, uint32 size)
{
ASSERT( channel < gNumChannels );
ASSERT( buffer != nil );
lastPosnRead = size + offset;
ASSERT( _GET_INDEX(offset) < MAX_CDIMAGES );
int32 hImage = gImgFiles[_GET_INDEX(offset)];
ASSERT( hImage > 0 );
CdReadInfo *pChannel = &gpReadInfo[channel];
ASSERT( pChannel != nil );
if ( pChannel->nSectorsToRead != 0 || pChannel->bReading ) {
2020-10-12 13:30:49 -04:00
if (pChannel->hFile == hImage - 1 && pChannel->nSectorOffset == _GET_OFFSET(offset) && pChannel->nSectorsToRead >= size)
2020-10-08 19:19:49 -04:00
return STREAM_SUCCESS;
2021-01-27 10:26:08 -05:00
#ifdef FLUSHABLE_STREAMING
flushStream[channel] = 1;
CdStreamSync(channel);
2021-01-27 10:26:08 -05:00
#else
return STREAM_NONE;
#endif
}
2020-05-10 22:55:57 -04:00
2020-10-08 19:19:49 -04:00
pChannel->hFile = hImage - 1;
pChannel->nStatus = STREAM_NONE;
pChannel->nSectorOffset = _GET_OFFSET(offset);
pChannel->nSectorsToRead = size;
pChannel->pBuffer = buffer;
pChannel->bLocked = 0;
2020-05-10 22:55:57 -04:00
#ifndef ONE_THREAD_PER_CHANNEL
AddToQueue(&gChannelRequestQ, channel);
if ( sem_post(gCdStreamSema) != 0 )
printf("Signal Sema Error\n");
2020-05-10 22:55:57 -04:00
#else
if ( sem_post(pChannel->pStartSemaphore) != 0 )
printf("Signal Sema Error\n");
2020-05-10 22:55:57 -04:00
#endif
return STREAM_SUCCESS;
2020-05-10 22:55:57 -04:00
}
int32
CdStreamGetStatus(int32 channel)
{
ASSERT( channel < gNumChannels );
CdReadInfo *pChannel = &gpReadInfo[channel];
ASSERT( pChannel != nil );
#ifdef ONE_THREAD_PER_CHANNEL
if (pChannel->nThreadStatus == 2)
return STREAM_NONE;
2020-05-10 22:55:57 -04:00
#else
if (gCdStreamThreadStatus == 2)
return STREAM_NONE;
2020-05-10 22:55:57 -04:00
#endif
if ( pChannel->bReading )
return STREAM_READING;
2020-05-10 22:55:57 -04:00
if ( pChannel->nSectorsToRead != 0 )
return STREAM_WAITING;
2020-05-10 22:55:57 -04:00
if ( pChannel->nStatus != STREAM_NONE )
{
int32 status = pChannel->nStatus;
pChannel->nStatus = STREAM_NONE;
2020-05-10 22:55:57 -04:00
return status;
}
2020-05-10 22:55:57 -04:00
return STREAM_NONE;
2020-05-10 22:55:57 -04:00
}
int32
CdStreamGetLastPosn(void)
{
return lastPosnRead;
}
// wait for channel to finish reading
int32
CdStreamSync(int32 channel)
{
ASSERT( channel < gNumChannels );
CdReadInfo *pChannel = &gpReadInfo[channel];
ASSERT( pChannel != nil );
2021-01-27 10:26:08 -05:00
#ifdef FLUSHABLE_STREAMING
2020-05-10 22:55:57 -04:00
if (flushStream[channel]) {
pChannel->nSectorsToRead = 0;
2021-01-27 10:26:08 -05:00
#ifdef ONE_THREAD_PER_CHANNEL
2020-10-08 19:19:49 -04:00
pthread_kill(pChannel->pChannelThread, SIGUSR1);
if (pChannel->bReading) {
pChannel->bLocked = true;
2020-05-10 22:55:57 -04:00
#else
if (pChannel->bReading) {
pChannel->bLocked = true;
2020-10-08 19:19:49 -04:00
pthread_kill(_gCdStreamThread, SIGUSR1);
2021-01-27 10:26:08 -05:00
#endif
2020-10-12 13:30:49 -04:00
while (pChannel->bLocked)
sem_wait(pChannel->pDoneSemaphore);
2020-05-10 22:55:57 -04:00
}
pChannel->bReading = false;
flushStream[channel] = false;
return STREAM_NONE;
2020-05-10 22:55:57 -04:00
}
2021-01-27 10:26:08 -05:00
#endif
2020-05-10 22:55:57 -04:00
if ( pChannel->nSectorsToRead != 0 )
{
pChannel->bLocked = true;
2021-01-27 10:26:08 -05:00
while (pChannel->bLocked && pChannel->nSectorsToRead != 0){
2020-10-12 13:30:49 -04:00
sem_wait(pChannel->pDoneSemaphore);
2021-01-27 10:26:08 -05:00
}
pChannel->bLocked = false;
}
2020-05-10 22:55:57 -04:00
pChannel->bReading = false;
2020-05-10 22:55:57 -04:00
return pChannel->nStatus;
2020-05-10 22:55:57 -04:00
}
void
AddToQueue(Queue *queue, int32 item)
{
ASSERT( queue != nil );
ASSERT( queue->items != nil );
queue->items[queue->tail] = item;
queue->tail = (queue->tail + 1) % queue->size;
if ( queue->head == queue->tail )
debug("Queue is full\n");
}
int32
GetFirstInQueue(Queue *queue)
{
ASSERT( queue != nil );
if ( queue->head == queue->tail )
return -1;
ASSERT( queue->items != nil );
return queue->items[queue->head];
}
void
RemoveFirstInQueue(Queue *queue)
{
ASSERT( queue != nil );
if ( queue->head == queue->tail )
{
debug("Queue is empty\n");
return;
}
queue->head = (queue->head + 1) % queue->size;
}
void *CdStreamThread(void *param)
{
debug("Created cdstream thread\n");
#ifndef ONE_THREAD_PER_CHANNEL
while (gCdStreamThreadStatus != 2) {
sem_wait(gCdStreamSema);
int32 channel = GetFirstInQueue(&gChannelRequestQ);
2020-05-10 22:55:57 -04:00
#else
int channel = *((int*)param);
while (gpReadInfo[channel].nThreadStatus != 2){
sem_wait(gpReadInfo[channel].pStartSemaphore);
2020-05-10 22:55:57 -04:00
#endif
CdReadInfo *pChannel = &gpReadInfo[channel];
ASSERT( pChannel != nil );
// spurious wakeup or we sent interrupt signal for flushing
if(pChannel->nSectorsToRead == 0)
continue;
2020-05-10 22:55:57 -04:00
pChannel->bReading = true;
// Not standard POSIX :shrug:
#ifdef __linux__
#ifdef ONE_THREAD_PER_CHANNEL
if (gpReadInfo[channel].nThreadStatus == 0){
gpReadInfo[channel].nThreadStatus = 1;
#else
if (gCdStreamThreadStatus == 0){
gCdStreamThreadStatus = 1;
#endif
pid_t tid = syscall(SYS_gettid);
int ret = setpriority(PRIO_PROCESS, tid, getpriority(PRIO_PROCESS, getpid()) + 1);
}
#endif
2020-05-10 22:55:57 -04:00
if ( pChannel->nStatus == STREAM_NONE )
{
ASSERT(pChannel->hFile >= 0);
ASSERT(pChannel->pBuffer != nil );
2020-05-10 22:55:57 -04:00
lseek(pChannel->hFile, (size_t)pChannel->nSectorOffset * (size_t)CDSTREAM_SECTOR_SIZE, SEEK_SET);
if (read(pChannel->hFile, pChannel->pBuffer, pChannel->nSectorsToRead * CDSTREAM_SECTOR_SIZE) == -1) {
2020-05-10 22:55:57 -04:00
// pChannel->nSectorsToRead == 0 at this point means we wanted to flush channel
// STREAM_WAITING is a little hack to make CStreaming not process this data
pChannel->nStatus = pChannel->nSectorsToRead == 0 ? STREAM_WAITING : STREAM_ERROR;
} else {
pChannel->nStatus = STREAM_NONE;
}
2020-05-10 22:55:57 -04:00
}
2020-05-10 22:55:57 -04:00
#ifndef ONE_THREAD_PER_CHANNEL
RemoveFirstInQueue(&gChannelRequestQ);
#endif
pChannel->nSectorsToRead = 0;
if ( pChannel->bLocked )
{
2020-10-12 13:30:49 -04:00
pChannel->bLocked = 0;
2021-01-27 10:26:08 -05:00
sem_post(pChannel->pDoneSemaphore);
2020-05-10 22:55:57 -04:00
}
pChannel->bReading = false;
}
char semName[20];
2020-05-10 22:55:57 -04:00
#ifndef ONE_THREAD_PER_CHANNEL
for ( int32 i = 0; i < gNumChannels; i++ )
{
sem_close(gpReadInfo[i].pDoneSemaphore);
sprintf(semName,"/semaphore_done%d",i);
sem_unlink(semName);
}
sem_close(gCdStreamSema);
sem_unlink("/semaphore_cd_stream");
free(gChannelRequestQ.items);
2020-05-10 22:55:57 -04:00
#else
sem_close(gpReadInfo[channel].pStartSemaphore);
sprintf(semName,"/semaphore_start%d",channel);
sem_unlink(semName);
sem_close(gpReadInfo[channel].pDoneSemaphore);
sprintf(semName,"/semaphore_done%d",channel);
sem_unlink(semName);
2020-05-10 22:55:57 -04:00
#endif
if (gpReadInfo)
free(gpReadInfo);
gpReadInfo = nil;
2020-05-10 22:55:57 -04:00
pthread_exit(nil);
}
bool
CdStreamAddImage(char const *path)
{
ASSERT(path != nil);
ASSERT(gNumImages < MAX_CDIMAGES);
gImgFiles[gNumImages] = open(path, _gdwCdStreamFlags);
// Fix case sensitivity and backslashes.
if (gImgFiles[gNumImages] == -1) {
2020-07-26 13:59:58 -04:00
char* real = casepath(path, false);
if (real)
2020-05-10 22:55:57 -04:00
{
gImgFiles[gNumImages] = open(real, _gdwCdStreamFlags);
2020-07-26 13:59:58 -04:00
free(real);
2020-05-10 22:55:57 -04:00
}
}
if ( gImgFiles[gNumImages] == -1 ) {
assert(false);
return false;
}
gImgNames[gNumImages] = strdup(path);
gImgFiles[gNumImages]++; // because -1: error 0: not used
strcpy(gCdImageNames[gNumImages], path);
gNumImages++;
return true;
}
char *
CdStreamGetImageName(int32 cd)
{
ASSERT(cd < MAX_CDIMAGES);
if ( gImgFiles[cd] > 0)
return gCdImageNames[cd];
return nil;
}
void
CdStreamRemoveImages(void)
{
for ( int32 i = 0; i < gNumChannels; i++ ) {
2021-01-27 10:26:08 -05:00
#ifdef FLUSHABLE_STREAMING
flushStream[i] = 1;
2021-01-27 10:26:08 -05:00
#endif
2020-05-10 22:55:57 -04:00
CdStreamSync(i);
}
2020-05-10 22:55:57 -04:00
for ( int32 i = 0; i < gNumImages; i++ )
{
close(gImgFiles[i] - 1);
free(gImgNames[i]);
gImgFiles[i] = 0;
}
gNumImages = 0;
}
int32
CdStreamGetNumImages(void)
{
return gNumImages;
}
#endif