mirror of
https://github.com/open-goal/jak-project.git
synced 2024-10-20 11:26:18 -04:00
143 lines
3.5 KiB
C++
143 lines
3.5 KiB
C++
/*!
|
|
* @file deci2.cpp
|
|
* Implementation of SCE DECI2 library.
|
|
*/
|
|
|
|
#include <cassert>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include "deci2.h"
|
|
#include "game/system/Deci2Server.h"
|
|
|
|
namespace ee {
|
|
|
|
namespace {
|
|
// constexpr int MAX_DECI2_PROTOCOLS = 4;
|
|
// Deci2Driver protocols[MAX_DECI2_PROTOCOLS]; // info for each deci2 protocol registered
|
|
// int protocol_count; // number of registered protocols
|
|
// Deci2Driver* sending_driver; // currently sending protocol driver
|
|
//::Deci2Server* server; // the server to send data to
|
|
} // namespace
|
|
|
|
/*
|
|
* Initialize the library.
|
|
*/
|
|
void LIBRARY_INIT_sceDeci2() {
|
|
// // reset protocols
|
|
// for (auto& p : protocols) {
|
|
// p = Deci2Driver();
|
|
// }
|
|
// protocol_count = 0;
|
|
// server = nullptr;
|
|
// sending_driver = nullptr;
|
|
}
|
|
|
|
/*!
|
|
* Run any pending requested sends.
|
|
*/
|
|
void LIBRARY_sceDeci2_run_sends() {
|
|
return;
|
|
// for (auto& prot : protocols) {
|
|
// if (prot.active && prot.pending_send == 'H') {
|
|
// sending_driver = &prot;
|
|
// (prot.handler)(DECI2_WRITE, 0, prot.opt);
|
|
// sending_driver = nullptr;
|
|
// prot.pending_send = 0;
|
|
// (prot.handler)(DECI2_WRITEDONE, 0, prot.opt);
|
|
// }
|
|
//}
|
|
}
|
|
|
|
/*!
|
|
* Register a Deci2Server with this library.
|
|
*/
|
|
void LIBRARY_sceDeci2_register(::Deci2Server* s) {
|
|
// server = s;
|
|
}
|
|
|
|
/*!
|
|
* Open a new socket with given protocol number and handler.
|
|
* The "opt" pointer is passed to the handler function.
|
|
* I don't know why it's like this.
|
|
*/
|
|
s32 sceDeci2Open(u16 protocol, void* opt, void (*handler)(s32 event, s32 param, void* opt)) {
|
|
// server->lock();
|
|
// Deci2Driver drv;
|
|
// drv.protocol = protocol;
|
|
// drv.opt = opt;
|
|
// drv.handler = handler;
|
|
// drv.id = protocol_count + 1;
|
|
// drv.active = true;
|
|
// protocols[protocol_count++] = drv;
|
|
// printf("[DECI2] Add new protocol driver %d for 0x%x\n", drv.id, drv.protocol);
|
|
// server->unlock();
|
|
|
|
// if (protocol_count == 1) {
|
|
// // if we have our first protocol, inform the server we are ready to receive!
|
|
// // then the server will accept incoming data.
|
|
// server->send_proto_ready(protocols, &protocol_count);
|
|
//}
|
|
|
|
// return drv.id;
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* Deactivate a DECI2 protocol by socket descriptor.
|
|
*/
|
|
s32 sceDeci2Close(s32 s) {
|
|
// assert(s - 1 < protocol_count);
|
|
// protocols[s - 1].active = false;
|
|
// return 1;
|
|
return 1;
|
|
}
|
|
|
|
/*!
|
|
* Start a send.
|
|
*/
|
|
s32 sceDeci2ReqSend(s32 s, char dest) {
|
|
// assert(s - 1 < protocol_count);
|
|
// auto& proto = protocols[s - 1];
|
|
// proto.pending_send = dest;
|
|
// return 0;
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* Do a receive from socket s into buf of size len.
|
|
* Returns after data is copied.
|
|
*/
|
|
s32 sceDeci2ExRecv(s32 s, void* buf, u16 len) {
|
|
// assert(s - 1 < protocol_count);
|
|
// protocols[s - 1].recv_size = len;
|
|
// auto avail = protocols[s - 1].available_to_receive;
|
|
// if (len <= avail) {
|
|
// memcpy(buf, protocols[s - 1].recv_buffer, len);
|
|
// return len;
|
|
//} else {
|
|
// printf("[DECI2] Error: ExRecv %d, only %d available!\n", len, avail);
|
|
// return -1;
|
|
//}
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* Do a send.
|
|
*/
|
|
s32 sceDeci2ExSend(s32 s, void* buf, u16 len) {
|
|
// assert(s - 1 < protocol_count);
|
|
// if (!sending_driver) {
|
|
// printf("sceDeci2ExSend called at illegal time!\n");
|
|
// }
|
|
//
|
|
// if (&protocols[s - 1] != sending_driver) {
|
|
// printf("sceDeci2ExSend called with the wrong socket!\n");
|
|
// }
|
|
//
|
|
// server->send_data(buf, len);
|
|
// return len;
|
|
return 0;
|
|
}
|
|
|
|
} // namespace ee
|