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(); }