Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "private", "static", "int", "findTrackIdAtOffset", "(", "SlotReference", "slot", ",", "Client", "client", ",", "int", "offset", ")", "throws", "IOException", "{", "Message", "entry", "=", "client", ".", "renderMenuItems", "(", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slot", ".", "slot", ",", "CdjStatus", ".", "TrackType", ".", "REKORDBOX", ",", "offset", ",", "1", ")", ".", "get", "(", "0", ")", ";", "if", "(", "entry", ".", "getMenuItemType", "(", ")", "==", "Message", ".", "MenuItemType", ".", "UNKNOWN", ")", "{", "logger", ".", "warn", "(", "\"Encountered unrecognized track list entry item type: {}\"", ",", "entry", ")", ";", "}", "return", "(", "int", ")", "(", "(", "NumberField", ")", "entry", ".", "arguments", ".", "get", "(", "1", ")", ")", ".", "getValue", "(", ")", ";", "}" ]

[ "As", "part", "of", "checking", "whether", "a", "metadata", "cache", "can", "be", "auto", "-", "mounted", "for", "a", "particular", "media", "slot", "this", "method", "looks", "up", "the", "track", "at", "the", "specified", "offset", "within", "the", "player", "s", "track", "list", "and", "returns", "its", "rekordbox", "ID", "." ]

[ "private", "boolean", "isPacketLongEnough", "(", "DatagramPacket", "packet", ",", "int", "expectedLength", ",", "String", "name", ")", "{", "final", "int", "length", "=", "packet", ".", "getLength", "(", ")", ";", "if", "(", "length", "<", "expectedLength", ")", "{", "logger", ".", "warn", "(", "\"Ignoring too-short \"", "+", "name", "+", "\" packet; expecting \"", "+", "expectedLength", "+", "\" bytes and got \"", "+", "length", "+", "\".\"", ")", ";", "return", "false", ";", "}", "if", "(", "length", ">", "expectedLength", ")", "{", "logger", ".", "warn", "(", "\"Processing too-long \"", "+", "name", "+", "\" packet; expecting \"", "+", "expectedLength", "+", "\" bytes and got \"", "+", "length", "+", "\".\"", ")", ";", "}", "return", "true", ";", "}" ]

[ "Helper", "method", "to", "check", "that", "we", "got", "the", "right", "size", "packet", "." ]

[ "public", "synchronized", "void", "stop", "(", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "socket", ".", "get", "(", ")", ".", "close", "(", ")", ";", "socket", ".", "set", "(", "null", ")", ";", "deliverLifecycleAnnouncement", "(", "logger", ",", "false", ")", ";", "}", "}" ]

[ "Stop", "listening", "for", "beats", "." ]

[ "private", "void", "deliverSyncCommand", "(", "byte", "command", ")", "{", "for", "(", "final", "SyncListener", "listener", ":", "getSyncListeners", "(", ")", ")", "{", "try", "{", "switch", "(", "command", ")", "{", "case", "0x01", ":", "listener", ".", "becomeMaster", "(", ")", ";", "case", "0x10", ":", "listener", ".", "setSyncMode", "(", "true", ")", ";", "break", ";", "case", "0x20", ":", "listener", ".", "setSyncMode", "(", "false", ")", ";", "break", ";", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering sync command to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "sync", "command", "to", "all", "registered", "listeners", "." ]

[ "private", "void", "deliverMasterYieldCommand", "(", "int", "toPlayer", ")", "{", "for", "(", "final", "MasterHandoffListener", "listener", ":", "getMasterHandoffListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "yieldMasterTo", "(", "toPlayer", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering master yield command to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "master", "handoff", "yield", "command", "to", "all", "registered", "listeners", "." ]

[ "private", "void", "deliverMasterYieldResponse", "(", "int", "fromPlayer", ",", "boolean", "yielded", ")", "{", "for", "(", "final", "MasterHandoffListener", "listener", ":", "getMasterHandoffListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "yieldResponse", "(", "fromPlayer", ",", "yielded", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering master yield response to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "master", "handoff", "yield", "response", "to", "all", "registered", "listeners", "." ]

[ "private", "void", "deliverOnAirUpdate", "(", "Set", "<", "Integer", ">", "audibleChannels", ")", "{", "for", "(", "final", "OnAirListener", "listener", ":", "getOnAirListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "channelsOnAir", "(", "audibleChannels", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering channels on-air update to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "channels", "on", "-", "air", "update", "to", "all", "registered", "listeners", "." ]

[ "private", "void", "deliverFaderStartCommand", "(", "Set", "<", "Integer", ">", "playersToStart", ",", "Set", "<", "Integer", ">", "playersToStop", ")", "{", "for", "(", "final", "FaderStartListener", "listener", ":", "getFaderStartListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "fadersChanged", "(", "playersToStart", ",", "playersToStop", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering fader start command to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "fader", "start", "command", "to", "all", "registered", "listeners", "." ]

[ "public", "void", "write", "(", "WritableByteChannel", "channel", ")", "throws", "IOException", "{", "logger", ".", "debug", "(", "\"Writing> {}\"", ",", "this", ")", ";", "for", "(", "Field", "field", ":", "fields", ")", "{", "field", ".", "write", "(", "channel", ")", ";", "}", "}" ]

[ "Writes", "the", "message", "to", "the", "specified", "channel", "for", "example", "when", "creating", "metadata", "cache", "files", "." ]

[ "public", "final", "void", "setFindDetails", "(", "boolean", "findDetails", ")", "{", "this", ".", "findDetails", ".", "set", "(", "findDetails", ")", ";", "if", "(", "findDetails", ")", "{", "primeCache", "(", ")", ";", "// Get details for any tracks that were already loaded on players.", "}", "else", "{", "// Inform our listeners, on the proper thread, that the detailed waveforms are no longer available", "final", "Set", "<", "DeckReference", ">", "dyingCache", "=", "new", "HashSet", "<", "DeckReference", ">", "(", "detailHotCache", ".", "keySet", "(", ")", ")", ";", "detailHotCache", ".", "clear", "(", ")", ";", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "for", "(", "DeckReference", "deck", ":", "dyingCache", ")", "{", "deliverWaveformDetailUpdate", "(", "deck", ".", "player", ",", "null", ")", ";", "}", "}", "}", ")", ";", "}", "}" ]

[ "Set", "whether", "we", "should", "retrieve", "the", "waveform", "details", "in", "addition", "to", "the", "waveform", "previews", "." ]

[ "public", "final", "void", "setColorPreferred", "(", "boolean", "preferColor", ")", "{", "if", "(", "this", ".", "preferColor", ".", "compareAndSet", "(", "!", "preferColor", ",", "preferColor", ")", "&&", "isRunning", "(", ")", ")", "{", "stop", "(", ")", ";", "try", "{", "start", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "error", "(", "\"Unexplained exception restarting; we had been running already!\"", ",", "e", ")", ";", "}", "}", "}" ]

[ "Set", "whether", "we", "should", "obtain", "color", "versions", "of", "waveforms", "and", "previews", "when", "they", "are", "available", ".", "This", "will", "only", "affect", "waveforms", "loaded", "after", "the", "setting", "has", "been", "changed", ".", "If", "this", "changes", "the", "setting", "and", "we", "were", "running", "stop", "and", "restart", "in", "order", "to", "flush", "and", "reload", "the", "correct", "waveform", "versions", "." ]

[ "private", "void", "clearDeckPreview", "(", "TrackMetadataUpdate", "update", ")", "{", "if", "(", "previewHotCache", ".", "remove", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "0", ")", ")", "!=", "null", ")", "{", "deliverWaveformPreviewUpdate", "(", "update", ".", "player", ",", "null", ")", ";", "}", "}" ]

[ "We", "have", "received", "an", "update", "that", "invalidates", "the", "waveform", "preview", "for", "a", "player", "so", "clear", "it", "and", "alert", "any", "listeners", "if", "this", "represents", "a", "change", ".", "This", "does", "not", "affect", "the", "hot", "cues", ";", "they", "will", "stick", "around", "until", "the", "player", "loads", "a", "new", "track", "that", "overwrites", "one", "or", "more", "of", "them", "." ]

[ "private", "void", "clearDeckDetail", "(", "TrackMetadataUpdate", "update", ")", "{", "if", "(", "detailHotCache", ".", "remove", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "0", ")", ")", "!=", "null", ")", "{", "deliverWaveformDetailUpdate", "(", "update", ".", "player", ",", "null", ")", ";", "}", "}" ]

[ "We", "have", "received", "an", "update", "that", "invalidates", "the", "waveform", "detail", "for", "a", "player", "so", "clear", "it", "and", "alert", "any", "listeners", "if", "this", "represents", "a", "change", ".", "This", "does", "not", "affect", "the", "hot", "cues", ";", "they", "will", "stick", "around", "until", "the", "player", "loads", "a", "new", "track", "that", "overwrites", "one", "or", "more", "of", "them", "." ]

[ "private", "void", "clearWaveforms", "(", "DeviceAnnouncement", "announcement", ")", "{", "final", "int", "player", "=", "announcement", ".", "getNumber", "(", ")", ";", "// Iterate over a copy to avoid concurrent modification issues", "for", "(", "DeckReference", "deck", ":", "new", "HashSet", "<", "DeckReference", ">", "(", "previewHotCache", ".", "keySet", "(", ")", ")", ")", "{", "if", "(", "deck", ".", "player", "==", "player", ")", "{", "previewHotCache", ".", "remove", "(", "deck", ")", ";", "if", "(", "deck", ".", "hotCue", "==", "0", ")", "{", "deliverWaveformPreviewUpdate", "(", "player", ",", "null", ")", ";", "// Inform listeners that preview is gone.", "}", "}", "}", "// Again iterate over a copy to avoid concurrent modification issues", "for", "(", "DeckReference", "deck", ":", "new", "HashSet", "<", "DeckReference", ">", "(", "detailHotCache", ".", "keySet", "(", ")", ")", ")", "{", "if", "(", "deck", ".", "player", "==", "player", ")", "{", "detailHotCache", ".", "remove", "(", "deck", ")", ";", "if", "(", "deck", ".", "hotCue", "==", "0", ")", "{", "deliverWaveformDetailUpdate", "(", "player", ",", "null", ")", ";", "// Inform listeners that detail is gone.", "}", "}", "}", "}" ]

[ "We", "have", "received", "notification", "that", "a", "device", "is", "no", "longer", "on", "the", "network", "so", "clear", "out", "all", "its", "waveforms", "." ]

[ "private", "void", "updatePreview", "(", "TrackMetadataUpdate", "update", ",", "WaveformPreview", "preview", ")", "{", "previewHotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "0", ")", ",", "preview", ")", ";", "// Main deck", "if", "(", "update", ".", "metadata", ".", "getCueList", "(", ")", "!=", "null", ")", "{", "// Update the cache with any hot cues in this track as well", "for", "(", "CueList", ".", "Entry", "entry", ":", "update", ".", "metadata", ".", "getCueList", "(", ")", ".", "entries", ")", "{", "if", "(", "entry", ".", "hotCueNumber", "!=", "0", ")", "{", "previewHotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "entry", ".", "hotCueNumber", ")", ",", "preview", ")", ";", "}", "}", "}", "deliverWaveformPreviewUpdate", "(", "update", ".", "player", ",", "preview", ")", ";", "}" ]

[ "We", "have", "obtained", "a", "waveform", "preview", "for", "a", "device", "so", "store", "it", "and", "alert", "any", "listeners", "." ]

[ "private", "void", "updateDetail", "(", "TrackMetadataUpdate", "update", ",", "WaveformDetail", "detail", ")", "{", "detailHotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "0", ")", ",", "detail", ")", ";", "// Main deck", "if", "(", "update", ".", "metadata", ".", "getCueList", "(", ")", "!=", "null", ")", "{", "// Update the cache with any hot cues in this track as well", "for", "(", "CueList", ".", "Entry", "entry", ":", "update", ".", "metadata", ".", "getCueList", "(", ")", ".", "entries", ")", "{", "if", "(", "entry", ".", "hotCueNumber", "!=", "0", ")", "{", "detailHotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "entry", ".", "hotCueNumber", ")", ",", "detail", ")", ";", "}", "}", "}", "deliverWaveformDetailUpdate", "(", "update", ".", "player", ",", "detail", ")", ";", "}" ]

[ "We", "have", "obtained", "waveform", "detail", "for", "a", "device", "so", "store", "it", "and", "alert", "any", "listeners", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "Map", "<", "DeckReference", ",", "WaveformPreview", ">", "getLoadedPreviews", "(", ")", "{", "ensureRunning", "(", ")", ";", "// Make a copy so callers get an immutable snapshot of the current state.", "return", "Collections", ".", "unmodifiableMap", "(", "new", "HashMap", "<", "DeckReference", ",", "WaveformPreview", ">", "(", "previewHotCache", ")", ")", ";", "}" ]

[ "Get", "the", "waveform", "previews", "available", "for", "all", "tracks", "currently", "loaded", "in", "any", "player", "either", "on", "the", "play", "deck", "or", "in", "a", "hot", "cue", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "Map", "<", "DeckReference", ",", "WaveformDetail", ">", "getLoadedDetails", "(", ")", "{", "ensureRunning", "(", ")", ";", "if", "(", "!", "isFindingDetails", "(", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"WaveformFinder is not configured to find waveform details.\"", ")", ";", "}", "// Make a copy so callers get an immutable snapshot of the current state.", "return", "Collections", ".", "unmodifiableMap", "(", "new", "HashMap", "<", "DeckReference", ",", "WaveformDetail", ">", "(", "detailHotCache", ")", ")", ";", "}" ]

[ "Get", "the", "waveform", "details", "available", "for", "all", "tracks", "currently", "loaded", "in", "any", "player", "either", "on", "the", "play", "deck", "or", "in", "a", "hot", "cue", "." ]

[ "private", "WaveformPreview", "requestPreviewInternal", "(", "final", "DataReference", "trackReference", ",", "final", "boolean", "failIfPassive", ")", "{", "// First check if we are using cached data for this slot", "MetadataCache", "cache", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getMetadataCache", "(", "SlotReference", ".", "getSlotReference", "(", "trackReference", ")", ")", ";", "if", "(", "cache", "!=", "null", ")", "{", "return", "cache", ".", "getWaveformPreview", "(", "null", ",", "trackReference", ")", ";", "}", "// Then see if any registered metadata providers can offer it for us.", "final", "MediaDetails", "sourceDetails", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getMediaDetailsFor", "(", "trackReference", ".", "getSlotReference", "(", ")", ")", ";", "if", "(", "sourceDetails", "!=", "null", ")", "{", "final", "WaveformPreview", "provided", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "allMetadataProviders", ".", "getWaveformPreview", "(", "sourceDetails", ",", "trackReference", ")", ";", "if", "(", "provided", "!=", "null", ")", "{", "return", "provided", ";", "}", "}", "// At this point, unless we are allowed to actively request the data, we are done. We can always actively", "// request tracks from rekordbox.", "if", "(", "MetadataFinder", ".", "getInstance", "(", ")", ".", "isPassive", "(", ")", "&&", "failIfPassive", "&&", "trackReference", ".", "slot", "!=", "CdjStatus", ".", "TrackSourceSlot", ".", "COLLECTION", ")", "{", "return", "null", ";", "}", "// We have to actually request the preview using the dbserver protocol.", "ConnectionManager", ".", "ClientTask", "<", "WaveformPreview", ">", "task", "=", "new", "ConnectionManager", ".", "ClientTask", "<", "WaveformPreview", ">", "(", ")", "{", "@", "Override", "public", "WaveformPreview", "useClient", "(", "Client", "client", ")", "throws", "Exception", "{", "return", "getWaveformPreview", "(", "trackReference", ".", "rekordboxId", ",", "SlotReference", ".", "getSlotReference", "(", "trackReference", ")", ",", "client", ")", ";", "}", "}", ";", "try", "{", "return", "ConnectionManager", ".", "getInstance", "(", ")", ".", "invokeWithClientSession", "(", "trackReference", ".", "player", ",", "task", ",", "\"requesting waveform preview\"", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "error", "(", "\"Problem requesting waveform preview, returning null\"", ",", "e", ")", ";", "}", "return", "null", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "the", "waveform", "preview", "in", "the", "specified", "slot", "with", "the", "specified", "rekordbox", "ID", "using", "cached", "media", "instead", "if", "it", "is", "available", "and", "possibly", "giving", "up", "if", "we", "are", "in", "passive", "mode", "." ]

[ "public", "WaveformPreview", "requestWaveformPreviewFrom", "(", "final", "DataReference", "dataReference", ")", "{", "ensureRunning", "(", ")", ";", "for", "(", "WaveformPreview", "cached", ":", "previewHotCache", ".", "values", "(", ")", ")", "{", "if", "(", "cached", ".", "dataReference", ".", "equals", "(", "dataReference", ")", ")", "{", "// Found a hot cue hit, use it.", "return", "cached", ";", "}", "}", "return", "requestPreviewInternal", "(", "dataReference", ",", "false", ")", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "the", "specified", "waveform", "preview", "from", "the", "specified", "media", "slot", "first", "checking", "if", "we", "have", "a", "cached", "copy", "." ]

[ "WaveformPreview", "getWaveformPreview", "(", "int", "rekordboxId", ",", "SlotReference", "slot", ",", "Client", "client", ")", "throws", "IOException", "{", "final", "NumberField", "idField", "=", "new", "NumberField", "(", "rekordboxId", ")", ";", "// First try to get the NXS2-style color waveform if we are supposed to.", "if", "(", "preferColor", ".", "get", "(", ")", ")", "{", "try", "{", "Message", "response", "=", "client", ".", "simpleRequest", "(", "Message", ".", "KnownType", ".", "ANLZ_TAG_REQ", ",", "Message", ".", "KnownType", ".", "ANLZ_TAG", ",", "client", ".", "buildRMST", "(", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slot", ".", "slot", ")", ",", "idField", ",", "new", "NumberField", "(", "Message", ".", "ANLZ_FILE_TAG_COLOR_WAVEFORM_PREVIEW", ")", ",", "new", "NumberField", "(", "Message", ".", "ALNZ_FILE_TYPE_EXT", ")", ")", ";", "return", "new", "WaveformPreview", "(", "new", "DataReference", "(", "slot", ",", "rekordboxId", ")", ",", "response", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "info", "(", "\"No color waveform preview available for slot \"", "+", "slot", "+", "\", id \"", "+", "rekordboxId", "+", "\"; requesting blue version.\"", ",", "e", ")", ";", "}", "}", "Message", "response", "=", "client", ".", "simpleRequest", "(", "Message", ".", "KnownType", ".", "WAVE_PREVIEW_REQ", ",", "Message", ".", "KnownType", ".", "WAVE_PREVIEW", ",", "client", ".", "buildRMST", "(", "Message", ".", "MenuIdentifier", ".", "DATA", ",", "slot", ".", "slot", ")", ",", "NumberField", ".", "WORD_1", ",", "idField", ",", "NumberField", ".", "WORD_0", ")", ";", "return", "new", "WaveformPreview", "(", "new", "DataReference", "(", "slot", ",", "rekordboxId", ")", ",", "response", ")", ";", "}" ]

[ "Requests", "the", "waveform", "preview", "for", "a", "specific", "track", "ID", "given", "a", "connection", "to", "a", "player", "that", "has", "already", "been", "set", "up", "." ]

[ "public", "WaveformDetail", "requestWaveformDetailFrom", "(", "final", "DataReference", "dataReference", ")", "{", "ensureRunning", "(", ")", ";", "for", "(", "WaveformDetail", "cached", ":", "detailHotCache", ".", "values", "(", ")", ")", "{", "if", "(", "cached", ".", "dataReference", ".", "equals", "(", "dataReference", ")", ")", "{", "// Found a hot cue hit, use it.", "return", "cached", ";", "}", "}", "return", "requestDetailInternal", "(", "dataReference", ",", "false", ")", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "the", "specified", "waveform", "detail", "from", "the", "specified", "media", "slot", "first", "checking", "if", "we", "have", "a", "cached", "copy", "." ]

[ "WaveformDetail", "getWaveformDetail", "(", "int", "rekordboxId", ",", "SlotReference", "slot", ",", "Client", "client", ")", "throws", "IOException", "{", "final", "NumberField", "idField", "=", "new", "NumberField", "(", "rekordboxId", ")", ";", "// First try to get the NXS2-style color waveform if we are supposed to.", "if", "(", "preferColor", ".", "get", "(", ")", ")", "{", "try", "{", "Message", "response", "=", "client", ".", "simpleRequest", "(", "Message", ".", "KnownType", ".", "ANLZ_TAG_REQ", ",", "Message", ".", "KnownType", ".", "ANLZ_TAG", ",", "client", ".", "buildRMST", "(", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slot", ".", "slot", ")", ",", "idField", ",", "new", "NumberField", "(", "Message", ".", "ANLZ_FILE_TAG_COLOR_WAVEFORM_DETAIL", ")", ",", "new", "NumberField", "(", "Message", ".", "ALNZ_FILE_TYPE_EXT", ")", ")", ";", "return", "new", "WaveformDetail", "(", "new", "DataReference", "(", "slot", ",", "rekordboxId", ")", ",", "response", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "info", "(", "\"No color waveform available for slot \"", "+", "slot", "+", "\", id \"", "+", "rekordboxId", "+", "\"; requesting blue version.\"", ",", "e", ")", ";", "}", "}", "Message", "response", "=", "client", ".", "simpleRequest", "(", "Message", ".", "KnownType", ".", "WAVE_DETAIL_REQ", ",", "Message", ".", "KnownType", ".", "WAVE_DETAIL", ",", "client", ".", "buildRMST", "(", "Message", ".", "MenuIdentifier", ".", "MAIN_MENU", ",", "slot", ".", "slot", ")", ",", "idField", ",", "NumberField", ".", "WORD_0", ")", ";", "return", "new", "WaveformDetail", "(", "new", "DataReference", "(", "slot", ",", "rekordboxId", ")", ",", "response", ")", ";", "}" ]

[ "Requests", "the", "waveform", "detail", "for", "a", "specific", "track", "ID", "given", "a", "connection", "to", "a", "player", "that", "has", "already", "been", "set", "up", "." ]

[ "private", "void", "deliverWaveformPreviewUpdate", "(", "final", "int", "player", ",", "final", "WaveformPreview", "preview", ")", "{", "final", "Set", "<", "WaveformListener", ">", "listeners", "=", "getWaveformListeners", "(", ")", ";", "if", "(", "!", "listeners", ".", "isEmpty", "(", ")", ")", "{", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "final", "WaveformPreviewUpdate", "update", "=", "new", "WaveformPreviewUpdate", "(", "player", ",", "preview", ")", ";", "for", "(", "final", "WaveformListener", "listener", ":", "listeners", ")", "{", "try", "{", "listener", ".", "previewChanged", "(", "update", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering waveform preview update to listener\"", ",", "t", ")", ";", "}", "}", "}", "}", ")", ";", "}", "}" ]

[ "Send", "a", "waveform", "preview", "update", "announcement", "to", "all", "registered", "listeners", "." ]

[ "private", "void", "deliverWaveformDetailUpdate", "(", "final", "int", "player", ",", "final", "WaveformDetail", "detail", ")", "{", "if", "(", "!", "getWaveformListeners", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "final", "WaveformDetailUpdate", "update", "=", "new", "WaveformDetailUpdate", "(", "player", ",", "detail", ")", ";", "for", "(", "final", "WaveformListener", "listener", ":", "getWaveformListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "detailChanged", "(", "update", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering waveform detail update to listener\"", ",", "t", ")", ";", "}", "}", "}", "}", ")", ";", "}", "}" ]

[ "Send", "a", "waveform", "detail", "update", "announcement", "to", "all", "registered", "listeners", "." ]

[ "private", "void", "primeCache", "(", ")", "{", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "for", "(", "Map", ".", "Entry", "<", "DeckReference", ",", "TrackMetadata", ">", "entry", ":", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getLoadedTracks", "(", ")", ".", "entrySet", "(", ")", ")", "{", "if", "(", "entry", ".", "getKey", "(", ")", ".", "hotCue", "==", "0", ")", "{", "// The track is currently loaded in a main player deck", "handleUpdate", "(", "new", "TrackMetadataUpdate", "(", "entry", ".", "getKey", "(", ")", ".", "player", ",", "entry", ".", "getValue", "(", ")", ")", ")", ";", "}", "}", "}", "}", ")", ";", "}" ]

[ "Send", "ourselves", "updates", "about", "any", "tracks", "that", "were", "loaded", "before", "we", "started", "or", "before", "we", "were", "requesting", "details", "since", "we", "missed", "them", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "synchronized", "void", "stop", "(", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "MetadataFinder", ".", "getInstance", "(", ")", ".", "removeTrackMetadataListener", "(", "metadataListener", ")", ";", "running", ".", "set", "(", "false", ")", ";", "pendingUpdates", ".", "clear", "(", ")", ";", "queueHandler", ".", "interrupt", "(", ")", ";", "queueHandler", "=", "null", ";", "// Report the loss of our waveforms, on the proper thread, outside our lock", "final", "Set", "<", "DeckReference", ">", "dyingPreviewCache", "=", "new", "HashSet", "<", "DeckReference", ">", "(", "previewHotCache", ".", "keySet", "(", ")", ")", ";", "previewHotCache", ".", "clear", "(", ")", ";", "final", "Set", "<", "DeckReference", ">", "dyingDetailCache", "=", "new", "HashSet", "<", "DeckReference", ">", "(", "detailHotCache", ".", "keySet", "(", ")", ")", ";", "detailHotCache", ".", "clear", "(", ")", ";", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "for", "(", "DeckReference", "deck", ":", "dyingPreviewCache", ")", "{", "// Report the loss of our previews.", "if", "(", "deck", ".", "hotCue", "==", "0", ")", "{", "deliverWaveformPreviewUpdate", "(", "deck", ".", "player", ",", "null", ")", ";", "}", "}", "for", "(", "DeckReference", "deck", ":", "dyingDetailCache", ")", "{", "// Report the loss of our details.", "if", "(", "deck", ".", "hotCue", "==", "0", ")", "{", "deliverWaveformDetailUpdate", "(", "deck", ".", "player", ",", "null", ")", ";", "}", "}", "}", "}", ")", ";", "deliverLifecycleAnnouncement", "(", "logger", ",", "false", ")", ";", "}", "}" ]

[ "Stop", "finding", "waveforms", "for", "all", "active", "players", "." ]

[ "private", "void", "clearArt", "(", "DeviceAnnouncement", "announcement", ")", "{", "final", "int", "player", "=", "announcement", ".", "getNumber", "(", ")", ";", "// Iterate over a copy to avoid concurrent modification issues", "for", "(", "DeckReference", "deck", ":", "new", "HashSet", "<", "DeckReference", ">", "(", "hotCache", ".", "keySet", "(", ")", ")", ")", "{", "if", "(", "deck", ".", "player", "==", "player", ")", "{", "hotCache", ".", "remove", "(", "deck", ")", ";", "if", "(", "deck", ".", "hotCue", "==", "0", ")", "{", "deliverAlbumArtUpdate", "(", "player", ",", "null", ")", ";", "// Inform listeners that the artwork is gone.", "}", "}", "}", "// Again iterate over a copy to avoid concurrent modification issues", "for", "(", "DataReference", "art", ":", "new", "HashSet", "<", "DataReference", ">", "(", "artCache", ".", "keySet", "(", ")", ")", ")", "{", "if", "(", "art", ".", "player", "==", "player", ")", "{", "artCache", ".", "remove", "(", "art", ")", ";", "}", "}", "}" ]

[ "We", "have", "received", "notification", "that", "a", "device", "is", "no", "longer", "on", "the", "network", "so", "clear", "out", "its", "artwork", "." ]

[ "private", "void", "updateArt", "(", "TrackMetadataUpdate", "update", ",", "AlbumArt", "art", ")", "{", "hotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "0", ")", ",", "art", ")", ";", "// Main deck", "if", "(", "update", ".", "metadata", ".", "getCueList", "(", ")", "!=", "null", ")", "{", "// Update the cache with any hot cues in this track as well", "for", "(", "CueList", ".", "Entry", "entry", ":", "update", ".", "metadata", ".", "getCueList", "(", ")", ".", "entries", ")", "{", "if", "(", "entry", ".", "hotCueNumber", "!=", "0", ")", "{", "hotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "entry", ".", "hotCueNumber", ")", ",", "art", ")", ";", "}", "}", "}", "deliverAlbumArtUpdate", "(", "update", ".", "player", ",", "art", ")", ";", "}" ]

[ "We", "have", "obtained", "album", "art", "for", "a", "device", "so", "store", "it", "and", "alert", "any", "listeners", "." ]

[ "public", "Map", "<", "DeckReference", ",", "AlbumArt", ">", "getLoadedArt", "(", ")", "{", "ensureRunning", "(", ")", ";", "// Make a copy so callers get an immutable snapshot of the current state.", "return", "Collections", ".", "unmodifiableMap", "(", "new", "HashMap", "<", "DeckReference", ",", "AlbumArt", ">", "(", "hotCache", ")", ")", ";", "}" ]

[ "Get", "the", "art", "available", "for", "all", "tracks", "currently", "loaded", "in", "any", "player", "either", "on", "the", "play", "deck", "or", "in", "a", "hot", "cue", "." ]

[ "private", "AlbumArt", "requestArtworkInternal", "(", "final", "DataReference", "artReference", ",", "final", "CdjStatus", ".", "TrackType", "trackType", ",", "final", "boolean", "failIfPassive", ")", "{", "// First check if we are using cached data for this slot.", "MetadataCache", "cache", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getMetadataCache", "(", "SlotReference", ".", "getSlotReference", "(", "artReference", ")", ")", ";", "if", "(", "cache", "!=", "null", ")", "{", "final", "AlbumArt", "result", "=", "cache", ".", "getAlbumArt", "(", "null", ",", "artReference", ")", ";", "if", "(", "result", "!=", "null", ")", "{", "artCache", ".", "put", "(", "artReference", ",", "result", ")", ";", "}", "return", "result", ";", "}", "// Then see if any registered metadata providers can offer it for us.", "final", "MediaDetails", "sourceDetails", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getMediaDetailsFor", "(", "artReference", ".", "getSlotReference", "(", ")", ")", ";", "if", "(", "sourceDetails", "!=", "null", ")", "{", "final", "AlbumArt", "provided", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "allMetadataProviders", ".", "getAlbumArt", "(", "sourceDetails", ",", "artReference", ")", ";", "if", "(", "provided", "!=", "null", ")", "{", "return", "provided", ";", "}", "}", "// At this point, unless we are allowed to actively request the data, we are done. We can always actively", "// request tracks from rekordbox.", "if", "(", "MetadataFinder", ".", "getInstance", "(", ")", ".", "isPassive", "(", ")", "&&", "failIfPassive", "&&", "artReference", ".", "slot", "!=", "CdjStatus", ".", "TrackSourceSlot", ".", "COLLECTION", ")", "{", "return", "null", ";", "}", "// We have to actually request the art using the dbserver protocol.", "ConnectionManager", ".", "ClientTask", "<", "AlbumArt", ">", "task", "=", "new", "ConnectionManager", ".", "ClientTask", "<", "AlbumArt", ">", "(", ")", "{", "@", "Override", "public", "AlbumArt", "useClient", "(", "Client", "client", ")", "throws", "Exception", "{", "return", "getArtwork", "(", "artReference", ".", "rekordboxId", ",", "SlotReference", ".", "getSlotReference", "(", "artReference", ")", ",", "trackType", ",", "client", ")", ";", "}", "}", ";", "try", "{", "AlbumArt", "artwork", "=", "ConnectionManager", ".", "getInstance", "(", ")", ".", "invokeWithClientSession", "(", "artReference", ".", "player", ",", "task", ",", "\"requesting artwork\"", ")", ";", "if", "(", "artwork", "!=", "null", ")", "{", "// Our cache file load or network request succeeded, so add to the level 2 cache.", "artCache", ".", "put", "(", "artReference", ",", "artwork", ")", ";", "}", "return", "artwork", ";", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "error", "(", "\"Problem requesting album art, returning null\"", ",", "e", ")", ";", "}", "return", "null", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "the", "album", "art", "in", "the", "specified", "slot", "with", "the", "specified", "rekordbox", "ID", "using", "cached", "media", "instead", "if", "it", "is", "available", "and", "possibly", "giving", "up", "if", "we", "are", "in", "passive", "mode", "." ]

[ "public", "AlbumArt", "requestArtworkFrom", "(", "final", "DataReference", "artReference", ",", "final", "CdjStatus", ".", "TrackType", "trackType", ")", "{", "ensureRunning", "(", ")", ";", "AlbumArt", "artwork", "=", "findArtInMemoryCaches", "(", "artReference", ")", ";", "// First check the in-memory artwork caches.", "if", "(", "artwork", "==", "null", ")", "{", "artwork", "=", "requestArtworkInternal", "(", "artReference", ",", "trackType", ",", "false", ")", ";", "}", "return", "artwork", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "the", "specified", "artwork", "from", "the", "specified", "media", "slot", "first", "checking", "if", "we", "have", "a", "cached", "copy", "." ]

[ "AlbumArt", "getArtwork", "(", "int", "artworkId", ",", "SlotReference", "slot", ",", "CdjStatus", ".", "TrackType", "trackType", ",", "Client", "client", ")", "throws", "IOException", "{", "// Send the artwork request", "Message", "response", "=", "client", ".", "simpleRequest", "(", "Message", ".", "KnownType", ".", "ALBUM_ART_REQ", ",", "Message", ".", "KnownType", ".", "ALBUM_ART", ",", "client", ".", "buildRMST", "(", "Message", ".", "MenuIdentifier", ".", "DATA", ",", "slot", ".", "slot", ",", "trackType", ")", ",", "new", "NumberField", "(", "(", "long", ")", "artworkId", ")", ")", ";", "// Create an image from the response bytes", "return", "new", "AlbumArt", "(", "new", "DataReference", "(", "slot", ",", "artworkId", ")", ",", "(", "(", "BinaryField", ")", "response", ".", "arguments", ".", "get", "(", "3", ")", ")", ".", "getValue", "(", ")", ")", ";", "}" ]

[ "Request", "the", "artwork", "with", "a", "particular", "artwork", "ID", "given", "a", "connection", "to", "a", "player", "that", "has", "already", "been", "set", "up", "." ]

[ "private", "AlbumArt", "findArtInMemoryCaches", "(", "DataReference", "artReference", ")", "{", "// First see if we can find the new track in the hot cache as a hot cue", "for", "(", "AlbumArt", "cached", ":", "hotCache", ".", "values", "(", ")", ")", "{", "if", "(", "cached", ".", "artReference", ".", "equals", "(", "artReference", ")", ")", "{", "// Found a hot cue hit, use it.", "return", "cached", ";", "}", "}", "// Not in the hot cache, see if it is in our LRU cache", "return", "artCache", ".", "get", "(", "artReference", ")", ";", "}" ]

[ "Look", "for", "the", "specified", "album", "art", "in", "both", "the", "hot", "cache", "of", "loaded", "tracks", "and", "the", "longer", "-", "lived", "LRU", "cache", "." ]

[ "private", "void", "deliverAlbumArtUpdate", "(", "int", "player", ",", "AlbumArt", "art", ")", "{", "if", "(", "!", "getAlbumArtListeners", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "final", "AlbumArtUpdate", "update", "=", "new", "AlbumArtUpdate", "(", "player", ",", "art", ")", ";", "for", "(", "final", "AlbumArtListener", "listener", ":", "getAlbumArtListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "albumArtChanged", "(", "update", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering album art update to listener\"", ",", "t", ")", ";", "}", "}", "}", "}" ]

[ "Send", "an", "album", "art", "update", "announcement", "to", "all", "registered", "listeners", "." ]

[ "public", "BufferedImage", "getImage", "(", ")", "{", "ByteBuffer", "artwork", "=", "getRawBytes", "(", ")", ";", "artwork", ".", "rewind", "(", ")", ";", "byte", "[", "]", "imageBytes", "=", "new", "byte", "[", "artwork", ".", "remaining", "(", ")", "]", ";", "artwork", ".", "get", "(", "imageBytes", ")", ";", "try", "{", "return", "ImageIO", ".", "read", "(", "new", "ByteArrayInputStream", "(", "imageBytes", ")", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "error", "(", "\"Weird! Caught exception creating image from artwork bytes\"", ",", "e", ")", ";", "return", "null", ";", "}", "}" ]

[ "Given", "the", "byte", "buffer", "containing", "album", "art", "build", "an", "actual", "image", "from", "it", "for", "easy", "rendering", "." ]

[ "private", "TrackSourceSlot", "findTrackSourceSlot", "(", ")", "{", "TrackSourceSlot", "result", "=", "TRACK_SOURCE_SLOT_MAP", ".", "get", "(", "packetBytes", "[", "41", "]", ")", ";", "if", "(", "result", "==", "null", ")", "{", "return", "TrackSourceSlot", ".", "UNKNOWN", ";", "}", "return", "result", ";", "}" ]

[ "Determine", "the", "enum", "value", "corresponding", "to", "the", "track", "source", "slot", "found", "in", "the", "packet", "." ]

[ "private", "TrackType", "findTrackType", "(", ")", "{", "TrackType", "result", "=", "TRACK_TYPE_MAP", ".", "get", "(", "packetBytes", "[", "42", "]", ")", ";", "if", "(", "result", "==", "null", ")", "{", "return", "TrackType", ".", "UNKNOWN", ";", "}", "return", "result", ";", "}" ]

[ "Determine", "the", "enum", "value", "corresponding", "to", "the", "track", "type", "found", "in", "the", "packet", "." ]

[ "private", "PlayState1", "findPlayState1", "(", ")", "{", "PlayState1", "result", "=", "PLAY_STATE_1_MAP", ".", "get", "(", "packetBytes", "[", "123", "]", ")", ";", "if", "(", "result", "==", "null", ")", "{", "return", "PlayState1", ".", "UNKNOWN", ";", "}", "return", "result", ";", "}" ]

[ "Determine", "the", "enum", "value", "corresponding", "to", "the", "first", "play", "state", "found", "in", "the", "packet", "." ]

[ "private", "PlayState3", "findPlayState3", "(", ")", "{", "PlayState3", "result", "=", "PLAY_STATE_3_MAP", ".", "get", "(", "packetBytes", "[", "157", "]", ")", ";", "if", "(", "result", "==", "null", ")", "{", "return", "PlayState3", ".", "UNKNOWN", ";", "}", "return", "result", ";", "}" ]

[ "Determine", "the", "enum", "value", "corresponding", "to", "the", "third", "play", "state", "found", "in", "the", "packet", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "boolean", "isPlaying", "(", ")", "{", "if", "(", "packetBytes", ".", "length", ">=", "212", ")", "{", "return", "(", "packetBytes", "[", "STATUS_FLAGS", "]", "&", "PLAYING_FLAG", ")", ">", "0", ";", "}", "else", "{", "final", "PlayState1", "state", "=", "getPlayState1", "(", ")", ";", "return", "state", "==", "PlayState1", ".", "PLAYING", "||", "state", "==", "PlayState1", ".", "LOOPING", "||", "(", "state", "==", "PlayState1", ".", "SEARCHING", "&&", "getPlayState2", "(", ")", "==", "PlayState2", ".", "MOVING", ")", ";", "}", "}" ]

[ "Was", "the", "CDJ", "playing", "a", "track", "when", "this", "update", "was", "sent?" ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "String", "formatCueCountdown", "(", ")", "{", "int", "count", "=", "getCueCountdown", "(", ")", ";", "if", "(", "count", "==", "511", ")", "{", "return", "\"--.-\"", ";", "}", "if", "(", "(", "count", ">=", "1", ")", "&&", "(", "count", "<=", "256", ")", ")", "{", "int", "bars", "=", "(", "count", "-", "1", ")", "/", "4", ";", "int", "beats", "=", "(", "(", "count", "-", "1", ")", "%", "4", ")", "+", "1", ";", "return", "String", ".", "format", "(", "\"%02d.%d\"", ",", "bars", ",", "beats", ")", ";", "}", "if", "(", "count", "==", "0", ")", "{", "return", "\"00.0\"", ";", "}", "return", "\"??.?\"", ";", "}" ]

[ "Format", "a", "cue", "countdown", "indicator", "in", "the", "same", "way", "as", "the", "CDJ", "would", "at", "this", "point", "in", "the", "track", "." ]

[ "private", "void", "clearDeck", "(", "TrackMetadataUpdate", "update", ")", "{", "if", "(", "hotCache", ".", "remove", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "0", ")", ")", "!=", "null", ")", "{", "deliverBeatGridUpdate", "(", "update", ".", "player", ",", "null", ")", ";", "}", "}" ]

[ "We", "have", "received", "an", "update", "that", "invalidates", "the", "beat", "grid", "for", "a", "player", "so", "clear", "it", "and", "alert", "any", "listeners", "if", "this", "represents", "a", "change", ".", "This", "does", "not", "affect", "the", "hot", "cues", ";", "they", "will", "stick", "around", "until", "the", "player", "loads", "a", "new", "track", "that", "overwrites", "one", "or", "more", "of", "them", "." ]

[ "private", "void", "clearBeatGrids", "(", "DeviceAnnouncement", "announcement", ")", "{", "final", "int", "player", "=", "announcement", ".", "getNumber", "(", ")", ";", "// Iterate over a copy to avoid concurrent modification issues", "for", "(", "DeckReference", "deck", ":", "new", "HashSet", "<", "DeckReference", ">", "(", "hotCache", ".", "keySet", "(", ")", ")", ")", "{", "if", "(", "deck", ".", "player", "==", "player", ")", "{", "hotCache", ".", "remove", "(", "deck", ")", ";", "if", "(", "deck", ".", "hotCue", "==", "0", ")", "{", "deliverBeatGridUpdate", "(", "player", ",", "null", ")", ";", "// Inform listeners the beat grid is gone.", "}", "}", "}", "}" ]

[ "We", "have", "received", "notification", "that", "a", "device", "is", "no", "longer", "on", "the", "network", "so", "clear", "out", "all", "its", "beat", "grids", "." ]

[ "private", "void", "updateBeatGrid", "(", "TrackMetadataUpdate", "update", ",", "BeatGrid", "beatGrid", ")", "{", "hotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "0", ")", ",", "beatGrid", ")", ";", "// Main deck", "if", "(", "update", ".", "metadata", ".", "getCueList", "(", ")", "!=", "null", ")", "{", "// Update the cache with any hot cues in this track as well", "for", "(", "CueList", ".", "Entry", "entry", ":", "update", ".", "metadata", ".", "getCueList", "(", ")", ".", "entries", ")", "{", "if", "(", "entry", ".", "hotCueNumber", "!=", "0", ")", "{", "hotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "entry", ".", "hotCueNumber", ")", ",", "beatGrid", ")", ";", "}", "}", "}", "deliverBeatGridUpdate", "(", "update", ".", "player", ",", "beatGrid", ")", ";", "}" ]

[ "We", "have", "obtained", "a", "beat", "grid", "for", "a", "device", "so", "store", "it", "and", "alert", "any", "listeners", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "Map", "<", "DeckReference", ",", "BeatGrid", ">", "getLoadedBeatGrids", "(", ")", "{", "ensureRunning", "(", ")", ";", "// Make a copy so callers get an immutable snapshot of the current state.", "return", "Collections", ".", "unmodifiableMap", "(", "new", "HashMap", "<", "DeckReference", ",", "BeatGrid", ">", "(", "hotCache", ")", ")", ";", "}" ]

[ "Get", "the", "beat", "grids", "available", "for", "all", "tracks", "currently", "loaded", "in", "any", "player", "either", "on", "the", "play", "deck", "or", "in", "a", "hot", "cue", "." ]

[ "public", "BeatGrid", "requestBeatGridFrom", "(", "final", "DataReference", "track", ")", "{", "for", "(", "BeatGrid", "cached", ":", "hotCache", ".", "values", "(", ")", ")", "{", "if", "(", "cached", ".", "dataReference", ".", "equals", "(", "track", ")", ")", "{", "// Found a hot cue hit, use it.", "return", "cached", ";", "}", "}", "return", "requestBeatGridInternal", "(", "track", ",", "false", ")", ";", "}" ]

[ "Ask", "the", "specified", "player", "for", "the", "beat", "grid", "of", "the", "track", "in", "the", "specified", "slot", "with", "the", "specified", "rekordbox", "ID", "first", "checking", "if", "we", "have", "a", "cache", "we", "can", "use", "instead", "." ]

[ "BeatGrid", "getBeatGrid", "(", "int", "rekordboxId", ",", "SlotReference", "slot", ",", "Client", "client", ")", "throws", "IOException", "{", "Message", "response", "=", "client", ".", "simpleRequest", "(", "Message", ".", "KnownType", ".", "BEAT_GRID_REQ", ",", "null", ",", "client", ".", "buildRMST", "(", "Message", ".", "MenuIdentifier", ".", "DATA", ",", "slot", ".", "slot", ")", ",", "new", "NumberField", "(", "rekordboxId", ")", ")", ";", "if", "(", "response", ".", "knownType", "==", "Message", ".", "KnownType", ".", "BEAT_GRID", ")", "{", "return", "new", "BeatGrid", "(", "new", "DataReference", "(", "slot", ",", "rekordboxId", ")", ",", "response", ")", ";", "}", "logger", ".", "error", "(", "\"Unexpected response type when requesting beat grid: {}\"", ",", "response", ")", ";", "return", "null", ";", "}" ]

[ "Requests", "the", "beat", "grid", "for", "a", "specific", "track", "ID", "given", "a", "connection", "to", "a", "player", "that", "has", "already", "been", "set", "up", "." ]

[ "private", "void", "deliverBeatGridUpdate", "(", "int", "player", ",", "BeatGrid", "beatGrid", ")", "{", "if", "(", "!", "getBeatGridListeners", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "final", "BeatGridUpdate", "update", "=", "new", "BeatGridUpdate", "(", "player", ",", "beatGrid", ")", ";", "for", "(", "final", "BeatGridListener", "listener", ":", "getBeatGridListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "beatGridChanged", "(", "update", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering beat grid update to listener\"", ",", "t", ")", ";", "}", "}", "}", "}" ]

[ "Send", "a", "beat", "grid", "update", "announcement", "to", "all", "registered", "listeners", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "synchronized", "void", "stop", "(", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "MetadataFinder", ".", "getInstance", "(", ")", ".", "removeTrackMetadataListener", "(", "metadataListener", ")", ";", "running", ".", "set", "(", "false", ")", ";", "pendingUpdates", ".", "clear", "(", ")", ";", "queueHandler", ".", "interrupt", "(", ")", ";", "queueHandler", "=", "null", ";", "// Report the loss of our previews, on the proper thread, and outside our lock.", "final", "Set", "<", "DeckReference", ">", "dyingCache", "=", "new", "HashSet", "<", "DeckReference", ">", "(", "hotCache", ".", "keySet", "(", ")", ")", ";", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "for", "(", "DeckReference", "deck", ":", "dyingCache", ")", "{", "if", "(", "deck", ".", "hotCue", "==", "0", ")", "{", "deliverBeatGridUpdate", "(", "deck", ".", "player", ",", "null", ")", ";", "}", "}", "}", "}", ")", ";", "hotCache", ".", "clear", "(", ")", ";", "deliverLifecycleAnnouncement", "(", "logger", ",", "false", ")", ";", "}", "}" ]

[ "Stop", "finding", "beat", "grids", "for", "all", "active", "players", "." ]

[ "private", "long", "interpolateTimeSinceUpdate", "(", "TrackPositionUpdate", "update", ",", "long", "currentTimestamp", ")", "{", "if", "(", "!", "update", ".", "playing", ")", "{", "return", "update", ".", "milliseconds", ";", "}", "long", "elapsedMillis", "=", "(", "currentTimestamp", "-", "update", ".", "timestamp", ")", "/", "1000000", ";", "long", "moved", "=", "Math", ".", "round", "(", "update", ".", "pitch", "*", "elapsedMillis", ")", ";", "if", "(", "update", ".", "reverse", ")", "{", "return", "update", ".", "milliseconds", "-", "moved", ";", "}", "return", "update", ".", "milliseconds", "+", "moved", ";", "}" ]

[ "Figure", "out", "based", "on", "how", "much", "time", "has", "elapsed", "since", "we", "received", "an", "update", "and", "the", "playback", "position", "speed", "and", "direction", "at", "the", "time", "of", "that", "update", "where", "the", "player", "will", "be", "now", "." ]

[ "private", "long", "interpolateTimeFromUpdate", "(", "TrackPositionUpdate", "lastTrackUpdate", ",", "CdjStatus", "newDeviceUpdate", ",", "BeatGrid", "beatGrid", ")", "{", "final", "int", "beatNumber", "=", "newDeviceUpdate", ".", "getBeatNumber", "(", ")", ";", "final", "boolean", "noLongerPlaying", "=", "!", "newDeviceUpdate", ".", "isPlaying", "(", ")", ";", "// If we have just stopped, see if we are near a cue (assuming that information is available), and if so,", "// the best assumption is that the DJ jumped to that cue.", "if", "(", "lastTrackUpdate", ".", "playing", "&&", "noLongerPlaying", ")", "{", "final", "CueList", ".", "Entry", "jumpedTo", "=", "findAdjacentCue", "(", "newDeviceUpdate", ",", "beatGrid", ")", ";", "if", "(", "jumpedTo", "!=", "null", ")", "return", "jumpedTo", ".", "cueTime", ";", "}", "// Handle the special case where we were not playing either in the previous or current update, but the DJ", "// might have jumped to a different place in the track.", "if", "(", "!", "lastTrackUpdate", ".", "playing", ")", "{", "if", "(", "lastTrackUpdate", ".", "beatNumber", "==", "beatNumber", "&&", "noLongerPlaying", ")", "{", "// Haven't moved", "return", "lastTrackUpdate", ".", "milliseconds", ";", "}", "else", "{", "if", "(", "noLongerPlaying", ")", "{", "// Have jumped without playing.", "if", "(", "beatNumber", "<", "0", ")", "{", "return", "-", "1", ";", "// We don't know the position any more; weird to get into this state and still have a grid?", "}", "// As a heuristic, assume we are right before the beat?", "return", "timeOfBeat", "(", "beatGrid", ",", "beatNumber", ",", "newDeviceUpdate", ")", ";", "}", "}", "}", "// One way or another, we are now playing.", "long", "elapsedMillis", "=", "(", "newDeviceUpdate", ".", "getTimestamp", "(", ")", "-", "lastTrackUpdate", ".", "timestamp", ")", "/", "1000000", ";", "long", "moved", "=", "Math", ".", "round", "(", "lastTrackUpdate", ".", "pitch", "*", "elapsedMillis", ")", ";", "long", "interpolated", "=", "(", "lastTrackUpdate", ".", "reverse", ")", "?", "(", "lastTrackUpdate", ".", "milliseconds", "-", "moved", ")", ":", "lastTrackUpdate", ".", "milliseconds", "+", "moved", ";", "if", "(", "Math", ".", "abs", "(", "beatGrid", ".", "findBeatAtTime", "(", "interpolated", ")", "-", "beatNumber", ")", "<", "2", ")", "{", "return", "interpolated", ";", "// Our calculations still look plausible", "}", "// The player has jumped or drifted somewhere unexpected, correct.", "if", "(", "newDeviceUpdate", ".", "isPlayingForwards", "(", ")", ")", "{", "return", "timeOfBeat", "(", "beatGrid", ",", "beatNumber", ",", "newDeviceUpdate", ")", ";", "}", "else", "{", "return", "beatGrid", ".", "getTimeWithinTrack", "(", "Math", ".", "min", "(", "beatNumber", "+", "1", ",", "beatGrid", ".", "beatCount", ")", ")", ";", "}", "}" ]

[ "Sanity", "-", "check", "a", "new", "non", "-", "beat", "update", "make", "sure", "we", "are", "still", "interpolating", "a", "sensible", "position", "and", "correct", "as", "needed", "." ]

[ "public", "long", "getTimeFor", "(", "int", "player", ")", "{", "TrackPositionUpdate", "update", "=", "positions", ".", "get", "(", "player", ")", ";", "if", "(", "update", "!=", "null", ")", "{", "return", "interpolateTimeSinceUpdate", "(", "update", ",", "System", ".", "nanoTime", "(", ")", ")", ";", "}", "return", "-", "1", ";", "// We don't know.", "}" ]

[ "Get", "the", "best", "guess", "we", "have", "for", "the", "current", "track", "position", "on", "the", "specified", "player", "." ]

[ "private", "boolean", "interpolationsDisagree", "(", "TrackPositionUpdate", "lastUpdate", ",", "TrackPositionUpdate", "currentUpdate", ")", "{", "long", "now", "=", "System", ".", "nanoTime", "(", ")", ";", "return", "Math", ".", "abs", "(", "interpolateTimeSinceUpdate", "(", "lastUpdate", ",", "now", ")", "-", "interpolateTimeSinceUpdate", "(", "currentUpdate", ",", "now", ")", ")", ">", "slack", ".", "get", "(", ")", ";", "}" ]

[ "Check", "whether", "we", "have", "diverged", "from", "what", "we", "would", "predict", "from", "the", "last", "update", "that", "was", "sent", "to", "a", "particular", "track", "position", "listener", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "synchronized", "void", "stop", "(", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "BeatFinder", ".", "getInstance", "(", ")", ".", "removeBeatListener", "(", "beatListener", ")", ";", "VirtualCdj", ".", "getInstance", "(", ")", ".", "removeUpdateListener", "(", "updateListener", ")", ";", "running", ".", "set", "(", "false", ")", ";", "positions", ".", "clear", "(", ")", ";", "updates", ".", "clear", "(", ")", ";", "deliverLifecycleAnnouncement", "(", "logger", ",", "false", ")", ";", "}", "}" ]

[ "Stop", "interpolating", "playback", "position", "for", "all", "active", "players", "." ]

[ "public", "static", "synchronized", "DeckReference", "getDeckReference", "(", "int", "player", ",", "int", "hotCue", ")", "{", "Map", "<", "Integer", ",", "DeckReference", ">", "playerMap", "=", "instances", ".", "get", "(", "player", ")", ";", "if", "(", "playerMap", "==", "null", ")", "{", "playerMap", "=", "new", "HashMap", "<", "Integer", ",", "DeckReference", ">", "(", ")", ";", "instances", ".", "put", "(", "player", ",", "playerMap", ")", ";", "}", "DeckReference", "result", "=", "playerMap", ".", "get", "(", "hotCue", ")", ";", "if", "(", "result", "==", "null", ")", "{", "result", "=", "new", "DeckReference", "(", "player", ",", "hotCue", ")", ";", "playerMap", ".", "put", "(", "hotCue", ",", "result", ")", ";", "}", "return", "result", ";", "}" ]

[ "Get", "a", "unique", "reference", "to", "a", "place", "where", "a", "track", "is", "currently", "loaded", "in", "a", "player", "." ]

[ "public", "synchronized", "void", "setDeviceName", "(", "String", "name", ")", "{", "if", "(", "name", ".", "getBytes", "(", ")", ".", "length", ">", "DEVICE_NAME_LENGTH", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"name cannot be more than \"", "+", "DEVICE_NAME_LENGTH", "+", "\" bytes long\"", ")", ";", "}", "Arrays", ".", "fill", "(", "announcementBytes", ",", "DEVICE_NAME_OFFSET", ",", "DEVICE_NAME_LENGTH", ",", "(", "byte", ")", "0", ")", ";", "System", ".", "arraycopy", "(", "name", ".", "getBytes", "(", ")", ",", "0", ",", "announcementBytes", ",", "DEVICE_NAME_OFFSET", ",", "name", ".", "getBytes", "(", ")", ".", "length", ")", ";", "}" ]

[ "Set", "the", "name", "to", "be", "used", "in", "announcing", "our", "presence", "on", "the", "network", ".", "The", "name", "can", "be", "no", "longer", "than", "twenty", "bytes", "and", "should", "be", "normal", "ASCII", "no", "Unicode", "." ]

[ "private", "void", "setTempoMaster", "(", "DeviceUpdate", "newMaster", ")", "{", "DeviceUpdate", "oldMaster", "=", "tempoMaster", ".", "getAndSet", "(", "newMaster", ")", ";", "if", "(", "(", "newMaster", "==", "null", "&&", "oldMaster", "!=", "null", ")", "||", "(", "newMaster", "!=", "null", "&&", "(", "(", "oldMaster", "==", "null", ")", "||", "!", "newMaster", ".", "getAddress", "(", ")", ".", "equals", "(", "oldMaster", ".", "getAddress", "(", ")", ")", ")", ")", ")", "{", "// This is a change in master, so report it to any registered listeners", "deliverMasterChangedAnnouncement", "(", "newMaster", ")", ";", "}", "}" ]

[ "Establish", "a", "new", "tempo", "master", "and", "if", "it", "is", "a", "change", "from", "the", "existing", "one", "report", "it", "to", "the", "listeners", "." ]

[ "private", "void", "setMasterTempo", "(", "double", "newTempo", ")", "{", "double", "oldTempo", "=", "Double", ".", "longBitsToDouble", "(", "masterTempo", ".", "getAndSet", "(", "Double", ".", "doubleToLongBits", "(", "newTempo", ")", ")", ")", ";", "if", "(", "(", "getTempoMaster", "(", ")", "!=", "null", ")", "&&", "(", "Math", ".", "abs", "(", "newTempo", "-", "oldTempo", ")", ">", "getTempoEpsilon", "(", ")", ")", ")", "{", "// This is a change in tempo, so report it to any registered listeners, and update our metronome if we are synced.", "if", "(", "isSynced", "(", ")", ")", "{", "metronome", ".", "setTempo", "(", "newTempo", ")", ";", "notifyBeatSenderOfChange", "(", ")", ";", "}", "deliverTempoChangedAnnouncement", "(", "newTempo", ")", ";", "}", "}" ]

[ "Establish", "a", "new", "master", "tempo", "and", "if", "it", "is", "a", "change", "from", "the", "existing", "one", "report", "it", "to", "the", "listeners", "." ]

[ "private", "void", "processUpdate", "(", "DeviceUpdate", "update", ")", "{", "updates", ".", "put", "(", "update", ".", "getAddress", "(", ")", ",", "update", ")", ";", "// Keep track of the largest sync number we see.", "if", "(", "update", "instanceof", "CdjStatus", ")", "{", "int", "syncNumber", "=", "(", "(", "CdjStatus", ")", "update", ")", ".", "getSyncNumber", "(", ")", ";", "if", "(", "syncNumber", ">", "this", ".", "largestSyncCounter", ".", "get", "(", ")", ")", "{", "this", ".", "largestSyncCounter", ".", "set", "(", "syncNumber", ")", ";", "}", "}", "// Deal with the tempo master complexities, including handoff to/from us.", "if", "(", "update", ".", "isTempoMaster", "(", ")", ")", "{", "final", "Integer", "packetYieldingTo", "=", "update", ".", "getDeviceMasterIsBeingYieldedTo", "(", ")", ";", "if", "(", "packetYieldingTo", "==", "null", ")", "{", "// This is a normal, non-yielding master packet. Update our notion of the current master, and,", "// if we were yielding, finish that process, updating our sync number appropriately.", "if", "(", "master", ".", "get", "(", ")", ")", "{", "if", "(", "nextMaster", ".", "get", "(", ")", "==", "update", ".", "deviceNumber", ")", "{", "syncCounter", ".", "set", "(", "largestSyncCounter", ".", "get", "(", ")", "+", "1", ")", ";", "}", "else", "{", "if", "(", "nextMaster", ".", "get", "(", ")", "==", "0xff", ")", "{", "logger", ".", "warn", "(", "\"Saw master asserted by player \"", "+", "update", ".", "deviceNumber", "+", "\" when we were not yielding it.\"", ")", ";", "}", "else", "{", "logger", ".", "warn", "(", "\"Expected to yield master role to player \"", "+", "nextMaster", ".", "get", "(", ")", "+", "\" but saw master asserted by player \"", "+", "update", ".", "deviceNumber", ")", ";", "}", "}", "}", "master", ".", "set", "(", "false", ")", ";", "nextMaster", ".", "set", "(", "0xff", ")", ";", "setTempoMaster", "(", "update", ")", ";", "setMasterTempo", "(", "update", ".", "getEffectiveTempo", "(", ")", ")", ";", "}", "else", "{", "// This is a yielding master packet. If it is us that is being yielded to, take over master.", "// Log a message if it was unsolicited, and a warning if it's coming from a different player than", "// we asked.", "if", "(", "packetYieldingTo", "==", "getDeviceNumber", "(", ")", ")", "{", "if", "(", "update", ".", "deviceNumber", "!=", "masterYieldedFrom", ".", "get", "(", ")", ")", "{", "if", "(", "masterYieldedFrom", ".", "get", "(", ")", "==", "0", ")", "{", "logger", ".", "info", "(", "\"Accepting unsolicited Master yield; we must be the only synced device playing.\"", ")", ";", "}", "else", "{", "logger", ".", "warn", "(", "\"Expected player \"", "+", "masterYieldedFrom", ".", "get", "(", ")", "+", "\" to yield master to us, but player \"", "+", "update", ".", "deviceNumber", "+", "\" did.\"", ")", ";", "}", "}", "master", ".", "set", "(", "true", ")", ";", "masterYieldedFrom", ".", "set", "(", "0", ")", ";", "setTempoMaster", "(", "null", ")", ";", "setMasterTempo", "(", "getTempo", "(", ")", ")", ";", "}", "}", "}", "else", "{", "// This update was not acting as a tempo master; if we thought it should be, update our records.", "DeviceUpdate", "oldMaster", "=", "getTempoMaster", "(", ")", ";", "if", "(", "oldMaster", "!=", "null", "&&", "oldMaster", ".", "getAddress", "(", ")", ".", "equals", "(", "update", ".", "getAddress", "(", ")", ")", ")", "{", "// This device has resigned master status, and nobody else has claimed it so far", "setTempoMaster", "(", "null", ")", ";", "}", "}", "deliverDeviceUpdate", "(", "update", ")", ";", "}" ]

[ "Process", "a", "device", "update", "once", "it", "has", "been", "received", ".", "Track", "it", "as", "the", "most", "recent", "update", "from", "its", "address", "and", "notify", "any", "registered", "listeners", "including", "master", "listeners", "if", "it", "results", "in", "changes", "to", "tracked", "state", "such", "as", "the", "current", "master", "player", "and", "tempo", ".", "Also", "handles", "the", "Baroque", "dance", "of", "handing", "off", "the", "tempo", "master", "role", "from", "or", "to", "another", "device", "." ]

[ "void", "processBeat", "(", "Beat", "beat", ")", "{", "if", "(", "isRunning", "(", ")", "&&", "beat", ".", "isTempoMaster", "(", ")", ")", "{", "setMasterTempo", "(", "beat", ".", "getEffectiveTempo", "(", ")", ")", ";", "deliverBeatAnnouncement", "(", "beat", ")", ";", "}", "}" ]

[ "Process", "a", "beat", "packet", "potentially", "updating", "the", "master", "tempo", "and", "sending", "our", "listeners", "a", "master", "beat", "notification", ".", "Does", "nothing", "if", "we", "are", "not", "active", "." ]

[ "private", "InterfaceAddress", "findMatchingAddress", "(", "DeviceAnnouncement", "aDevice", ",", "NetworkInterface", "networkInterface", ")", "{", "for", "(", "InterfaceAddress", "address", ":", "networkInterface", ".", "getInterfaceAddresses", "(", ")", ")", "{", "if", "(", "(", "address", ".", "getBroadcast", "(", ")", "!=", "null", ")", "&&", "Util", ".", "sameNetwork", "(", "address", ".", "getNetworkPrefixLength", "(", ")", ",", "aDevice", ".", "getAddress", "(", ")", ",", "address", ".", "getAddress", "(", ")", ")", ")", "{", "return", "address", ";", "}", "}", "return", "null", ";", "}" ]

[ "Scan", "a", "network", "interface", "to", "find", "if", "it", "has", "an", "address", "space", "which", "matches", "the", "device", "we", "are", "trying", "to", "reach", ".", "If", "so", "return", "the", "address", "specification", "." ]

[ "public", "Set", "<", "DeviceAnnouncement", ">", "findUnreachablePlayers", "(", ")", "{", "ensureRunning", "(", ")", ";", "Set", "<", "DeviceAnnouncement", ">", "result", "=", "new", "HashSet", "<", "DeviceAnnouncement", ">", "(", ")", ";", "for", "(", "DeviceAnnouncement", "candidate", ":", "DeviceFinder", ".", "getInstance", "(", ")", ".", "getCurrentDevices", "(", ")", ")", "{", "if", "(", "!", "Util", ".", "sameNetwork", "(", "matchedAddress", ".", "getNetworkPrefixLength", "(", ")", ",", "matchedAddress", ".", "getAddress", "(", ")", ",", "candidate", ".", "getAddress", "(", ")", ")", ")", "{", "result", ".", "add", "(", "candidate", ")", ";", "}", "}", "return", "Collections", ".", "unmodifiableSet", "(", "result", ")", ";", "}" ]

[ "Checks", "if", "we", "can", "see", "any", "players", "that", "are", "on", "a", "different", "network", "than", "the", "one", "we", "chose", "for", "the", "Virtual", "CDJ", ".", "If", "so", "we", "are", "not", "going", "to", "be", "able", "to", "communicate", "with", "them", "and", "they", "should", "all", "be", "moved", "onto", "a", "single", "network", "." ]

[ "public", "synchronized", "void", "stop", "(", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "try", "{", "setSendingStatus", "(", "false", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "error", "(", "\"Problem stopping sending status during shutdown\"", ",", "t", ")", ";", "}", "DeviceFinder", ".", "getInstance", "(", ")", ".", "removeIgnoredAddress", "(", "socket", ".", "get", "(", ")", ".", "getLocalAddress", "(", ")", ")", ";", "socket", ".", "get", "(", ")", ".", "close", "(", ")", ";", "socket", ".", "set", "(", "null", ")", ";", "broadcastAddress", ".", "set", "(", "null", ")", ";", "updates", ".", "clear", "(", ")", ";", "setTempoMaster", "(", "null", ")", ";", "setDeviceNumber", "(", "(", "byte", ")", "0", ")", ";", "// Set up for self-assignment if restarted.", "deliverLifecycleAnnouncement", "(", "logger", ",", "false", ")", ";", "}", "}" ]

[ "Stop", "announcing", "ourselves", "and", "listening", "for", "status", "updates", "." ]

[ "private", "void", "sendAnnouncement", "(", "InetAddress", "broadcastAddress", ")", "{", "try", "{", "DatagramPacket", "announcement", "=", "new", "DatagramPacket", "(", "announcementBytes", ",", "announcementBytes", ".", "length", ",", "broadcastAddress", ",", "DeviceFinder", ".", "ANNOUNCEMENT_PORT", ")", ";", "socket", ".", "get", "(", ")", ".", "send", "(", "announcement", ")", ";", "Thread", ".", "sleep", "(", "getAnnounceInterval", "(", ")", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Unable to send announcement packet, shutting down\"", ",", "t", ")", ";", "stop", "(", ")", ";", "}", "}" ]

[ "Send", "an", "announcement", "packet", "so", "the", "other", "devices", "see", "us", "as", "being", "part", "of", "the", "DJ", "Link", "network", "and", "send", "us", "updates", "." ]

[ "private", "void", "deliverMasterChangedAnnouncement", "(", "final", "DeviceUpdate", "update", ")", "{", "for", "(", "final", "MasterListener", "listener", ":", "getMasterListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "masterChanged", "(", "update", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering master changed announcement to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "master", "changed", "announcement", "to", "all", "registered", "master", "listeners", "." ]

[ "private", "void", "deliverTempoChangedAnnouncement", "(", "final", "double", "tempo", ")", "{", "for", "(", "final", "MasterListener", "listener", ":", "getMasterListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "tempoChanged", "(", "tempo", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering tempo changed announcement to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "tempo", "changed", "announcement", "to", "all", "registered", "master", "listeners", "." ]

[ "private", "void", "deliverBeatAnnouncement", "(", "final", "Beat", "beat", ")", "{", "for", "(", "final", "MasterListener", "listener", ":", "getMasterListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "newBeat", "(", "beat", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering master beat announcement to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "beat", "announcement", "to", "all", "registered", "master", "listeners", "." ]

[ "private", "void", "deliverDeviceUpdate", "(", "final", "DeviceUpdate", "update", ")", "{", "for", "(", "DeviceUpdateListener", "listener", ":", "getUpdateListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "received", "(", "update", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering device update to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "device", "update", "to", "all", "registered", "update", "listeners", "." ]

[ "private", "void", "deliverMediaDetailsUpdate", "(", "final", "MediaDetails", "details", ")", "{", "for", "(", "MediaDetailsListener", "listener", ":", "getMediaDetailsListeners", "(", ")", ")", "{", "try", "{", "listener", ".", "detailsAvailable", "(", "details", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering media details response to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

[ "Send", "a", "media", "details", "response", "to", "all", "registered", "listeners", "." ]

[ "@", "SuppressWarnings", "(", "\"SameParameterValue\"", ")", "private", "void", "assembleAndSendPacket", "(", "Util", ".", "PacketType", "kind", ",", "byte", "[", "]", "payload", ",", "InetAddress", "destination", ",", "int", "port", ")", "throws", "IOException", "{", "DatagramPacket", "packet", "=", "Util", ".", "buildPacket", "(", "kind", ",", "ByteBuffer", ".", "wrap", "(", "announcementBytes", ",", "DEVICE_NAME_OFFSET", ",", "DEVICE_NAME_LENGTH", ")", ".", "asReadOnlyBuffer", "(", ")", ",", "ByteBuffer", ".", "wrap", "(", "payload", ")", ")", ";", "packet", ".", "setAddress", "(", "destination", ")", ";", "packet", ".", "setPort", "(", "port", ")", ";", "socket", ".", "get", "(", ")", ".", "send", "(", "packet", ")", ";", "}" ]

[ "Finish", "the", "work", "of", "building", "and", "sending", "a", "protocol", "packet", "." ]

[ "private", "void", "sendSyncControlCommand", "(", "DeviceUpdate", "target", ",", "byte", "command", ")", "throws", "IOException", "{", "ensureRunning", "(", ")", ";", "byte", "[", "]", "payload", "=", "new", "byte", "[", "SYNC_CONTROL_PAYLOAD", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "SYNC_CONTROL_PAYLOAD", ",", "0", ",", "payload", ",", "0", ",", "SYNC_CONTROL_PAYLOAD", ".", "length", ")", ";", "payload", "[", "2", "]", "=", "getDeviceNumber", "(", ")", ";", "payload", "[", "8", "]", "=", "getDeviceNumber", "(", ")", ";", "payload", "[", "12", "]", "=", "command", ";", "assembleAndSendPacket", "(", "Util", ".", "PacketType", ".", "SYNC_CONTROL", ",", "payload", ",", "target", ".", "getAddress", "(", ")", ",", "BeatFinder", ".", "BEAT_PORT", ")", ";", "}" ]

[ "Assemble", "and", "send", "a", "packet", "that", "performs", "sync", "control", "turning", "a", "device", "s", "sync", "mode", "on", "or", "off", "or", "telling", "it", "to", "become", "the", "tempo", "master", "." ]

[ "public", "void", "sendSyncModeCommand", "(", "int", "deviceNumber", ",", "boolean", "synced", ")", "throws", "IOException", "{", "final", "DeviceUpdate", "update", "=", "getLatestStatusFor", "(", "deviceNumber", ")", ";", "if", "(", "update", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Device \"", "+", "deviceNumber", "+", "\" not found on network.\"", ")", ";", "}", "sendSyncModeCommand", "(", "update", ",", "synced", ")", ";", "}" ]

[ "Tell", "a", "device", "to", "turn", "sync", "on", "or", "off", "." ]

[ "public", "void", "appointTempoMaster", "(", "int", "deviceNumber", ")", "throws", "IOException", "{", "final", "DeviceUpdate", "update", "=", "getLatestStatusFor", "(", "deviceNumber", ")", ";", "if", "(", "update", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Device \"", "+", "deviceNumber", "+", "\" not found on network.\"", ")", ";", "}", "appointTempoMaster", "(", "update", ")", ";", "}" ]

[ "Tell", "a", "device", "to", "become", "tempo", "master", "." ]

[ "public", "void", "sendFaderStartCommand", "(", "Set", "<", "Integer", ">", "deviceNumbersToStart", ",", "Set", "<", "Integer", ">", "deviceNumbersToStop", ")", "throws", "IOException", "{", "ensureRunning", "(", ")", ";", "byte", "[", "]", "payload", "=", "new", "byte", "[", "FADER_START_PAYLOAD", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "FADER_START_PAYLOAD", ",", "0", ",", "payload", ",", "0", ",", "FADER_START_PAYLOAD", ".", "length", ")", ";", "payload", "[", "2", "]", "=", "getDeviceNumber", "(", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<=", "4", ";", "i", "++", ")", "{", "if", "(", "deviceNumbersToStart", ".", "contains", "(", "i", ")", ")", "{", "payload", "[", "i", "+", "4", "]", "=", "0", ";", "}", "if", "(", "deviceNumbersToStop", ".", "contains", "(", "i", ")", ")", "{", "payload", "[", "i", "+", "4", "]", "=", "1", ";", "}", "}", "assembleAndSendPacket", "(", "Util", ".", "PacketType", ".", "FADER_START_COMMAND", ",", "payload", ",", "getBroadcastAddress", "(", ")", ",", "BeatFinder", ".", "BEAT_PORT", ")", ";", "}" ]

[ "Broadcast", "a", "packet", "that", "tells", "some", "players", "to", "start", "playing", "and", "others", "to", "stop", ".", "If", "a", "player", "number", "is", "in", "both", "sets", "it", "will", "be", "told", "to", "stop", ".", "Numbers", "outside", "the", "range", "1", "to", "4", "are", "ignored", "." ]

[ "public", "void", "sendLoadTrackCommand", "(", "int", "targetPlayer", ",", "int", "rekordboxId", ",", "int", "sourcePlayer", ",", "CdjStatus", ".", "TrackSourceSlot", "sourceSlot", ",", "CdjStatus", ".", "TrackType", "sourceType", ")", "throws", "IOException", "{", "final", "DeviceUpdate", "update", "=", "getLatestStatusFor", "(", "targetPlayer", ")", ";", "if", "(", "update", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Device \"", "+", "targetPlayer", "+", "\" not found on network.\"", ")", ";", "}", "sendLoadTrackCommand", "(", "update", ",", "rekordboxId", ",", "sourcePlayer", ",", "sourceSlot", ",", "sourceType", ")", ";", "}" ]

[ "Send", "a", "packet", "to", "the", "target", "player", "telling", "it", "to", "load", "the", "specified", "track", "from", "the", "specified", "source", "player", "." ]

[ "public", "void", "sendLoadTrackCommand", "(", "DeviceUpdate", "target", ",", "int", "rekordboxId", ",", "int", "sourcePlayer", ",", "CdjStatus", ".", "TrackSourceSlot", "sourceSlot", ",", "CdjStatus", ".", "TrackType", "sourceType", ")", "throws", "IOException", "{", "ensureRunning", "(", ")", ";", "byte", "[", "]", "payload", "=", "new", "byte", "[", "LOAD_TRACK_PAYLOAD", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "LOAD_TRACK_PAYLOAD", ",", "0", ",", "payload", ",", "0", ",", "LOAD_TRACK_PAYLOAD", ".", "length", ")", ";", "payload", "[", "0x02", "]", "=", "getDeviceNumber", "(", ")", ";", "payload", "[", "0x05", "]", "=", "getDeviceNumber", "(", ")", ";", "payload", "[", "0x09", "]", "=", "(", "byte", ")", "sourcePlayer", ";", "payload", "[", "0x0a", "]", "=", "sourceSlot", ".", "protocolValue", ";", "payload", "[", "0x0b", "]", "=", "sourceType", ".", "protocolValue", ";", "Util", ".", "numberToBytes", "(", "rekordboxId", ",", "payload", ",", "0x0d", ",", "4", ")", ";", "assembleAndSendPacket", "(", "Util", ".", "PacketType", ".", "LOAD_TRACK_COMMAND", ",", "payload", ",", "target", ".", "getAddress", "(", ")", ",", "UPDATE_PORT", ")", ";", "}" ]

[ "Send", "a", "packet", "to", "the", "target", "device", "telling", "it", "to", "load", "the", "specified", "track", "from", "the", "specified", "source", "player", "." ]

[ "public", "synchronized", "void", "setSendingStatus", "(", "boolean", "send", ")", "throws", "IOException", "{", "if", "(", "isSendingStatus", "(", ")", "==", "send", ")", "{", "return", ";", "}", "if", "(", "send", ")", "{", "// Start sending status packets.", "ensureRunning", "(", ")", ";", "if", "(", "(", "getDeviceNumber", "(", ")", "<", "1", ")", "||", "(", "getDeviceNumber", "(", ")", ">", "4", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Can only send status when using a standard player number, 1 through 4.\"", ")", ";", "}", "BeatFinder", ".", "getInstance", "(", ")", ".", "start", "(", ")", ";", "BeatFinder", ".", "getInstance", "(", ")", ".", "addLifecycleListener", "(", "beatFinderLifecycleListener", ")", ";", "final", "AtomicBoolean", "stillRunning", "=", "new", "AtomicBoolean", "(", "true", ")", ";", "sendingStatus", "=", "stillRunning", ";", "// Allow other threads to stop us when necessary.", "Thread", "sender", "=", "new", "Thread", "(", "null", ",", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "while", "(", "stillRunning", ".", "get", "(", ")", ")", "{", "sendStatus", "(", ")", ";", "try", "{", "Thread", ".", "sleep", "(", "getStatusInterval", "(", ")", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "logger", ".", "warn", "(", "\"beat-link VirtualCDJ status sender thread was interrupted; continuing\"", ")", ";", "}", "}", "}", "}", ",", "\"beat-link VirtualCdj status sender\"", ")", ";", "sender", ".", "setDaemon", "(", "true", ")", ";", "sender", ".", "start", "(", ")", ";", "if", "(", "isSynced", "(", ")", ")", "{", "// If we are supposed to be synced, we need to respond to master beats and tempo changes.", "addMasterListener", "(", "ourSyncMasterListener", ")", ";", "}", "if", "(", "isPlaying", "(", ")", ")", "{", "// Start the beat sender too, if we are supposed to be playing.", "beatSender", ".", "set", "(", "new", "BeatSender", "(", "metronome", ")", ")", ";", "}", "}", "else", "{", "// Stop sending status packets, and responding to master beats and tempo changes if we were synced.", "BeatFinder", ".", "getInstance", "(", ")", ".", "removeLifecycleListener", "(", "beatFinderLifecycleListener", ")", ";", "removeMasterListener", "(", "ourSyncMasterListener", ")", ";", "sendingStatus", ".", "set", "(", "false", ")", ";", "// Stop the status sending thread.", "sendingStatus", "=", "null", ";", "// Indicate that we are no longer sending status.", "final", "BeatSender", "activeSender", "=", "beatSender", ".", "get", "(", ")", ";", "// And stop the beat sender if we have one.", "if", "(", "activeSender", "!=", "null", ")", "{", "activeSender", ".", "shutDown", "(", ")", ";", "beatSender", ".", "set", "(", "null", ")", ";", "}", "}", "}" ]

[ "Control", "whether", "the", "Virtual", "CDJ", "sends", "status", "packets", "to", "the", "other", "players", ".", "Most", "uses", "of", "Beat", "Link", "will", "not", "require", "this", "level", "of", "activity", ".", "However", "if", "you", "want", "to", "be", "able", "to", "take", "over", "the", "tempo", "master", "role", "and", "control", "the", "tempo", "and", "beat", "alignment", "of", "other", "players", "you", "will", "need", "to", "turn", "on", "this", "feature", "which", "also", "requires", "that", "you", "are", "using", "one", "of", "the", "standard", "player", "numbers", "1", "-", "4", "." ]

[ "public", "void", "setPlaying", "(", "boolean", "playing", ")", "{", "if", "(", "this", ".", "playing", ".", "get", "(", ")", "==", "playing", ")", "{", "return", ";", "}", "this", ".", "playing", ".", "set", "(", "playing", ")", ";", "if", "(", "playing", ")", "{", "metronome", ".", "jumpToBeat", "(", "whereStopped", ".", "get", "(", ")", ".", "getBeat", "(", ")", ")", ";", "if", "(", "isSendingStatus", "(", ")", ")", "{", "// Need to also start the beat sender.", "beatSender", ".", "set", "(", "new", "BeatSender", "(", "metronome", ")", ")", ";", "}", "}", "else", "{", "final", "BeatSender", "activeSender", "=", "beatSender", ".", "get", "(", ")", ";", "if", "(", "activeSender", "!=", "null", ")", "{", "// We have a beat sender we need to stop.", "activeSender", ".", "shutDown", "(", ")", ";", "beatSender", ".", "set", "(", "null", ")", ";", "}", "whereStopped", ".", "set", "(", "metronome", ".", "getSnapshot", "(", ")", ")", ";", "}", "}" ]

[ "Controls", "whether", "we", "report", "that", "we", "are", "playing", ".", "This", "will", "only", "have", "an", "impact", "when", "we", "are", "sending", "status", "and", "beat", "packets", "." ]

[ "public", "synchronized", "void", "becomeTempoMaster", "(", ")", "throws", "IOException", "{", "logger", ".", "debug", "(", "\"Trying to become master.\"", ")", ";", "if", "(", "!", "isSendingStatus", "(", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Must be sending status updates to become the tempo master.\"", ")", ";", "}", "// Is there someone we need to ask to yield to us?", "final", "DeviceUpdate", "currentMaster", "=", "getTempoMaster", "(", ")", ";", "if", "(", "currentMaster", "!=", "null", ")", "{", "// Send the yield request; we will become master when we get a successful response.", "byte", "[", "]", "payload", "=", "new", "byte", "[", "MASTER_HANDOFF_REQUEST_PAYLOAD", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "MASTER_HANDOFF_REQUEST_PAYLOAD", ",", "0", ",", "payload", ",", "0", ",", "MASTER_HANDOFF_REQUEST_PAYLOAD", ".", "length", ")", ";", "payload", "[", "2", "]", "=", "getDeviceNumber", "(", ")", ";", "payload", "[", "8", "]", "=", "getDeviceNumber", "(", ")", ";", "if", "(", "logger", ".", "isDebugEnabled", "(", ")", ")", "{", "logger", ".", "debug", "(", "\"Sending master yield request to player \"", "+", "currentMaster", ")", ";", "}", "requestingMasterRoleFromPlayer", ".", "set", "(", "currentMaster", ".", "deviceNumber", ")", ";", "assembleAndSendPacket", "(", "Util", ".", "PacketType", ".", "MASTER_HANDOFF_REQUEST", ",", "payload", ",", "currentMaster", ".", "address", ",", "BeatFinder", ".", "BEAT_PORT", ")", ";", "}", "else", "if", "(", "!", "master", ".", "get", "(", ")", ")", "{", "// There is no other master, we can just become it immediately.", "requestingMasterRoleFromPlayer", ".", "set", "(", "0", ")", ";", "setMasterTempo", "(", "getTempo", "(", ")", ")", ";", "master", ".", "set", "(", "true", ")", ";", "}", "}" ]

[ "Arrange", "to", "become", "the", "tempo", "master", ".", "Starts", "a", "sequence", "of", "interactions", "with", "the", "other", "players", "that", "should", "end", "up", "with", "us", "in", "charge", "of", "the", "group", "tempo", "and", "beat", "alignment", "." ]

[ "public", "synchronized", "void", "setSynced", "(", "boolean", "sync", ")", "{", "if", "(", "synced", ".", "get", "(", ")", "!=", "sync", ")", "{", "// We are changing sync state, so add or remove our master listener as appropriate.", "if", "(", "sync", "&&", "isSendingStatus", "(", ")", ")", "{", "addMasterListener", "(", "ourSyncMasterListener", ")", ";", "}", "else", "{", "removeMasterListener", "(", "ourSyncMasterListener", ")", ";", "}", "// Also, if there is a tempo master, and we just got synced, adopt its tempo.", "if", "(", "!", "isTempoMaster", "(", ")", "&&", "getTempoMaster", "(", ")", "!=", "null", ")", "{", "setTempo", "(", "getMasterTempo", "(", ")", ")", ";", "}", "}", "synced", ".", "set", "(", "sync", ")", ";", "}" ]

[ "Controls", "whether", "we", "are", "currently", "staying", "in", "sync", "with", "the", "tempo", "master", ".", "Will", "only", "be", "meaningful", "if", "we", "are", "sending", "status", "packets", "." ]

[ "public", "synchronized", "void", "jumpToBeat", "(", "int", "beat", ")", "{", "if", "(", "beat", "<", "1", ")", "{", "beat", "=", "1", ";", "}", "else", "{", "beat", "=", "wrapBeat", "(", "beat", ")", ";", "}", "if", "(", "playing", ".", "get", "(", ")", ")", "{", "metronome", ".", "jumpToBeat", "(", "beat", ")", ";", "}", "else", "{", "whereStopped", ".", "set", "(", "metronome", ".", "getSnapshot", "(", "metronome", ".", "getTimeOfBeat", "(", "beat", ")", ")", ")", ";", "}", "}" ]

[ "Moves", "our", "current", "playback", "position", "to", "the", "specified", "beat", ";", "this", "will", "be", "reflected", "in", "any", "status", "and", "beat", "packets", "that", "we", "are", "sending", ".", "An", "incoming", "value", "less", "than", "one", "will", "jump", "us", "to", "the", "first", "beat", "." ]

[ "public", "Set", "<", "PlaybackState", ">", "getPlaybackState", "(", ")", "{", "Set", "<", "PlaybackState", ">", "result", "=", "new", "HashSet", "<", "PlaybackState", ">", "(", "playbackStateMap", ".", "values", "(", ")", ")", ";", "return", "Collections", ".", "unmodifiableSet", "(", "result", ")", ";", "}" ]

[ "Look", "up", "all", "recorded", "playback", "state", "information", "." ]

[ "private", "void", "setPlaybackPosition", "(", "long", "milliseconds", ")", "{", "PlaybackState", "oldState", "=", "currentSimpleState", "(", ")", ";", "if", "(", "oldState", "!=", "null", "&&", "oldState", ".", "position", "!=", "milliseconds", ")", "{", "setPlaybackState", "(", "oldState", ".", "player", ",", "milliseconds", ",", "oldState", ".", "playing", ")", ";", "}", "}" ]

[ "Set", "the", "current", "playback", "position", ".", "This", "method", "can", "only", "be", "used", "in", "situations", "where", "the", "component", "is", "tied", "to", "a", "single", "player", "and", "therefore", "always", "has", "a", "single", "playback", "position", "." ]

[ "private", "void", "setPlaying", "(", "boolean", "playing", ")", "{", "PlaybackState", "oldState", "=", "currentSimpleState", "(", ")", ";", "if", "(", "oldState", "!=", "null", "&&", "oldState", ".", "playing", "!=", "playing", ")", "{", "setPlaybackState", "(", "oldState", ".", "player", ",", "oldState", ".", "position", ",", "playing", ")", ";", "}", "}" ]

[ "Set", "whether", "the", "player", "holding", "the", "waveform", "is", "playing", "which", "changes", "the", "indicator", "color", "to", "white", "from", "red", ".", "This", "method", "can", "only", "be", "used", "in", "situations", "where", "the", "component", "is", "tied", "to", "a", "single", "player", "and", "therefore", "has", "a", "single", "playback", "position", "." ]

[ "public", "synchronized", "void", "setMonitoredPlayer", "(", "final", "int", "player", ")", "{", "if", "(", "player", "<", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"player cannot be negative\"", ")", ";", "}", "clearPlaybackState", "(", ")", ";", "monitoredPlayer", ".", "set", "(", "player", ")", ";", "if", "(", "player", ">", "0", ")", "{", "// Start monitoring the specified player", "setPlaybackState", "(", "player", ",", "0", ",", "false", ")", ";", "// Start with default values for required simple state.", "VirtualCdj", ".", "getInstance", "(", ")", ".", "addUpdateListener", "(", "updateListener", ")", ";", "MetadataFinder", ".", "getInstance", "(", ")", ".", "addTrackMetadataListener", "(", "metadataListener", ")", ";", "cueList", ".", "set", "(", "null", ")", ";", "// Assume the worst, but see if we have one available next.", "if", "(", "MetadataFinder", ".", "getInstance", "(", ")", ".", "isRunning", "(", ")", ")", "{", "TrackMetadata", "metadata", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getLatestMetadataFor", "(", "player", ")", ";", "if", "(", "metadata", "!=", "null", ")", "{", "cueList", ".", "set", "(", "metadata", ".", "getCueList", "(", ")", ")", ";", "}", "}", "WaveformFinder", ".", "getInstance", "(", ")", ".", "addWaveformListener", "(", "waveformListener", ")", ";", "if", "(", "WaveformFinder", ".", "getInstance", "(", ")", ".", "isRunning", "(", ")", "&&", "WaveformFinder", ".", "getInstance", "(", ")", ".", "isFindingDetails", "(", ")", ")", "{", "waveform", ".", "set", "(", "WaveformFinder", ".", "getInstance", "(", ")", ".", "getLatestDetailFor", "(", "player", ")", ")", ";", "}", "else", "{", "waveform", ".", "set", "(", "null", ")", ";", "}", "BeatGridFinder", ".", "getInstance", "(", ")", ".", "addBeatGridListener", "(", "beatGridListener", ")", ";", "if", "(", "BeatGridFinder", ".", "getInstance", "(", ")", ".", "isRunning", "(", ")", ")", "{", "beatGrid", ".", "set", "(", "BeatGridFinder", ".", "getInstance", "(", ")", ".", "getLatestBeatGridFor", "(", "player", ")", ")", ";", "}", "else", "{", "beatGrid", ".", "set", "(", "null", ")", ";", "}", "try", "{", "TimeFinder", ".", "getInstance", "(", ")", ".", "start", "(", ")", ";", "if", "(", "!", "animating", ".", "getAndSet", "(", "true", ")", ")", "{", "// Create the thread to update our position smoothly as the track plays", "new", "Thread", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "while", "(", "animating", ".", "get", "(", ")", ")", "{", "try", "{", "Thread", ".", "sleep", "(", "33", ")", ";", "// Animate at 30 fps", "}", "catch", "(", "InterruptedException", "e", ")", "{", "logger", ".", "warn", "(", "\"Waveform animation thread interrupted; ending\"", ")", ";", "animating", ".", "set", "(", "false", ")", ";", "}", "setPlaybackPosition", "(", "TimeFinder", ".", "getInstance", "(", ")", ".", "getTimeFor", "(", "getMonitoredPlayer", "(", ")", ")", ")", ";", "}", "}", "}", ")", ".", "start", "(", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "error", "(", "\"Unable to start the TimeFinder to animate the waveform detail view\"", ")", ";", "animating", ".", "set", "(", "false", ")", ";", "}", "}", "else", "{", "// Stop monitoring any player", "animating", ".", "set", "(", "false", ")", ";", "VirtualCdj", ".", "getInstance", "(", ")", ".", "removeUpdateListener", "(", "updateListener", ")", ";", "MetadataFinder", ".", "getInstance", "(", ")", ".", "removeTrackMetadataListener", "(", "metadataListener", ")", ";", "WaveformFinder", ".", "getInstance", "(", ")", ".", "removeWaveformListener", "(", "waveformListener", ")", ";", "cueList", ".", "set", "(", "null", ")", ";", "waveform", ".", "set", "(", "null", ")", ";", "beatGrid", ".", "set", "(", "null", ")", ";", "}", "if", "(", "!", "autoScroll", ".", "get", "(", ")", ")", "{", "invalidate", "(", ")", ";", "}", "repaint", "(", ")", ";", "}" ]

[ "Configures", "the", "player", "whose", "current", "track", "waveforms", "and", "status", "will", "automatically", "be", "reflected", ".", "Whenever", "a", "new", "track", "is", "loaded", "on", "that", "player", "the", "waveform", "and", "metadata", "will", "be", "updated", "and", "the", "current", "playback", "position", "and", "state", "of", "the", "player", "will", "be", "reflected", "by", "the", "component", "." ]

[ "public", "PlaybackState", "getFurthestPlaybackState", "(", ")", "{", "PlaybackState", "result", "=", "null", ";", "for", "(", "PlaybackState", "state", ":", "playbackStateMap", ".", "values", "(", ")", ")", "{", "if", "(", "result", "==", "null", "||", "(", "!", "result", ".", "playing", "&&", "state", ".", "playing", ")", "||", "(", "result", ".", "position", "<", "state", ".", "position", ")", "&&", "(", "state", ".", "playing", "||", "!", "result", ".", "playing", ")", ")", "{", "result", "=", "state", ";", "}", "}", "return", "result", ";", "}" ]

[ "Look", "up", "the", "playback", "state", "that", "has", "reached", "furthest", "in", "the", "track", "but", "give", "playing", "players", "priority", "over", "stopped", "players", ".", "This", "is", "used", "to", "choose", "the", "scroll", "center", "when", "auto", "-", "scrolling", "is", "active", "." ]

[ "private", "int", "getSegmentForX", "(", "int", "x", ")", "{", "if", "(", "autoScroll", ".", "get", "(", ")", ")", "{", "int", "playHead", "=", "(", "x", "-", "(", "getWidth", "(", ")", "/", "2", ")", ")", ";", "int", "offset", "=", "Util", ".", "timeToHalfFrame", "(", "getFurthestPlaybackPosition", "(", ")", ")", "/", "scale", ".", "get", "(", ")", ";", "return", "(", "playHead", "+", "offset", ")", "*", "scale", ".", "get", "(", ")", ";", "}", "return", "x", "*", "scale", ".", "get", "(", ")", ";", "}" ]

[ "Figure", "out", "the", "starting", "waveform", "segment", "that", "corresponds", "to", "the", "specified", "coordinate", "in", "the", "window", "." ]

[ "public", "int", "getXForBeat", "(", "int", "beat", ")", "{", "BeatGrid", "grid", "=", "beatGrid", ".", "get", "(", ")", ";", "if", "(", "grid", "!=", "null", ")", "{", "return", "millisecondsToX", "(", "grid", ".", "getTimeWithinTrack", "(", "beat", ")", ")", ";", "}", "return", "0", ";", "}" ]

[ "Determine", "the", "X", "coordinate", "within", "the", "component", "at", "which", "the", "specified", "beat", "begins", "." ]

[ "public", "int", "millisecondsToX", "(", "long", "milliseconds", ")", "{", "if", "(", "autoScroll", ".", "get", "(", ")", ")", "{", "int", "playHead", "=", "(", "getWidth", "(", ")", "/", "2", ")", "+", "2", ";", "long", "offset", "=", "milliseconds", "-", "getFurthestPlaybackPosition", "(", ")", ";", "return", "playHead", "+", "(", "Util", ".", "timeToHalfFrame", "(", "offset", ")", "/", "scale", ".", "get", "(", ")", ")", ";", "}", "return", "Util", ".", "timeToHalfFrame", "(", "milliseconds", ")", "/", "scale", ".", "get", "(", ")", ";", "}" ]

[ "Converts", "a", "time", "in", "milliseconds", "to", "the", "appropriate", "x", "coordinate", "for", "drawing", "something", "at", "that", "time", "." ]

[ "public", "static", "Color", "cueColor", "(", "CueList", ".", "Entry", "entry", ")", "{", "if", "(", "entry", ".", "hotCueNumber", ">", "0", ")", "{", "return", "Color", ".", "GREEN", ";", "}", "if", "(", "entry", ".", "isLoop", ")", "{", "return", "Color", ".", "ORANGE", ";", "}", "return", "Color", ".", "RED", ";", "}" ]

[ "Determine", "the", "color", "to", "use", "to", "draw", "a", "cue", "list", "entry", ".", "Hot", "cues", "are", "green", "ordinary", "memory", "points", "are", "red", "and", "loops", "are", "orange", "." ]

[ "public", "byte", "[", "]", "getPacketBytes", "(", ")", "{", "byte", "[", "]", "result", "=", "new", "byte", "[", "packetBytes", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "packetBytes", ",", "0", ",", "result", ",", "0", ",", "packetBytes", ".", "length", ")", ";", "return", "result", ";", "}" ]

[ "Get", "the", "raw", "data", "bytes", "of", "the", "device", "update", "packet", "." ]

[ "public", "static", "DatagramPacket", "buildPacket", "(", "PacketType", "type", ",", "ByteBuffer", "deviceName", ",", "ByteBuffer", "payload", ")", "{", "ByteBuffer", "content", "=", "ByteBuffer", ".", "allocate", "(", "0x1f", "+", "payload", ".", "remaining", "(", ")", ")", ";", "content", ".", "put", "(", "getMagicHeader", "(", ")", ")", ";", "content", ".", "put", "(", "type", ".", "protocolValue", ")", ";", "content", ".", "put", "(", "deviceName", ")", ";", "content", ".", "put", "(", "payload", ")", ";", "return", "new", "DatagramPacket", "(", "content", ".", "array", "(", ")", ",", "content", ".", "capacity", "(", ")", ")", ";", "}" ]

[ "Build", "a", "standard", "-", "format", "UDP", "packet", "for", "sending", "to", "port", "50001", "or", "50002", "in", "the", "protocol", "." ]

[ "public", "static", "PacketType", "validateHeader", "(", "DatagramPacket", "packet", ",", "int", "port", ")", "{", "byte", "[", "]", "data", "=", "packet", ".", "getData", "(", ")", ";", "if", "(", "data", ".", "length", "<", "PACKET_TYPE_OFFSET", ")", "{", "logger", ".", "warn", "(", "\"Packet is too short to be a Pro DJ Link packet; must be at least \"", "+", "PACKET_TYPE_OFFSET", "+", "\" bytes long, was only \"", "+", "data", ".", "length", "+", "\".\"", ")", ";", "return", "null", ";", "}", "if", "(", "!", "getMagicHeader", "(", ")", ".", "equals", "(", "ByteBuffer", ".", "wrap", "(", "data", ",", "0", ",", "MAGIC_HEADER", ".", "length", ")", ")", ")", "{", "logger", ".", "warn", "(", "\"Packet did not have correct nine-byte header for the Pro DJ Link protocol.\"", ")", ";", "return", "null", ";", "}", "final", "Map", "<", "Byte", ",", "PacketType", ">", "portMap", "=", "PACKET_TYPE_MAP", ".", "get", "(", "port", ")", ";", "if", "(", "portMap", "==", "null", ")", "{", "logger", ".", "warn", "(", "\"Do not know any Pro DJ Link packets that are received on port \"", "+", "port", "+", "\".\"", ")", ";", "return", "null", ";", "}", "final", "PacketType", "result", "=", "portMap", ".", "get", "(", "data", "[", "PACKET_TYPE_OFFSET", "]", ")", ";", "if", "(", "result", "==", "null", ")", "{", "logger", ".", "warn", "(", "\"Do not know any Pro DJ Link packets received on port \"", "+", "port", "+", "\" with type \"", "+", "String", ".", "format", "(", "\"0x%02x\"", ",", "data", "[", "PACKET_TYPE_OFFSET", "]", ")", "+", "\".\"", ")", ";", "}", "return", "result", ";", "}" ]

[ "Check", "to", "see", "whether", "a", "packet", "starts", "with", "the", "standard", "header", "bytes", "followed", "by", "a", "known", "byte", "identifying", "it", ".", "If", "so", "return", "the", "kind", "of", "packet", "that", "has", "been", "recognized", "." ]

[ "public", "static", "long", "bytesToNumber", "(", "byte", "[", "]", "buffer", ",", "int", "start", ",", "int", "length", ")", "{", "long", "result", "=", "0", ";", "for", "(", "int", "index", "=", "start", ";", "index", "<", "start", "+", "length", ";", "index", "++", ")", "{", "result", "=", "(", "result", "<<", "8", ")", "+", "unsign", "(", "buffer", "[", "index", "]", ")", ";", "}", "return", "result", ";", "}" ]

[ "Reconstructs", "a", "number", "that", "is", "represented", "by", "more", "than", "one", "byte", "in", "a", "network", "packet", "in", "big", "-", "endian", "order", "." ]

[ "@", "SuppressWarnings", "(", "\"SameParameterValue\"", ")", "public", "static", "long", "bytesToNumberLittleEndian", "(", "byte", "[", "]", "buffer", ",", "int", "start", ",", "int", "length", ")", "{", "long", "result", "=", "0", ";", "for", "(", "int", "index", "=", "start", "+", "length", "-", "1", ";", "index", ">=", "start", ";", "index", "--", ")", "{", "result", "=", "(", "result", "<<", "8", ")", "+", "unsign", "(", "buffer", "[", "index", "]", ")", ";", "}", "return", "result", ";", "}" ]

[ "Reconstructs", "a", "number", "that", "is", "represented", "by", "more", "than", "one", "byte", "in", "a", "network", "packet", "in", "little", "-", "endian", "order", "for", "the", "very", "few", "protocol", "values", "that", "are", "sent", "in", "this", "quirky", "way", "." ]

[ "public", "static", "void", "numberToBytes", "(", "int", "number", ",", "byte", "[", "]", "buffer", ",", "int", "start", ",", "int", "length", ")", "{", "for", "(", "int", "index", "=", "start", "+", "length", "-", "1", ";", "index", ">=", "start", ";", "index", "--", ")", "{", "buffer", "[", "index", "]", "=", "(", "byte", ")", "(", "number", "&", "0xff", ")", ";", "number", "=", "number", ">>", "8", ";", "}", "}" ]

[ "Writes", "a", "number", "to", "the", "specified", "byte", "array", "field", "breaking", "it", "into", "its", "component", "bytes", "in", "big", "-", "endian", "order", ".", "If", "the", "number", "is", "too", "large", "to", "fit", "in", "the", "specified", "number", "of", "bytes", "only", "the", "low", "-", "order", "bytes", "are", "written", "." ]

[ "public", "static", "long", "addressToLong", "(", "InetAddress", "address", ")", "{", "long", "result", "=", "0", ";", "for", "(", "byte", "element", ":", "address", ".", "getAddress", "(", ")", ")", "{", "result", "=", "(", "result", "<<", "8", ")", "+", "unsign", "(", "element", ")", ";", "}", "return", "result", ";", "}" ]

[ "Converts", "the", "bytes", "that", "make", "up", "an", "internet", "address", "into", "the", "corresponding", "integer", "value", "to", "make", "it", "easier", "to", "perform", "bit", "-", "masking", "operations", "on", "them", "." ]

[ "public", "static", "boolean", "sameNetwork", "(", "int", "prefixLength", ",", "InetAddress", "address1", ",", "InetAddress", "address2", ")", "{", "if", "(", "logger", ".", "isDebugEnabled", "(", ")", ")", "{", "logger", ".", "debug", "(", "\"Comparing address \"", "+", "address1", ".", "getHostAddress", "(", ")", "+", "\" with \"", "+", "address2", ".", "getHostAddress", "(", ")", "+", "\", prefixLength=\"", "+", "prefixLength", ")", ";", "}", "long", "prefixMask", "=", "0xffffffff", "", "L", "&", "(", "-", "1", "<<", "(", "32", "-", "prefixLength", ")", ")", ";", "return", "(", "addressToLong", "(", "address1", ")", "&", "prefixMask", ")", "==", "(", "addressToLong", "(", "address2", ")", "&", "prefixMask", ")", ";", "}" ]

[ "Checks", "whether", "two", "internet", "addresses", "are", "on", "the", "same", "subnet", "." ]

[ "public", "static", "void", "writeFully", "(", "ByteBuffer", "buffer", ",", "WritableByteChannel", "channel", ")", "throws", "IOException", "{", "while", "(", "buffer", ".", "hasRemaining", "(", ")", ")", "{", "channel", ".", "write", "(", "buffer", ")", ";", "}", "}" ]

[ "Writes", "the", "entire", "remaining", "contents", "of", "the", "buffer", "to", "the", "channel", ".", "May", "complete", "in", "one", "operation", "but", "the", "documentation", "is", "vague", "so", "this", "keeps", "going", "until", "we", "are", "sure", "." ]