BOOL
UfsFile::open(const TCHAR *name, uint32_t flags)
{
int error;
if (!_to_ascii(_ascii_filename, name, MAX_PATH))
return FALSE;
error = ufs_open(_ascii_filename, _f);
DPRINTF((TEXT("open file \"%s\" "), name));
if (!error)
DPRINTF((TEXT("(%d byte).\n"), size()));
else
DPRINTF((TEXT("failed.\n")));
return !error;
}
static int open_ts_file(stream_t * s)
{
unsigned short path_tmp[256] = {0};
char * p_filename1;
char file_new[256] = {0};
int ret = 0;
mtos_sem_take(&ts_sem, 0);
ret = ufs_close(s->fd);
mtos_sem_give(&ts_sem);
if (ret != FR_OK) {
mtos_printk("UFS close FAIL %d\n", ret);
return ret ;
}
memset(s->fd, 0, sizeof(ufs_file_t));
memset(file_new, 0, 256);
sprintf(file_new, "%s%04d%s", basename, rec_index, ".ts");
memset(path_tmp, 0, 256);
//mtos_printk("\n%s %d %s\n", __func__, __LINE__, file_new);
p_filename1 = Convert_Utf8_To_Unicode((unsigned char *)file_new, path_tmp);
memcpy(filename1, file_new, 256);
do {
//{
mtos_sem_take(&ts_sem, 0);
ret = ufs_open(s->fd, p_filename1, UFS_READ);
mtos_sem_give(&ts_sem);
mtos_task_sleep(10);
} while (ret == FR_NO_FILE && (is_file_seq_exit() == FALSE));
if(ret == FR_OK)
{
mtos_sem_take(&ts_sem, 0);
ufs_ioctl(s->fd, FS_SEEK_LINKMAP, 0 , 0 , 0);
mtos_sem_give(&ts_sem);
}
return ret;
}
PS2EMU_PATCHED_FUNCTION(int, open_iso, (int unk, char *path))
{
/*uint64_t val;
for(uint64_t i=0;i<0x50;i+=8)
{
val = dump_ram(0x3174478ULL+i);
int dump = ufs_open(0, "/tmp/dump");
ufs_write(dump, 1, (void *)val, 8);
}*/
if (!vars->setup_done)
{
// if (strstr(path, "--COBRA--"))
// {
int fd = ufs_open(0, CONFIG_FILE);
if (fd >= 0)
{
uint8_t b;
ufs_read(fd, 0, &b, 1);
vars->is_cd = (b&1);
ufs_read(fd, 1, vars->iso_file, 0x6FF);
ufs_read(fd, 0x702, vars->mnt, 0xf0);
if((strstr(vars->mnt, "mount")) || (strstr(path, "--COBRA--")))
{
uint8_t disable=0x00;
ufs_write(fd, 0x702, &disable, 1);
if (vars->is_cd)
{
static int open_f(stream_t * stream, int mode, void * opts, int * file_format)
{
#ifndef __LINUX__
ufs_file_t * f = malloc(sizeof(ufs_file_t)); //= stream->fd;
recv_bytes = 0;
memset(f, 0, sizeof(ufs_file_t));
memset(filename1, 0, 512);
#else
int f = 0;
#endif
mode_t m = 0;
file_size = 0;
long long len;
unsigned char * filename = NULL;
struct stream_priv_s * p = (struct stream_priv_s *)opts;
if (mode == STREAM_READ) {
m = O_RDONLY;
} else if (mode == STREAM_WRITE) {
m = O_RDWR | O_CREAT | O_TRUNC;
} else {
mp_msg(MSGT_OPEN, MSGL_ERR, "[file] Unknown open mode %d\n", mode);
m_struct_free(&stream_opts, opts);
return STREAM_UNSUPPORTED;
}
if (p->filename) {
filename = p->filename;
} else if (p->filename2) {
filename = p->filename2;
} else {
filename = NULL;
}
if (!filename) {
mp_msg(MSGT_OPEN, MSGL_ERR, "[file] No filename\n");
m_struct_free(&stream_opts, opts);
return STREAM_ERROR;
}
#if HAVE_DOS_PATHS
// extract '/' from '/x:/path'
if (filename[ 0 ] == '/' && filename[ 1 ] && filename[ 2 ] == ':') {
filename++;
}
#endif
m |= O_BINARY;
if (!strcmp(filename, "-")) {
#ifdef __LINUX__
if (mode == STREAM_READ) {
// read from stdin
mp_msg(MSGT_OPEN, MSGL_INFO, MSGTR_ReadSTDIN);
f = 0; // 0=stdin
#if HAVE_SETMODE
setmode(fileno(stdin), O_BINARY);
#endif
} else {
mp_msg(MSGT_OPEN, MSGL_INFO, "Writing to stdout\n");
f = 1;
#if HAVE_SETMODE
setmode(fileno(stdout), O_BINARY);
#endif
}
#endif
} else {
#ifdef __LINUX__
mode_t openmode = S_IRUSR | S_IWUSR;
#ifndef __MINGW32__
openmode |= S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
#endif
f = open(filename, m, openmode);
if (f < 0) {
mp_msg(MSGT_OPEN, MSGL_ERR, MSGTR_FileNotFound, filename);
m_struct_free(&stream_opts, opts);
return STREAM_ERROR;
}
#else
// ufs_asc2uni(filename,filename1);
//printf("\n before ufs open filename:%s \n",filename);
memcpy(filename1, filename, strlen(filename));
int ret = 0;
unsigned short * p_filename1;
{
unsigned short path_tmp[512] = {0};
p_filename1 = Convert_Utf8_To_Unicode((unsigned char *)filename, path_tmp);
ret = ufs_open(f, p_filename1, UFS_READ);
}
if (ret != FR_OK) {
mtos_printk("[%s][ERROR][ERROR] UFS OPEN FAIL %d!!!!!!!!!\n", __func__, ret);
m_struct_free(&stream_opts, opts);
free(f);
return STREAM_ERROR;
}
#if 1
// mtos_printk("\n%s %d \n", __func__, __LINE__);
{
int r = 0;
char pvr_timeshift[512] = {0};
char pvr_ists[32] = {0};
recv_bytes_inter = 0;
ret = ufs_read(f, pvr_timeshift, 512, &r);
int time_mode;
mp_timeshift_size = 0;
file_size = 0;
sect_size = 0;
if (ret != FR_OK) {
mtos_printk("[%s][ERROR][ERROR] UFS OPEN FAIL %d!!!!!!!!!\n", __func__, ret);
m_struct_free(&stream_opts, opts);
return STREAM_ERROR;
}
if (strstr(pvr_timeshift, "pvrtimeshift")) {
memcpy(&mp_timeshift_size, pvr_timeshift + 32, sizeof(int));
memcpy(&time_mode, pvr_timeshift + 32 + sizeof(int), sizeof(int));
memcpy(basename, pvr_timeshift + 32 + 2 * sizeof(int), 256);
memcpy(&file_size, pvr_timeshift + 384, sizeof(int));
memcpy(§_size, pvr_timeshift + 384+sizeof(int), sizeof(int));
rec_index = 1;
}
}
#endif
printf("\n ufs open ok f: %x \n", f);
#ifndef __LINUX__
ret = ufs_ioctl(f, FS_SEEK_LINKMAP, 0 , 0 , 0);
#endif
#endif
}
#ifdef __LINUX__
len = lseek(f, 0, SEEK_END);
lseek(f, 0, SEEK_SET);
#else
if (fp_is_timeshift_file() == 1) {
while(mp_rec_bytes<sect_size*2)
{
mtos_task_sleep(100);
}
len = mp_rec_bytes;
} else if (file_size > 0) {
len = file_size;
} else {
len = f->file_size;
}
if (ufs_lseek(f, 0, 0) == FR_OK) {
OS_PRINTF("#########@@@@#######\n");
} else {
OS_PRINTF("#########@@1111@@#######\n");
}
#endif
#ifdef __MINGW32__
// seeks on stdin incorrectly succeed on MinGW
if (f == 0) {
len = -1;
}
#endif
if (len == -1) {
if (mode == STREAM_READ) {
stream->seek = seek_forward;
}
stream->type = STREAMTYPE_STREAM; // Must be move to STREAMTYPE_FILE
stream->flags |= MP_STREAM_SEEK_FW;
} else if (len >= 0) {
stream->seek = seek;
stream->end_pos = len;
stream->type = STREAMTYPE_FILE;
}
mp_msg(MSGT_OPEN, MSGL_V, "[file] File size is %"PRId64" bytes\n", (int64_t)len);
// #ifdef __LINUX__
stream->fd = f;
//#endif
stream->fill_buffer = fill_buffer;
stream->write_buffer = write_buffer;
stream->control = control;
stream->read_chunk = 64 * 1024;
m_struct_free(&stream_opts, opts);
return STREAM_OK;
}
