TCPConnection::~TCPConnection() {
FinishDisconnect();
ClearBuffers();
if (ConnectionType == Outgoing) {
MRunLoop.lock();
pRunLoop = false;
MRunLoop.unlock();
MLoopRunning.lock();
MLoopRunning.unlock();
#if TCPN_DEBUG_Memory >= 6
std::cout << "Deconstructor on outgoing TCP# " << GetID() << std::endl;
#endif
}
#if TCPN_DEBUG_Memory >= 5
else {
std::cout << "Deconstructor on incomming TCP# " << GetID() << std::endl;
}
#endif
safe_delete_array(recvbuf);
safe_delete_array(sendbuf);
safe_delete_array(charAsyncConnect);
}
void TCPConnection::FinishDisconnect() {
MState.lock();
if (connection_socket != INVALID_SOCKET && connection_socket != 0) {
if (pState == TCPS_Connected || pState == TCPS_Disconnecting || pState == TCPS_Disconnected) {
bool sent_something = false;
SendData(sent_something);
}
pState = TCPS_Closing;
shutdown(connection_socket, 0x01);
shutdown(connection_socket, 0x00);
#ifdef _WINDOWS
closesocket(connection_socket);
#else
close(connection_socket);
#endif
connection_socket = 0;
rIP = 0;
rPort = 0;
ClearBuffers();
}
pState = TCPS_Disconnected;
MState.unlock();
}
FDrawInfo::~FDrawInfo()
{
ClearBuffers();
}
void ShowScene(int mode, int view_mode, int quad, GLint s_left, GLint s_down){
CheckMemory;
show_mode = mode;
UNCLIP;
/* ++++++++++++++++++++++++ update variables as needed +++++++++++++++++++++++++ */
update_ShowScene();
if(showstereo == STEREO_NONE || showstereo == STEREO_TIME)ClearBuffers(mode);
/* ++++++++++++++++++++++++ setup viewports +++++++++++++++++++++++++ */
if(mode == DRAWSCENE){
Get_VP_info();
if(clip_rendered_scene == 1){
CLIP_viewport(quad, s_left, s_down);
SNIFF_ERRORS("after CLIP_viewport");
}
if(VP_info.doit == 1){
INFO_viewport(quad, s_left, s_down);
SNIFF_ERRORS("after INFO_viewport");
}
if(VP_timebar.doit == 1){
TIMEBAR_viewport(quad, s_left, s_down);
SNIFF_ERRORS("after TIMEBAR_viewport");
}
if(VP_colorbar.doit == 1){
COLORBAR_viewport(quad, s_left, s_down);
SNIFF_ERRORS("after COLORBAR_viewport");
}
if(VP_title.doit == 1){
TITLE_viewport(quad, s_left, s_down);
SNIFF_ERRORS("after TITLE_viewport");
}
Scene_viewport(quad, view_mode, s_left, s_down);
SNIFF_ERRORS("after Scene_viewport");
}
/* ++++++++++++++++++++++++ draw "fancy" colorbar +++++++++++++++++++++++++ */
if(viscolorbarpath == 1){
if(colorbar_hidescene == 1)UNCLIP;
drawcolorbarpath();
SNIFF_ERRORS("after setColorbarClipPlanes 1");
}
if(viscolorbarpath==0||colorbar_hidescene==0)ShowScene2(mode, view_mode, quad, s_left, s_down);
/* ++++++++++++++++++++++++ render scene +++++++++++++++++++++++++ */
Render(view_mode);
/* ++++++++++++++++++++++++ draw "fancy" colorbar +++++++++++++++++++++++++ */
SNIFF_ERRORS("end of loop");
}
bool TCPConnection::ConnectIP(uint32 in_ip, uint16 in_port, char* errbuf) {
if (errbuf)
errbuf[0] = 0;
if (ConnectionType != Outgoing) {
// If this code runs, we got serious problems
// Crash and burn.
return false;
}
MState.lock();
if (ConnectReady()) {
pState = TCPS_Connecting;
} else {
MState.unlock();
SetAsyncConnect(false);
return false;
}
MState.unlock();
if (!pRunLoop) {
pRunLoop = true;
#ifdef _WINDOWS
_beginthread(TCPConnectionLoop, 0, this);
#else
pthread_t thread;
pthread_create(&thread, nullptr, TCPConnectionLoop, this);
#endif
}
connection_socket = INVALID_SOCKET;
struct sockaddr_in server_sin;
//struct in_addr in;
if ((connection_socket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET || connection_socket == 0) {
#ifdef _WINDOWS
if (errbuf)
snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): Allocating socket failed. Error: %i", WSAGetLastError());
#else
if (errbuf)
snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): Allocating socket failed. Error: %s", strerror(errno));
#endif
SetState(TCPS_Ready);
SetAsyncConnect(false);
return false;
}
server_sin.sin_family = AF_INET;
server_sin.sin_addr.s_addr = in_ip;
server_sin.sin_port = htons(in_port);
// Establish a connection to the server socket.
#ifdef _WINDOWS
if (connect(connection_socket, (PSOCKADDR) &server_sin, sizeof (server_sin)) == SOCKET_ERROR) {
if (errbuf)
snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): connect() failed. Error: %i", WSAGetLastError());
closesocket(connection_socket);
connection_socket = 0;
SetState(TCPS_Ready);
SetAsyncConnect(false);
return false;
}
#else
if (connect(connection_socket, (struct sockaddr *) &server_sin, sizeof (server_sin)) == SOCKET_ERROR) {
if (errbuf)
snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): connect() failed. Error: %s", strerror(errno));
close(connection_socket);
connection_socket = 0;
SetState(TCPS_Ready);
SetAsyncConnect(false);
return false;
}
#endif
int bufsize = 64 * 1024; // 64kbyte recieve buffer, up from default of 8k
setsockopt(connection_socket, SOL_SOCKET, SO_RCVBUF, (char*) &bufsize, sizeof(bufsize));
#ifdef _WINDOWS
unsigned long nonblocking = 1;
ioctlsocket(connection_socket, FIONBIO, &nonblocking);
#else
fcntl(connection_socket, F_SETFL, O_NONBLOCK);
#endif
SetEcho(false);
ClearBuffers();
rIP = in_ip;
rPort = in_port;
SetState(TCPS_Connected);
SetAsyncConnect(false);
return true;
}
FDrawInfo::~FDrawInfo()
{
if (dldrawlists != NULL) delete[] dldrawlists;
ClearBuffers();
}
// called from ---GUI--- thread
bool NetPlayClient::StartGame(const std::string &path)
{
std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
// tell server i started the game
sf::Packet* spac = new sf::Packet;
*spac << (MessageId)NP_MSG_START_GAME;
*spac << m_current_game;
*spac << (char *)&g_NetPlaySettings;
SendAsync(spac);
if (m_is_running.load())
{
PanicAlertT("Game is already running!");
return false;
}
m_dialog->AppendChat(" -- STARTING GAME -- ");
m_timebase_frame = 0;
m_is_running.store(true);
NetPlay_Enable(this);
ClearBuffers();
if (m_dialog->IsRecording())
{
if (Movie::IsReadOnly())
Movie::SetReadOnly(false);
u8 controllers_mask = 0;
for (unsigned int i = 0; i < 4; ++i)
{
if (m_pad_map[i] > 0)
controllers_mask |= (1 << i);
if (m_wiimote_map[i] > 0)
controllers_mask |= (1 << (i + 4));
}
Movie::BeginRecordingInput(controllers_mask);
}
// boot game
m_dialog->BootGame(path);
UpdateDevices();
if (SConfig::GetInstance().bWii)
{
for (unsigned int i = 0; i < 4; ++i)
WiimoteReal::ChangeWiimoteSource(i, m_wiimote_map[i] > 0 ? WIIMOTE_SRC_EMU : WIIMOTE_SRC_NONE);
// Needed to prevent locking up at boot if (when) the wiimotes connect out of order.
NetWiimote nw;
nw.resize(4, 0);
for (unsigned int w = 0; w < 4; ++w)
{
if (m_wiimote_map[w] != -1)
// probably overkill, but whatever
for (unsigned int i = 0; i < 7; ++i)
m_wiimote_buffer[w].Push(nw);
}
}
return true;
}
// called from ---GUI--- thread
NetPlayClient::NetPlayClient(const std::string& address, const u16 port, NetPlayUI* dialog, const std::string& name, bool traversal, const std::string& centralServer, u16 centralPort)
: m_state(Failure)
, m_dialog(dialog)
, m_client(nullptr)
, m_server(nullptr)
, m_is_running(false)
, m_do_loop(true)
, m_target_buffer_size()
, m_local_player(nullptr)
, m_current_game(0)
, m_is_recording(false)
, m_pid(0)
, m_connecting(false)
, m_traversal_client(nullptr)
{
m_target_buffer_size = 20;
ClearBuffers();
is_connected = false;
m_player_name = name;
if (!traversal)
{
//Direct Connection
m_client = enet_host_create(nullptr, 1, 3, 0, 0);
if (m_client == nullptr)
{
PanicAlertT("Couldn't Create Client");
}
ENetAddress addr;
enet_address_set_host(&addr, address.c_str());
addr.port = port;
m_server = enet_host_connect(m_client, &addr, 3, 0);
if (m_server == nullptr)
{
PanicAlertT("Couldn't create peer.");
}
ENetEvent netEvent;
int net = enet_host_service(m_client, &netEvent, 5000);
if (net > 0 && netEvent.type == ENET_EVENT_TYPE_CONNECT)
{
if (Connect())
{
m_client->intercept = ENetUtil::InterceptCallback;
m_thread = std::thread(&NetPlayClient::ThreadFunc, this);
}
}
else
{
PanicAlertT("Failed to Connect!");
}
}
else
{
if (address.size() > NETPLAY_CODE_SIZE)
{
PanicAlertT("Host code size is to large.\nPlease recheck that you have the correct code");
return;
}
if (!EnsureTraversalClient(centralServer, centralPort))
return;
m_client = g_MainNetHost.get();
m_traversal_client = g_TraversalClient.get();
// If we were disconnected in the background, reconnect.
if (m_traversal_client->m_State == TraversalClient::Failure)
m_traversal_client->ReconnectToServer();
m_traversal_client->m_Client = this;
m_host_spec = address;
m_state = WaitingForTraversalClientConnection;
OnTraversalStateChanged();
m_connecting = true;
Common::Timer connect_timer;
connect_timer.Start();
while (m_connecting)
{
ENetEvent netEvent;
if (m_traversal_client)
m_traversal_client->HandleResends();
while (enet_host_service(m_client, &netEvent, 4) > 0)
{
sf::Packet rpac;
switch (netEvent.type)
{
case ENET_EVENT_TYPE_CONNECT:
m_server = netEvent.peer;
if (Connect())
{
m_state = Connected;
m_thread = std::thread(&NetPlayClient::ThreadFunc, this);
}
return;
default:
break;
}
}
if (connect_timer.GetTimeElapsed() > 5000)
break;
}
PanicAlertT("Failed To Connect!");
}
}
//////////////////////////// MAIN //////////////////// MAIN //////////////
int main()
{
// Local Variables for main()
int i = 0; // index
int menusel = 99999; // Menu Select
int mode = 9; // Mode of Operation
int enable_state = 0; // 0: disabled, 1: enabled
int thres = 0; // Trigger Threshold
char updateint = 'N'; // switch to change integral values
u32 databuff = 0; // size of the data buffer
// Initialize System
init_platform(); // This initializes the platform, which is ...
ps7_post_config();
Xil_DCacheDisable(); //
InitializeAXIDma(); // Initialize the AXI DMA Transfer Interface
Xil_Out32 (XPAR_AXI_GPIO_16_BASEADDR, 16384);
Xil_Out32 (XPAR_AXI_GPIO_17_BASEADDR , 1);
InitializeInterruptSystem(XPAR_PS7_SCUGIC_0_DEVICE_ID);
for (i=0; i<32; i++ ) { RecvBuffer[i] = '_'; } // Clear RecvBuffer Variable
for (i=0; i<32; i++ ) { SendBuffer[i] = '_'; } // Clear SendBuffer Variable
//*******************Setup the UART **********************//
XUartPs_Config *Config = XUartPs_LookupConfig(UART_DEVICEID);
if (NULL == Config) { return 1;}
Status = XUartPs_CfgInitialize(&Uart_PS, Config, Config->BaseAddress);
if (Status != 0){ return 1; }
/* Conduct a Selftest for the UART */
Status = XUartPs_SelfTest(&Uart_PS);
if (Status != 0) { return 1; }
/* Set to normal mode. */
XUartPs_SetOperMode(&Uart_PS, XUARTPS_OPER_MODE_NORMAL);
//*******************Setup the UART **********************//
//*******************Receive and Process Packets **********************//
Xil_Out32 (XPAR_AXI_GPIO_0_BASEADDR, 11);
Xil_Out32 (XPAR_AXI_GPIO_1_BASEADDR, 71);
Xil_Out32 (XPAR_AXI_GPIO_2_BASEADDR, 167);
Xil_Out32 (XPAR_AXI_GPIO_3_BASEADDR, 2015);
Xil_Out32 (XPAR_AXI_GPIO_4_BASEADDR, 12);
Xil_Out32 (XPAR_AXI_GPIO_5_BASEADDR, 75);
Xil_Out32 (XPAR_AXI_GPIO_6_BASEADDR, 75);
Xil_Out32 (XPAR_AXI_GPIO_7_BASEADDR, 5);
Xil_Out32 (XPAR_AXI_GPIO_8_BASEADDR, 25);
//*******************Receive and Process Packets **********************//
//******************Setup Detector and Module Objects*****************//
//LDetector *Detector = LDetector();
//Detector->SetMode(1); // Processed Data Mode
//******************Setup Detector and Module Objects*****************//
// *********** Setup the Hardware Reset GPIO ****************//
GPIOConfigPtr = XGpioPs_LookupConfig(XPAR_PS7_GPIO_0_DEVICE_ID);
Status = XGpioPs_CfgInitialize(&Gpio, GPIOConfigPtr, GPIOConfigPtr ->BaseAddr);
if (Status != XST_SUCCESS) { return XST_FAILURE; }
XGpioPs_SetDirectionPin(&Gpio, SW_BREAK_GPIO, 1);
// *********** Setup the Hardware Reset MIO ****************//
// ******************* POLLING LOOP *******************//
xil_printf("\n\r Turn on Local Echo: under Terminal-Setup in Tera Term \n\r");
xil_printf(" Code is expecting a 'Return' after Each Command \n\r");
while(1){
sw = 0; // stop switch reset to 0
XUartPs_SetOptions(&Uart_PS,XUARTPS_OPTION_RESET_RX); // Clear UART Read Buffer
for (i=0; i<32; i++ ) { RecvBuffer[i] = '_'; } // Clear RecvBuffer Variable
sleep(0.5); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 0.5 s
xil_printf("\n\r MAIN MENU \n\r");
xil_printf("******************************\n\r");
xil_printf(" 0) Set Mode of Operation\n\r");
xil_printf(" 1) Enable or disable the system\n\r");
xil_printf(" 2) Continuously Read of Processed Data\n\r");
xil_printf("\n\r **Setup Parameters ** \n\r");
xil_printf(" 3) Set Trigger Threshold\n\r");
xil_printf(" 4) Set Integration Times (number of clock cycles * 4ns) \n\r");
xil_printf("\n\r ** Additional Commands ** \n\r");
xil_printf(" 5) Perform a DMA transfer of Waveform Data\n\r");
xil_printf(" 6) Perform a DMA transfer of Processed Data\n\r");
xil_printf(" 7) Check the Size of the Data Buffered (Max = 4095) \n\r");
xil_printf(" 8) Clear the Processed Data Buffers\n\r");
xil_printf(" 9) Execute Print of Data on DRAM \n\r");
xil_printf("******************************\n\n\r");
while (XUartPs_IsSending(&Uart_PS)) {i++;} // Wait until Write Buffer is Sent
// Wait for Input, Check
// If input is valid break while and enter case statement
// If input is invalid break and try again
ReadCommandPoll();
menusel = 99999;
sscanf(RecvBuffer,"%01d",&menusel);
if ( menusel < 0 || menusel > 9 ) {
xil_printf(" Invalid Command: Enter 0-9 \n\r");
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
}
switch (menusel) { // Switch-Case Menu Select
case 0: //Set Mode of Operation
mode = 99; //Detector->GetMode();
xil_printf("\n\r Waveform Data: \t Enter 0 <return>\n\r");
xil_printf(" LPF Waveform Data: \t Enter 1 <return>\n\r");
xil_printf(" DFF Waveform Data: \t Enter 2 <return>\n\r");
xil_printf(" TRG Waveform Data: \t Enter 3 <return>\n\r");
xil_printf(" Processed Data: \t Enter 4 <return>\n\r");
ReadCommandPoll();
sscanf(RecvBuffer,"%01d",&mode);
if (mode < 0 || mode > 4 ) { xil_printf("Invalid Command\n\r"); break; }
// mode = 0, AA waveform
// mode = 1, LPF waveform
// mode = 2, DFF waveform
// mode = 3, TRG waveform
// mode = 4, Processed Data
//Detector->SetMode(mode); // Set Mode for Detector
Xil_Out32 (XPAR_AXI_GPIO_14_BASEADDR, ((u32)mode));
// Register 14
if ( mode == 0 ) { xil_printf("Transfer AA Waveforms\n\r"); }
if ( mode == 1 ) { xil_printf("Transfer LPF Waveforms\n\r"); }
if ( mode == 2 ) { xil_printf("Transfer DFF Waveforms\n\r"); }
if ( mode == 3 ) { xil_printf("Transfer TRG Waveforms\n\r"); }
if ( mode == 4 ) { xil_printf("Transfer Processed Data\n\r"); }
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
break;
case 1: //Enable or disable the system
xil_printf("\n\r Disable: Enter 0 <return>\n\r");
xil_printf(" Enable: Enter 1 <return>\n\r");
ReadCommandPoll();
sscanf(RecvBuffer,"%01d",&enable_state);
if (enable_state != 0 && enable_state != 1) { xil_printf("Invalid Command\n\r"); break; }
Xil_Out32(XPAR_AXI_GPIO_18_BASEADDR, ((u32)enable_state));
// Register 18 Out enabled, In Disabled
if ( enable_state == 1 ) { xil_printf("DAQ Enabled\n\r"); }
if ( enable_state == 0 ) { xil_printf("DAQ Disabled\n\r"); }
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
break;
case 2: //Continuously Read of Processed Data
xil_printf("\n\r ********Data Acquisition:\n\r");
xil_printf(" Press 'q' to Stop or Press Hardware USR reset button \n\r");
xil_printf(" Press <return> to Start");
ReadCommandPoll();
DAQ();
sw = 0; // broke out of the read loop, stop swith reset to 0
break;
case 3: //Set Threshold
xil_printf("\n\r Existing Threshold = %d \n\r",Xil_In32(XPAR_AXI_GPIO_10_BASEADDR));
xil_printf(" Enter Threshold (6144 to 10240) <return> \n\r");
ReadCommandPoll();
sscanf(RecvBuffer,"%04d",&thres);
Xil_Out32(XPAR_AXI_GPIO_10_BASEADDR, ((u32)thres));
xil_printf("New Threshold = %d \n\r",Xil_In32(XPAR_AXI_GPIO_10_BASEADDR));
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
break;
case 4: //Set Integration Times
xil_printf("\n\r Existing Integration Times \n\r");
xil_printf(" Time = 0 ns is when the Pulse Crossed Threshold \n\r");
xil_printf(" Baseline Integral Window \t [-200ns,%dns] \n\r",-52 + ((int)Xil_In32(XPAR_AXI_GPIO_0_BASEADDR))*4 );
xil_printf(" Short Integral Window \t [-200ns,%dns] \n\r",-52 + ((int)Xil_In32(XPAR_AXI_GPIO_1_BASEADDR))*4 );
xil_printf(" Long Integral Window \t [-200ns,%dns] \n\r",-52 + ((int)Xil_In32(XPAR_AXI_GPIO_2_BASEADDR))*4 );
xil_printf(" Full Integral Window \t [-200ns,%dns] \n\r",-52 + ((int)Xil_In32(XPAR_AXI_GPIO_3_BASEADDR))*4 );
xil_printf(" Change: (Y)es (N)o <return>\n\r");
ReadCommandPoll();
sscanf(RecvBuffer,"%c",&updateint);
if (updateint == 'N' || updateint == 'n') { break; }
if (updateint == 'Y' || updateint == 'y') { SetIntegrationTimes(0); }
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
break;
case 5: //Perform a DMA transfer
xil_printf("\n\r Perform DMA Transfer of Waveform Data\n\r");
xil_printf(" Press 'q' to Exit Transfer \n\r");
Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x48, 0xa000000);
Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x58 , 65536);
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
PrintData(); // Display data to console.
sw = 0; // broke out of the read loop, stop swith reset to 0
break;
case 6: //Perform a DMA transfer of Processed data
xil_printf("\n\r ********Perform DMA Transfer of Processed Data \n\r");
xil_printf(" Press 'q' to Exit Transfer \n\r");
//Xil_Out32 (XPAR_AXI_GPIO_18_BASEADDR, 0); // Disable : GPIO Reg Capture Module
Xil_Out32 (XPAR_AXI_GPIO_15_BASEADDR, 1); // Enable: GPIO Reg to Readout Data MUX
//sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x48, 0xa000000); // Transfer from BRAM to DRAM, start address 0xa000000, 16-bit length
Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x58 , 65536);
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
Xil_Out32 (XPAR_AXI_GPIO_15_BASEADDR, 0); // Disable: GPIO Reg turn off Readout Data MUX
ClearBuffers();
PrintData(); // Display data to console.
//Xil_Out32 (XPAR_AXI_GPIO_18_BASEADDR, 1); // Enable : GPIO Reg Capture Module
sw = 0; // broke out of the read loop, stop swith reset to 0
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
break;
case 7: //Check the Size of the Data Buffers
databuff = Xil_In32 (XPAR_AXI_GPIO_11_BASEADDR);
xil_printf("\n\r BRAM Data Buffer Size = %d \n\r",databuff);
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
break;
case 8: //Clear the processed data buffers
xil_printf("\n\r Clear the Data Buffers\n\r");
ClearBuffers();
sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s
break;
case 9: //Print DMA Data
xil_printf("\n\r Print Data\n\r");
PrintData();
break;
default :
break;
} // End Switch-Case Menu Select
} // ******************* POLLING LOOP *******************//
cleanup_platform(); // Clean up the platform, which is ...
return 0;
}
CC608Buffer* CC608Reader::GetOutputText(bool &changed)
{
if (!m_enabled || !m_parent)
return NULL;
VideoFrame *last = NULL;
if (m_parent->getVideoOutput())
last = m_parent->getVideoOutput()->GetLastShownFrame();
if (NumInputBuffers() && m_inputBuffers[m_writePosition].timecode &&
(last && m_inputBuffers[m_writePosition].timecode <= last->timecode))
{
if (m_inputBuffers[m_writePosition].type == 'T')
{
// display full page of teletext
//
// all formatting is always defined in the page itself,
// if scrolling is needed for live closed captions this
// is handled by the broadcaster:
// the pages are then very often transmitted (sometimes as often as
// every 2 frames) with small differences between them
unsigned char *inpos = m_inputBuffers[m_writePosition].buffer;
int pagenr;
memcpy(&pagenr, inpos, sizeof(int));
inpos += sizeof(int);
if (pagenr == (m_ccPageNum<<16))
{
// show teletext subtitles
ClearBuffers(false, true);
(*inpos)++;
while (*inpos)
{
struct teletextsubtitle st;
memcpy(&st, inpos, sizeof(st));
inpos += sizeof(st);
CC608Text *cc = new CC608Text(QString((const char*) inpos),
st.row, st.col, st.fg, true);
m_outputBuffers.lock.lock();
m_outputBuffers.buffers.push_back(cc);
m_outputBuffers.lock.unlock();
inpos += st.len;
}
changed = true;
}
}
else if (m_inputBuffers[m_writePosition].type == 'C')
{
Update(m_inputBuffers[m_writePosition].buffer);
changed = true;
}
QMutexLocker locker(&m_inputBufLock);
if (m_writePosition != m_readPosition)
m_writePosition = (m_writePosition + 1) % MAXTBUFFER;
}
m_changed = false;
return &m_outputBuffers;
}
void CC608Reader::Update(unsigned char *inpos)
{
struct ccsubtitle subtitle;
memcpy(&subtitle, inpos, sizeof(subtitle));
inpos += sizeof(ccsubtitle);
// skip undisplayed streams
if ((subtitle.resumetext & CC_MODE_MASK) != m_ccMode)
return;
if (subtitle.row == 0)
subtitle.row = 1;
if (subtitle.clr)
{
//printf ("erase displayed memory\n");
ClearBuffers(false, true);
if (!subtitle.len)
return;
}
// if (subtitle.len || !subtitle.clr)
{
unsigned char *end = inpos + subtitle.len;
int row = 0;
int linecont = (subtitle.resumetext & CC_LINE_CONT);
vector<CC608Text*> *ccbuf = new vector<CC608Text*>;
vector<CC608Text*>::iterator ccp;
CC608Text *tmpcc = NULL;
int replace = linecont;
int scroll = 0;
bool scroll_prsv = false;
int scroll_yoff = 0;
int scroll_ymax = 15;
do
{
if (linecont)
{
// append to last line; needs to be redrawn
replace = 1;
// backspace into existing line if needed
int bscnt = 0;
while ((inpos < end) && *inpos != 0 && (char)*inpos == '\b')
{
bscnt++;
inpos++;
}
if (bscnt)
m_outputText.remove(m_outputText.length() - bscnt, bscnt);
}
else
{
// new line: count spaces to calculate column position
row++;
m_outputCol = 0;
m_outputText = "";
while ((inpos < end) && *inpos != 0 && (char)*inpos == ' ')
{
inpos++;
m_outputCol++;
}
}
m_outputRow = subtitle.row;
unsigned char *cur = inpos;
//null terminate at EOL
while (cur < end && *cur != '\n' && *cur != 0)
cur++;
*cur = 0;
if (*inpos != 0 || linecont)
{
if (linecont)
m_outputText += QString::fromUtf8((const char *)inpos, -1);
else
m_outputText = QString::fromUtf8((const char *)inpos, -1);
tmpcc = new CC608Text(m_outputText, m_outputCol, m_outputRow,
0, false);
ccbuf->push_back(tmpcc);
#if 0
if (ccbuf->size() > 4)
{
QByteArray ccl = m_outputText.toAscii();
printf("CC overflow: ");
printf("%d %d %s\n", m_outputCol, m_outputRow, ccl.constData());
}
#endif
}
subtitle.row++;
inpos = cur + 1;
linecont = 0;
} while (inpos < end);
// adjust row position
if (subtitle.resumetext & CC_TXT_MASK)
{
// TXT mode
// - can use entire 15 rows
// - scroll up when reaching bottom
if (m_outputRow > 15)
{
if (row)
scroll = m_outputRow - 15;
if (tmpcc)
tmpcc->y = 15;
}
}
else if (subtitle.rowcount == 0 || row > 1)
{
// multi-line text
// - fix display of old (badly-encoded) files
if (m_outputRow > 15)
{
ccp = ccbuf->begin();
for (; ccp != ccbuf->end(); ccp++)
{
tmpcc = *ccp;
tmpcc->y -= (m_outputRow - 15);
}
}
}
else
{
// scrolling text
// - scroll up previous lines if adding new line
// - if caption is at bottom, row address is for last
// row
// - if caption is at top, row address is for first row (?)
if (subtitle.rowcount > 4)
subtitle.rowcount = 4;
if (m_outputRow < subtitle.rowcount)
{
m_outputRow = subtitle.rowcount;
if (tmpcc)
tmpcc->y = m_outputRow;
}
if (row)
{
scroll = row;
scroll_prsv = true;
scroll_yoff = m_outputRow - subtitle.rowcount;
scroll_ymax = m_outputRow;
}
}
Update608Text(ccbuf, replace, scroll,
scroll_prsv, scroll_yoff, scroll_ymax);
delete ccbuf;
}
}
// called from ---GUI--- thread
NetPlay::NetPlay(NetPlayUI* dialog)
: m_dialog(dialog), m_is_running(false), m_do_loop(true)
{
m_target_buffer_size = 20;
ClearBuffers();
}
/*
This is the basic display callback routine
It creates the geometry, lighting, and viewing position
*/
void HandleDisplay(void)
{
XYZ r;
double ratio,radians,wd2,ndfl;
double left,right,top,bottom;
/* Misc stuff needed for the frustum */
ratio = camera.screenwidth / (double)camera.screenheight;
if (camera.stereo == DUALSTEREO)
ratio /= 2;
radians = DTOR * camera.aperture / 2;
wd2 = camera.near * tan(radians);
ndfl = camera.near / camera.focallength;
top = wd2;
bottom = - wd2;
/* Clear the buffers */
if (camera.stereo == ACTIVESTEREO)
ClearBuffers(2);
else
ClearBuffers(1);
/* Determine the right eye vector */
CROSSPROD(camera.vd,camera.vu,r);
Normalise(&r);
r.x *= camera.eyesep / 2.0;
r.y *= camera.eyesep / 2.0;
r.z *= camera.eyesep / 2.0;
if (camera.stereo == ACTIVESTEREO || camera.stereo == DUALSTEREO) {
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
left = - ratio * wd2 - 0.5 * camera.eyesep * ndfl;
right = ratio * wd2 - 0.5 * camera.eyesep * ndfl;
glFrustum(left,right,bottom,top,camera.near,camera.far);
if (camera.stereo == DUALSTEREO)
glViewport(camera.screenwidth/2,0,camera.screenwidth/2,camera.screenheight);
else
glViewport(0,0,camera.screenwidth,camera.screenheight);
glMatrixMode(GL_MODELVIEW);
glDrawBuffer(GL_BACK_RIGHT);
glLoadIdentity();
gluLookAt(camera.vp.x + r.x,camera.vp.y + r.y,camera.vp.z + r.z,
camera.vp.x + r.x + camera.vd.x,
camera.vp.y + r.y + camera.vd.y,
camera.vp.z + r.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
DrawGLScene();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
left = - ratio * wd2 + 0.5 * camera.eyesep * ndfl;
right = ratio * wd2 + 0.5 * camera.eyesep * ndfl;
glFrustum(left,right,bottom,top,camera.near,camera.far);
if (camera.stereo == DUALSTEREO)
glViewport(0,0,camera.screenwidth/2,camera.screenheight);
else
glViewport(0,0,camera.screenwidth,camera.screenheight);
glMatrixMode(GL_MODELVIEW);
glDrawBuffer(GL_BACK_LEFT);
glLoadIdentity();
gluLookAt(camera.vp.x - r.x,camera.vp.y - r.y,camera.vp.z - r.z,
camera.vp.x - r.x + camera.vd.x,
camera.vp.y - r.y + camera.vd.y,
camera.vp.z - r.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
DrawGLScene();
} else { //not stereo
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glViewport(0,0,camera.screenwidth,camera.screenheight);
left = - ratio * wd2;
right = ratio * wd2;
glFrustum(left,right,bottom,top,camera.near,camera.far);
glMatrixMode(GL_MODELVIEW);
glDrawBuffer(GL_BACK_LEFT);
glLoadIdentity();
gluLookAt(camera.vp.x,camera.vp.y,camera.vp.z,
camera.vp.x + camera.vd.x,
camera.vp.y + camera.vd.y,
camera.vp.z + camera.vd.z,
camera.vu.x,camera.vu.y,camera.vu.z);
DrawGLScene();
}
/* Swap buffers */
glutSwapBuffers();
}
// called from ---GUI--- thread
NetPlayClient::NetPlayClient(const std::string& address, const u16 port, NetPlayUI* dialog, const std::string& name) : m_dialog(dialog), m_is_running(false), m_do_loop(true)
{
m_target_buffer_size = 20;
ClearBuffers();
is_connected = false;
if (m_socket.Connect(port, address, 5) == sf::Socket::Done)
{
// send connect message
sf::Packet spac;
spac << NETPLAY_VERSION;
spac << netplay_dolphin_ver;
spac << name;
m_socket.Send(spac);
sf::Packet rpac;
// TODO: make this not hang
m_socket.Receive(rpac);
MessageId error;
rpac >> error;
// got error message
if (error)
{
switch (error)
{
case CON_ERR_SERVER_FULL :
PanicAlertT("The server is full!");
break;
case CON_ERR_VERSION_MISMATCH :
PanicAlertT("The server and client's NetPlay versions are incompatible!");
break;
case CON_ERR_GAME_RUNNING :
PanicAlertT("The server responded: the game is currently running!");
break;
default :
PanicAlertT("The server sent an unknown error message!");
break;
}
m_socket.Close();
}
else
{
rpac >> m_pid;
Player player;
player.name = name;
player.pid = m_pid;
player.revision = netplay_dolphin_ver;
// add self to player list
m_players[m_pid] = player;
m_local_player = &m_players[m_pid];
m_dialog->Update();
//PanicAlertT("Connection successful: assigned player id: %d", m_pid);
is_connected = true;
m_selector.Add(m_socket);
m_thread = std::thread(std::mem_fn(&NetPlayClient::ThreadFunc), this);
}
}
COpTransFFT::~COpTransFFT()
{
ClearBuffers();
}
StreamPacketizer::~StreamPacketizer()
{
ClearBuffers();
}
