void clsTracking2D::resetBG() { resetTracking(); /*if(paramsInt["bg"] == BG_BGCodeBookModel) { INFOMSG(("background resetted")); BgCbNrframes = 0; } else { if(paramsInt["bg"] == BG_SEG) { if(updateBgModel) { INFOMSG(("Background update is on\n")); } else { INFOMSG(("Background update is off\n")); } updateBgModel = !updateBgModel; } else { INFOMSG(("Nothing to do.")); } }*/ }
bool MidiParser::setTrack(int track) { if (track < 0 || track >= _num_tracks) return false; // We allow restarting the track via setTrack when // it isn't playing anymore. This allows us to reuse // a MidiParser when a track has finished and will // be restarted via setTrack by the client again. // This isn't exactly how setTrack behaved before though, // the old MidiParser code did not allow setTrack to be // used to restart a track, which was already finished. // // TODO: Check if any engine has problem with this // handling, if so we need to find a better way to handle // track restarts. (KYRA relies on this working) else if (track == _active_track && isPlaying()) return true; if (_smartJump) hangAllActiveNotes(); else allNotesOff(); resetTracking(); memset(_active_notes, 0, sizeof(_active_notes)); _active_track = track; _position._play_pos = _tracks[track]; parseNextEvent(_next_event); return true; }
void RobotSocket::internalInit(void) { //关闭时无需执行其他函数 myCloseFunctor = NULL; sprintf(myIPString, "none"); //清空计数器 #ifdef COUNT_DATA resetTracking(); #endif }
bool MidiParser_S1D::loadMusic(byte *data, uint32 size) { unloadMusic(); if (!size) return false; // The original actually just ignores the first two bytes. byte *pos = data; if (*pos == 0xFC) { // SysEx found right at the start // this seems to happen since Elvira 2, we ignore it // 3rd byte after the SysEx seems to be saved into a global // We expect at least 4 bytes in total if (size < 4) return false; byte skipOffset = pos[2]; // get second byte after the SysEx // pos[1] seems to have been ignored // pos[3] is saved into a global inside the original interpreters // Waxworks + Simon 1 demo typical header is: // 0xFC 0x29 0x07 0x01 [0x00/0x01] // Elvira 2 typical header is: // 0xFC 0x04 0x06 0x06 if (skipOffset >= 6) { // should be at least 6, so that we skip over the 2 size bytes and the // smallest SysEx possible skipOffset -= 2; // 2 size bytes were already read by previous code outside of this method if (size <= skipOffset) // Skip to the end of file? -> something is not correct return false; // Do skip over the bytes pos += skipOffset; } else { warning("MidiParser_S1D: unexpected skip offset in music file"); } } // And now we're at the actual data. Only one track. _numTracks = 1; _data = pos; _tracks[0] = pos; // Note that we assume the original data passed in // will persist beyond this call, i.e. we do NOT // copy the data to our own buffer. Take warning.... resetTracking(); setTempo(666667); setTrack(0); return true; }
void ArSocket::internalInit(void) { myCloseFunctor = NULL; myStringAutoEcho = true; myStringEcho = false; myStringPosLast = 0; myStringPos = 0; myStringGotComplete = false; myStringBufEmpty[0] = '\0'; myStringGotEscapeChars = false; myStringHaveEchoed = false; sprintf(myIPString, "none"); resetTracking(); }
void MidiParser::unloadMusic() { resetTracking(); allNotesOff(); _num_tracks = 0; _active_track = 255; _abort_parse = true; if (_centerPitchWheelOnUnload) { // Center the pitch wheels in preparation for the next piece of // music. It's not safe to do this from within allNotesOff(), // and might not even be safe here, so we only do it if the // client has explicitly asked for it. if (_driver) { for (int i = 0; i < 16; ++i) { sendToDriver(0xE0 | i, 0, 0x40); } } } }
bool MidiParser_RO::loadMusic (byte *data, uint32 size) { unloadMusic(); byte *pos = data; if (memcmp (pos, "RO", 2)) { error("'RO' header expected but found '%c%c' instead", pos[0], pos[1]); return false; } _num_tracks = 1; _ppqn = 120; _tracks[0] = pos + 2; _markerCount = _lastMarkerCount = 0; // Note that we assume the original data passed in // will persist beyond this call, i.e. we do NOT // copy the data to our own buffer. Take warning.... resetTracking(); setTempo (500000); setTrack (0); return true; }
void ArSocket::internalInit(void) { myReadStringMutex.setLogName("ArMutex::myReadStringMutex"); myWriteStringMutex.setLogName("ArMutex::myWriteStringMutex"); myCloseFunctor = NULL; myStringAutoEcho = true; myStringEcho = false; myStringPosLast = 0; myStringPos = 0; myStringGotComplete = false; myStringBufEmpty[0] = '\0'; myStringGotEscapeChars = false; myStringHaveEchoed = false; myLastStringReadTime.setToNow(); myLogWriteStrings = false; sprintf(myRawIPString, "none"); myIPString = ""; myBadWrite = false; myBadRead = false; myStringIgnoreReturn = false; myStringWrongEndChars = false; myErrorTracking = false; resetTracking(); }
bool MidiParser_S1D::loadMusic(byte *data, uint32 size) { unloadMusic(); byte *pos = data; if (*(pos++) != 0xFC) debug(1, "Expected 0xFC header but found 0x%02X instead", (int) *pos); // The next 3 bytes MIGHT be tempo, but we skip them and use the default. // setTempo (*(pos++) | (*(pos++) << 8) | (*(pos++) << 16)); pos += 3; // And now we're at the actual data. Only one track. _num_tracks = 1; _data = pos; _tracks[0] = pos; // Note that we assume the original data passed in // will persist beyond this call, i.e. we do NOT // copy the data to our own buffer. Take warning.... resetTracking(); setTempo(666667); setTrack(0); return true; }
bool MidiParser_SMF::loadMusic(byte *data, uint32 size) { uint32 len; byte midi_type; uint32 total_size; bool isGMF; unloadMusic(); byte *pos = data; isGMF = false; if (!memcmp(pos, "RIFF", 4)) { // Skip the outer RIFF header. pos += 8; } if (!memcmp(pos, "MThd", 4)) { // SMF with MTHd information. pos += 4; len = read4high(pos); if (len != 6) { warning("MThd length 6 expected but found %d", (int)len); return false; } // Verify that this MIDI either is a Type 2 // or has only 1 track. We do not support // multitrack Type 1 files. _num_tracks = pos[2] << 8 | pos[3]; midi_type = pos[1]; if (midi_type > 2 /*|| (midi_type < 2 && _num_tracks > 1)*/) { warning("No support for a Type %d MIDI with %d tracks", (int)midi_type, (int)_num_tracks); return false; } _ppqn = pos[4] << 8 | pos[5]; pos += len; } else if (!memcmp(pos, "GMF\x1", 4)) { // Older GMD/MUS file with no header info. // Assume 1 track, 192 PPQN, and no MTrk headers. isGMF = true; midi_type = 0; _num_tracks = 1; _ppqn = 192; pos += 7; // 'GMD\x1' + 3 bytes of useless (translate: unknown) information } else { warning("Expected MThd or GMD header but found '%c%c%c%c' instead", pos[0], pos[1], pos[2], pos[3]); return false; } // Now we identify and store the location for each track. if (_num_tracks > ARRAYSIZE(_tracks)) { warning("Can only handle %d tracks but was handed %d", (int)ARRAYSIZE(_tracks), (int)_num_tracks); return false; } total_size = 0; int tracks_read = 0; while (tracks_read < _num_tracks) { if (memcmp(pos, "MTrk", 4) && !isGMF) { warning("Position: %p ('%c')", pos, *pos); warning("Hit invalid block '%c%c%c%c' while scanning for track locations", pos[0], pos[1], pos[2], pos[3]); return false; } // If needed, skip the MTrk and length bytes _tracks[tracks_read] = pos + (isGMF ? 0 : 8); if (!isGMF) { pos += 4; len = read4high(pos); total_size += len; pos += len; } else { // An SMF End of Track meta event must be placed // at the end of the stream. data[size++] = 0xFF; data[size++] = 0x2F; data[size++] = 0x00; data[size++] = 0x00; } ++tracks_read; } // If this is a Type 1 MIDI, we need to now compress // our tracks down into a single Type 0 track. free(_buffer); _buffer = 0; if (midi_type == 1) { // FIXME: Doubled the buffer size to prevent crashes with the // Inherit the Earth MIDIs. Jamieson630 said something about a // better fix, but this will have to do in the meantime. _buffer = (byte *)malloc(size * 2); compressToType0(); _num_tracks = 1; _tracks[0] = _buffer; } // Note that we assume the original data passed in // will persist beyond this call, i.e. we do NOT // copy the data to our own buffer. Take warning.... resetTracking(); setTempo(500000); setTrack(0); return true; }
bool MidiParser::jumpToTick(uint32 tick, bool fireEvents, bool stopNotes, bool dontSendNoteOn) { if (_active_track >= _num_tracks) return false; Tracker currentPos(_position); EventInfo currentEvent(_next_event); resetTracking(); _position._play_pos = _tracks[_active_track]; parseNextEvent(_next_event); if (tick > 0) { while (true) { EventInfo &info = _next_event; if (_position._last_event_tick + info.delta >= tick) { _position._play_time += (tick - _position._last_event_tick) * _psec_per_tick; _position._play_tick = tick; break; } _position._last_event_tick += info.delta; _position._last_event_time += info.delta * _psec_per_tick; _position._play_tick = _position._last_event_tick; _position._play_time = _position._last_event_time; if (info.event == 0xFF) { if (info.ext.type == 0x2F) { // End of track _position = currentPos; _next_event = currentEvent; return false; } else { if (info.ext.type == 0x51 && info.length >= 3) // Tempo setTempo(info.ext.data[0] << 16 | info.ext.data[1] << 8 | info.ext.data[2]); if (fireEvents) _driver->metaEvent(info.ext.type, info.ext.data, (uint16) info.length); } } else if (fireEvents) { if (info.event == 0xF0) { if (info.ext.data[info.length-1] == 0xF7) _driver->sysEx(info.ext.data, (uint16)info.length-1); else _driver->sysEx(info.ext.data, (uint16)info.length); } else { // The note on sending code is used by the SCUMM engine. Other engine using this code // (such as SCI) have issues with this, as all the notes sent can be heard when a song // is fast-forwarded. Thus, if the engine requests it, don't send note on events. if (info.command() == 0x9 && dontSendNoteOn) { // Don't send note on; doing so creates a "warble" with some instruments on the MT-32. // Refer to patch #3117577 } else { sendToDriver(info.event, info.basic.param1, info.basic.param2); } } } parseNextEvent(_next_event); } } if (stopNotes) { if (!_smartJump || !currentPos._play_pos) { allNotesOff(); } else { EventInfo targetEvent(_next_event); Tracker targetPosition(_position); _position = currentPos; _next_event = currentEvent; hangAllActiveNotes(); _next_event = targetEvent; _position = targetPosition; } } _abort_parse = true; return true; }
void MidiParser::stopPlaying() { allNotesOff(); resetTracking(); }
AREXPORT ArServerClient::ArServerClient( ArSocket *tcpSocket, unsigned int udpPort, long authKey, long introKey, ArRetFunctor2<bool, ArNetPacket *, struct sockaddr_in *> *sendUdpCallback, std::map<unsigned int, ArServerData *> *dataMap, const char *passwordKey, const char *serverKey, const ArServerUserInfo *userInfo, int rejecting, const char *rejectingString, bool debugLogging, const char *serverClientName, bool logPasswordFailureVerbosely, bool allowSlowPackets, bool allowIdlePackets) : myProcessPacketCB(this, &ArServerClient::processPacket, NULL, true) { ArNetPacket packet; // set our default to no command pushCommand(0); myAuthKey = authKey; myIntroKey = introKey; myTcpSocket.transfer(tcpSocket); myTcpSocket.setCloseCallback(tcpSocket->getCloseCallback()); myTcpSocket.setNonBlock(); myTcpReceiver.setSocket(&myTcpSocket); myTcpReceiver.setProcessPacketCB(&myProcessPacketCB); myTcpSender.setSocket(&myTcpSocket); mySendUdpCB = sendUdpCallback; myDataMap = dataMap; if (udpPort == 0) myTcpOnly = true; else myTcpOnly = false; mySentTcpOnly = myTcpOnly; myUserInfo = userInfo; myPasswordKey = passwordKey; myServerKey = serverKey; myRejecting = rejecting; if (rejectingString != NULL) myRejectingString = rejectingString; myDebugLogging = debugLogging; if (myDebugLogging) myVerboseLogLevel = ArLog::Normal; else myVerboseLogLevel = ArLog::Verbose; myTcpSender.setDebugLogging(myDebugLogging); myLogPrefix = serverClientName; myLogPrefix += ": "; myTcpSender.setLoggingPrefix(myLogPrefix.c_str()); myTcpReceiver.setLoggingPrefix(myLogPrefix.c_str()); myLogPasswordFailureVerbosely = logPasswordFailureVerbosely; mySlowPacketsMutex.setLogName("ArServerClient::mySlowPacketsMutex"); myIdlePacketsMutex.setLogName("ArServerClient::myIdlePacketsMutex"); myAllowSlowPackets = allowSlowPackets; myAllowIdlePackets = allowIdlePackets; setIdentifier(ArServerClientIdentifier()); internalSwitchState(STATE_SENT_INTRO); packet.empty(); packet.setCommand(ArServerCommands::INTRODUCTION); packet.strToBuf("alpha"); packet.uByte2ToBuf(udpPort); packet.uByte4ToBuf(myAuthKey); packet.uByte4ToBuf(myIntroKey); packet.strToBuf(myPasswordKey.c_str()); sendPacketTcp(&packet); mySlowIdleThread = NULL; myHaveSlowPackets = false; myHaveIdlePackets = false; myCreationTime.setToNow(); resetTracking(); }
bool MidiParser_XMIDI::loadMusic(byte *data, uint32 size) { uint32 i = 0; byte *start; uint32 len; uint32 chunk_len; char buf[32]; _loopCount = -1; unloadMusic(); byte *pos = data; if (!memcmp(pos, "FORM", 4)) { pos += 4; // Read length of len = read4high(pos); start = pos; // XDIRless XMIDI, we can handle them here. if (!memcmp(pos, "XMID", 4)) { warning("XMIDI doesn't have XDIR"); pos += 4; _num_tracks = 1; } else if (memcmp(pos, "XDIR", 4)) { // Not an XMIDI that we recognise warning("Expected 'XDIR' but found '%c%c%c%c'", pos[0], pos[1], pos[2], pos[3]); return false; } else { // Seems Valid pos += 4; _num_tracks = 0; for (i = 4; i < len; i++) { // Read 4 bytes of type memcpy(buf, pos, 4); pos += 4; // Read length of chunk chunk_len = read4high(pos); // Add eight bytes i += 8; if (memcmp(buf, "INFO", 4)) { // Must align pos += (chunk_len + 1) & ~1; i += (chunk_len + 1) & ~1; continue; } // Must be at least 2 bytes long if (chunk_len < 2) { warning("Invalid chunk length %d for 'INFO' block", (int)chunk_len); return false; } _num_tracks = (byte)read2low(pos); if (chunk_len > 2) { warning("Chunk length %d is greater than 2", (int)chunk_len); pos += chunk_len - 2; } break; } // Didn't get to fill the header if (_num_tracks == 0) { warning("Didn't find a valid track count"); return false; } // Ok now to start part 2 // Goto the right place pos = start + ((len + 1) & ~1); if (memcmp(pos, "CAT ", 4)) { // Not an XMID warning("Expected 'CAT ' but found '%c%c%c%c'", pos[0], pos[1], pos[2], pos[3]); return false; } pos += 4; // Now read length of this track len = read4high(pos); if (memcmp(pos, "XMID", 4)) { // Not an XMID warning("Expected 'XMID' but found '%c%c%c%c'", pos[0], pos[1], pos[2], pos[3]); return false; } pos += 4; } // Ok it's an XMIDI. // We're going to identify and store the location for each track. if (_num_tracks > ARRAYSIZE(_tracks)) { warning("Can only handle %d tracks but was handed %d", (int)ARRAYSIZE(_tracks), (int)_num_tracks); return false; } int tracks_read = 0; while (tracks_read < _num_tracks) { if (!memcmp(pos, "FORM", 4)) { // Skip this plus the 4 bytes after it. pos += 8; } else if (!memcmp(pos, "XMID", 4)) { // Skip this. pos += 4; } else if (!memcmp(pos, "TIMB", 4)) { // Custom timbres? // We don't support them. // Read the length, skip it, and hope there was nothing there. pos += 4; len = read4high(pos); pos += (len + 1) & ~1; } else if (!memcmp(pos, "EVNT", 4)) { // Ahh! What we're looking for at last. _tracks[tracks_read] = pos + 8; // Skip the EVNT and length bytes pos += 4; len = read4high(pos); pos += (len + 1) & ~1; ++tracks_read; } else { warning("Hit invalid block '%c%c%c%c' while scanning for track locations", pos[0], pos[1], pos[2], pos[3]); return false; } } // If we got this far, we successfully established // the locations for each of our tracks. // Note that we assume the original data passed in // will persist beyond this call, i.e. we do NOT // copy the data to our own buffer. Take warning.... _ppqn = 60; resetTracking(); setTempo(500000); _inserted_delta = 0; setTrack(0); return true; } return false; }
bool MidiParser::jumpToTick(uint32 tick, bool fireEvents) { if (_active_track >= _num_tracks) return false; Tracker currentPos(_position); EventInfo currentEvent(_next_event); resetTracking(); _position._play_pos = _tracks[_active_track]; parseNextEvent(_next_event); if (tick > 0) { while (true) { EventInfo &info = _next_event; if (_position._last_event_tick + info.delta >= tick) { _position._play_time += (tick - _position._last_event_tick) * _psec_per_tick; _position._play_tick = tick; break; } _position._last_event_tick += info.delta; _position._last_event_time += info.delta * _psec_per_tick; _position._play_tick = _position._last_event_tick; _position._play_time = _position._last_event_time; if (info.event == 0xFF) { if (info.ext.type == 0x2F) { // End of track _position = currentPos; _next_event = currentEvent; return false; } else { if (info.ext.type == 0x51 && info.length >= 3) // Tempo setTempo(info.ext.data[0] << 16 | info.ext.data[1] << 8 | info.ext.data[2]); if (fireEvents) _driver->metaEvent(info.ext.type, info.ext.data, (uint16) info.length); } } else if (fireEvents) { if (info.event == 0xF0) { if (info.ext.data[info.length-1] == 0xF7) _driver->sysEx(info.ext.data, (uint16)info.length-1); else _driver->sysEx(info.ext.data, (uint16)info.length); } else _driver->send(info.event, info.basic.param1, info.basic.param2); } parseNextEvent(_next_event); } } if (!_smartJump || !currentPos._play_pos) { allNotesOff(); } else { EventInfo targetEvent(_next_event); Tracker targetPosition(_position); _position = currentPos; _next_event = currentEvent; hangAllActiveNotes(); _next_event = targetEvent; _position = targetPosition; } _abort_parse = true; return true; }
void MainWindow::startClock() { isTracking = true; setTrayIconTrackingMode(); resetTracking(); }