_id stringlengths 2 7 | title stringlengths 3 140 | partition stringclasses 3
values | text stringlengths 73 34.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q7400 | Field.read | train | public static Field read(DataInputStream is) throws IOException {
final byte tag = is.readByte();
final Field result;
switch (tag) {
case 0x0f:
case 0x10:
case 0x11:
result = new NumberField(tag, is);
break;
case 0x14:
result = new BinaryField(is);
break;
case 0x26:
result = new StringField(is);
break;
default:
throw new IOException("Unable to read a field with type tag " + tag);
}
logger.debug("..received> {}", result);
return result;
} | java | {
"resource": ""
} |
q7401 | Field.write | train | public void write(WritableByteChannel channel) throws IOException {
logger.debug("..writing> {}", this);
Util.writeFully(getBytes(), channel);
} | java | {
"resource": ""
} |
q7402 | MetadataFinder.requestMetadataFrom | train | @SuppressWarnings("WeakerAccess")
public TrackMetadata requestMetadataFrom(final CdjStatus status) {
if (status.getTrackSourceSlot() == CdjStatus.TrackSourceSlot.NO_TRACK || status.getRekordboxId() == 0) {
return null;
}
final DataReference track = new DataReference(status.getTrackSourcePlayer(), status.getTrackSourceSlot(),
status.getRekordboxId());
return requestMetadataFrom(track, status.getTrackType());
} | java | {
"resource": ""
} |
q7403 | MetadataFinder.requestMetadataFrom | train | @SuppressWarnings("WeakerAccess")
public TrackMetadata requestMetadataFrom(final DataReference track, final CdjStatus.TrackType trackType) {
return requestMetadataInternal(track, trackType, false);
} | java | {
"resource": ""
} |
q7404 | MetadataFinder.requestMetadataInternal | train | private TrackMetadata requestMetadataInternal(final DataReference track, final CdjStatus.TrackType trackType,
final boolean failIfPassive) {
// First check if we are using cached data for this request.
MetadataCache cache = getMetadataCache(SlotReference.getSlotReference(track));
if (cache != null && trackType == CdjStatus.TrackType.REKORDBOX) {
return cache.getTrackMetadata(null, track);
}
// Then see if any registered metadata providers can offer it for us.
final MediaDetails sourceDetails = getMediaDetailsFor(track.getSlotReference());
if (sourceDetails != null) {
final TrackMetadata provided = allMetadataProviders.getTrackMetadata(sourceDetails, track);
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 (passive.get() && failIfPassive && track.slot != CdjStatus.TrackSourceSlot.COLLECTION) {
return null;
}
// Use the dbserver protocol implementation to request the metadata.
ConnectionManager.ClientTask<TrackMetadata> task = new ConnectionManager.ClientTask<TrackMetadata>() {
@Override
public TrackMetadata useClient(Client client) throws Exception {
return queryMetadata(track, trackType, client);
}
};
try {
return ConnectionManager.getInstance().invokeWithClientSession(track.player, task, "requesting metadata");
} catch (Exception e) {
logger.error("Problem requesting metadata, returning null", e);
}
return null;
} | java | {
"resource": ""
} |
q7405 | MetadataFinder.queryMetadata | train | TrackMetadata queryMetadata(final DataReference track, final CdjStatus.TrackType trackType, final Client client)
throws IOException, InterruptedException, TimeoutException {
// Send the metadata menu request
if (client.tryLockingForMenuOperations(20, TimeUnit.SECONDS)) {
try {
final Message.KnownType requestType = (trackType == CdjStatus.TrackType.REKORDBOX) ?
Message.KnownType.REKORDBOX_METADATA_REQ : Message.KnownType.UNANALYZED_METADATA_REQ;
final Message response = client.menuRequestTyped(requestType, Message.MenuIdentifier.MAIN_MENU,
track.slot, trackType, new NumberField(track.rekordboxId));
final long count = response.getMenuResultsCount();
if (count == Message.NO_MENU_RESULTS_AVAILABLE) {
return null;
}
// Gather the cue list and all the metadata menu items
final List<Message> items = client.renderMenuItems(Message.MenuIdentifier.MAIN_MENU, track.slot, trackType, response);
final CueList cueList = getCueList(track.rekordboxId, track.slot, client);
return new TrackMetadata(track, trackType, items, cueList);
} finally {
client.unlockForMenuOperations();
}
} else {
throw new TimeoutException("Unable to lock the player for menu operations");
}
} | java | {
"resource": ""
} |
q7406 | MetadataFinder.getCueList | train | CueList getCueList(int rekordboxId, CdjStatus.TrackSourceSlot slot, Client client)
throws IOException {
Message response = client.simpleRequest(Message.KnownType.CUE_LIST_REQ, null,
client.buildRMST(Message.MenuIdentifier.DATA, slot), new NumberField(rekordboxId));
if (response.knownType == Message.KnownType.CUE_LIST) {
return new CueList(response);
}
logger.error("Unexpected response type when requesting cue list: {}", response);
return null;
} | java | {
"resource": ""
} |
q7407 | MetadataFinder.getFullTrackList | train | List<Message> getFullTrackList(final CdjStatus.TrackSourceSlot slot, final Client client, final int sortOrder)
throws IOException, InterruptedException, TimeoutException {
// Send the metadata menu request
if (client.tryLockingForMenuOperations(MENU_TIMEOUT, TimeUnit.SECONDS)) {
try {
Message response = client.menuRequest(Message.KnownType.TRACK_MENU_REQ, Message.MenuIdentifier.MAIN_MENU, slot,
new NumberField(sortOrder));
final long count = response.getMenuResultsCount();
if (count == Message.NO_MENU_RESULTS_AVAILABLE || count == 0) {
return Collections.emptyList();
}
// Gather all the metadata menu items
return client.renderMenuItems(Message.MenuIdentifier.MAIN_MENU, slot, CdjStatus.TrackType.REKORDBOX, response);
}
finally {
client.unlockForMenuOperations();
}
} else {
throw new TimeoutException("Unable to lock the player for menu operations");
}
} | java | {
"resource": ""
} |
q7408 | MetadataFinder.clearDeck | train | private void clearDeck(CdjStatus update) {
if (hotCache.remove(DeckReference.getDeckReference(update.getDeviceNumber(), 0)) != null) {
deliverTrackMetadataUpdate(update.getDeviceNumber(), null);
}
} | java | {
"resource": ""
} |
q7409 | MetadataFinder.clearMetadata | train | private void clearMetadata(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) {
deliverTrackMetadataUpdate(player, null); // Inform listeners the metadata is gone.
}
}
}
} | java | {
"resource": ""
} |
q7410 | MetadataFinder.updateMetadata | train | private void updateMetadata(CdjStatus update, TrackMetadata data) {
hotCache.put(DeckReference.getDeckReference(update.getDeviceNumber(), 0), data); // Main deck
if (data.getCueList() != null) { // Update the cache with any hot cues in this track as well
for (CueList.Entry entry : data.getCueList().entries) {
if (entry.hotCueNumber != 0) {
hotCache.put(DeckReference.getDeckReference(update.getDeviceNumber(), entry.hotCueNumber), data);
}
}
}
deliverTrackMetadataUpdate(update.getDeviceNumber(), data);
} | java | {
"resource": ""
} |
q7411 | MetadataFinder.getLoadedTracks | train | public Map<DeckReference, TrackMetadata> getLoadedTracks() {
ensureRunning();
// Make a copy so callers get an immutable snapshot of the current state.
return Collections.unmodifiableMap(new HashMap<DeckReference, TrackMetadata>(hotCache));
} | java | {
"resource": ""
} |
q7412 | MetadataFinder.attachMetadataCache | train | public void attachMetadataCache(SlotReference slot, File file)
throws IOException {
ensureRunning();
if (slot.player < 1 || slot.player > 4 || DeviceFinder.getInstance().getLatestAnnouncementFrom(slot.player) == null) {
throw new IllegalArgumentException("unable to attach metadata cache for player " + slot.player);
}
if ((slot.slot != CdjStatus.TrackSourceSlot.USB_SLOT) && (slot.slot != CdjStatus.TrackSourceSlot.SD_SLOT)) {
throw new IllegalArgumentException("unable to attach metadata cache for slot " + slot.slot);
}
MetadataCache cache = new MetadataCache(file);
final MediaDetails slotDetails = getMediaDetailsFor(slot);
if (cache.sourceMedia != null && slotDetails != null) {
if (!slotDetails.hashKey().equals(cache.sourceMedia.hashKey())) {
throw new IllegalArgumentException("Cache was created for different media (" + cache.sourceMedia.hashKey() +
") than is in the slot (" + slotDetails.hashKey() + ").");
}
if (slotDetails.hasChanged(cache.sourceMedia)) {
logger.warn("Media has changed (" + slotDetails + ") since cache was created (" + cache.sourceMedia +
"). Attaching anyway as instructed.");
}
}
attachMetadataCacheInternal(slot, cache);
} | java | {
"resource": ""
} |
q7413 | MetadataFinder.attachMetadataCacheInternal | train | void attachMetadataCacheInternal(SlotReference slot, MetadataCache cache) {
MetadataCache oldCache = metadataCacheFiles.put(slot, cache);
if (oldCache != null) {
try {
oldCache.close();
} catch (IOException e) {
logger.error("Problem closing previous metadata cache", e);
}
}
deliverCacheUpdate(slot, cache);
} | java | {
"resource": ""
} |
q7414 | MetadataFinder.detachMetadataCache | train | public void detachMetadataCache(SlotReference slot) {
MetadataCache oldCache = metadataCacheFiles.remove(slot);
if (oldCache != null) {
try {
oldCache.close();
} catch (IOException e) {
logger.error("Problem closing metadata cache", e);
}
deliverCacheUpdate(slot, null);
}
} | java | {
"resource": ""
} |
q7415 | MetadataFinder.getAutoAttachCacheFiles | train | public List<File> getAutoAttachCacheFiles() {
ArrayList<File> currentFiles = new ArrayList<File>(autoAttachCacheFiles);
Collections.sort(currentFiles, new Comparator<File>() {
@Override
public int compare(File o1, File o2) {
return o1.getName().compareTo(o2.getName());
}
});
return Collections.unmodifiableList(currentFiles);
} | java | {
"resource": ""
} |
q7416 | MetadataFinder.flushHotCacheSlot | train | private void flushHotCacheSlot(SlotReference slot) {
// Iterate over a copy to avoid concurrent modification issues
for (Map.Entry<DeckReference, TrackMetadata> entry : new HashMap<DeckReference,TrackMetadata>(hotCache).entrySet()) {
if (slot == SlotReference.getSlotReference(entry.getValue().trackReference)) {
logger.debug("Evicting cached metadata in response to unmount report {}", entry.getValue());
hotCache.remove(entry.getKey());
}
}
} | java | {
"resource": ""
} |
q7417 | MetadataFinder.recordMount | train | private void recordMount(SlotReference slot) {
if (mediaMounts.add(slot)) {
deliverMountUpdate(slot, true);
}
if (!mediaDetails.containsKey(slot)) {
try {
VirtualCdj.getInstance().sendMediaQuery(slot);
} catch (Exception e) {
logger.warn("Problem trying to request media details for " + slot, e);
}
}
} | java | {
"resource": ""
} |
q7418 | MetadataFinder.removeMount | train | private void removeMount(SlotReference slot) {
mediaDetails.remove(slot);
if (mediaMounts.remove(slot)) {
deliverMountUpdate(slot, false);
}
} | java | {
"resource": ""
} |
q7419 | MetadataFinder.deliverMountUpdate | train | private void deliverMountUpdate(SlotReference slot, boolean mounted) {
if (mounted) {
logger.info("Reporting media mounted in " + slot);
} else {
logger.info("Reporting media removed from " + slot);
}
for (final MountListener listener : getMountListeners()) {
try {
if (mounted) {
listener.mediaMounted(slot);
} else {
listener.mediaUnmounted(slot);
}
} catch (Throwable t) {
logger.warn("Problem delivering mount update to listener", t);
}
}
if (mounted) {
MetadataCache.tryAutoAttaching(slot);
}
} | java | {
"resource": ""
} |
q7420 | MetadataFinder.deliverCacheUpdate | train | private void deliverCacheUpdate(SlotReference slot, MetadataCache cache) {
for (final MetadataCacheListener listener : getCacheListeners()) {
try {
if (cache == null) {
listener.cacheDetached(slot);
} else {
listener.cacheAttached(slot, cache);
}
} catch (Throwable t) {
logger.warn("Problem delivering metadata cache update to listener", t);
}
}
} | java | {
"resource": ""
} |
q7421 | MetadataFinder.deliverTrackMetadataUpdate | train | private void deliverTrackMetadataUpdate(int player, TrackMetadata metadata) {
if (!getTrackMetadataListeners().isEmpty()) {
final TrackMetadataUpdate update = new TrackMetadataUpdate(player, metadata);
for (final TrackMetadataListener listener : getTrackMetadataListeners()) {
try {
listener.metadataChanged(update);
} catch (Throwable t) {
logger.warn("Problem delivering track metadata update to listener", t);
}
}
}
} | java | {
"resource": ""
} |
q7422 | MetadataFinder.addMetadataProviderForMedia | train | private void addMetadataProviderForMedia(String key, MetadataProvider provider) {
if (!metadataProviders.containsKey(key)) {
metadataProviders.put(key, Collections.newSetFromMap(new ConcurrentHashMap<MetadataProvider, Boolean>()));
}
Set<MetadataProvider> providers = metadataProviders.get(key);
providers.add(provider);
} | java | {
"resource": ""
} |
q7423 | MetadataFinder.removeMetadataProvider | train | public void removeMetadataProvider(MetadataProvider provider) {
for (Set<MetadataProvider> providers : metadataProviders.values()) {
providers.remove(provider);
}
} | java | {
"resource": ""
} |
q7424 | MetadataFinder.getMetadataProviders | train | public Set<MetadataProvider> getMetadataProviders(MediaDetails sourceMedia) {
String key = (sourceMedia == null)? "" : sourceMedia.hashKey();
Set<MetadataProvider> result = metadataProviders.get(key);
if (result == null) {
return Collections.emptySet();
}
return Collections.unmodifiableSet(new HashSet<MetadataProvider>(result));
} | java | {
"resource": ""
} |
q7425 | MetadataFinder.handleUpdate | train | private void handleUpdate(final CdjStatus update) {
// First see if any metadata caches need evicting or mount sets need updating.
if (update.isLocalUsbEmpty()) {
final SlotReference slot = SlotReference.getSlotReference(update.getDeviceNumber(), CdjStatus.TrackSourceSlot.USB_SLOT);
detachMetadataCache(slot);
flushHotCacheSlot(slot);
removeMount(slot);
} else if (update.isLocalUsbLoaded()) {
recordMount(SlotReference.getSlotReference(update.getDeviceNumber(), CdjStatus.TrackSourceSlot.USB_SLOT));
}
if (update.isLocalSdEmpty()) {
final SlotReference slot = SlotReference.getSlotReference(update.getDeviceNumber(), CdjStatus.TrackSourceSlot.SD_SLOT);
detachMetadataCache(slot);
flushHotCacheSlot(slot);
removeMount(slot);
} else if (update.isLocalSdLoaded()){
recordMount(SlotReference.getSlotReference(update.getDeviceNumber(), CdjStatus.TrackSourceSlot.SD_SLOT));
}
if (update.isDiscSlotEmpty()) {
removeMount(SlotReference.getSlotReference(update.getDeviceNumber(), CdjStatus.TrackSourceSlot.CD_SLOT));
} else {
recordMount(SlotReference.getSlotReference(update.getDeviceNumber(), CdjStatus.TrackSourceSlot.CD_SLOT));
}
// Now see if a track has changed that needs new metadata.
if (update.getTrackType() == CdjStatus.TrackType.UNKNOWN ||
update.getTrackType() == CdjStatus.TrackType.NO_TRACK ||
update.getTrackSourceSlot() == CdjStatus.TrackSourceSlot.NO_TRACK ||
update.getTrackSourceSlot() == CdjStatus.TrackSourceSlot.UNKNOWN ||
update.getRekordboxId() == 0) { // We no longer have metadata for this device.
clearDeck(update);
} else { // We can offer metadata for this device; check if we already looked up this track.
final TrackMetadata lastMetadata = hotCache.get(DeckReference.getDeckReference(update.getDeviceNumber(), 0));
final DataReference trackReference = new DataReference(update.getTrackSourcePlayer(),
update.getTrackSourceSlot(), update.getRekordboxId());
if (lastMetadata == null || !lastMetadata.trackReference.equals(trackReference)) { // We have something new!
// First see if we can find the new track in the hot cache as a hot cue
for (TrackMetadata cached : hotCache.values()) {
if (cached.trackReference.equals(trackReference)) { // Found a hot cue hit, use it.
updateMetadata(update, cached);
return;
}
}
// Not in the hot cache so try actually retrieving it.
if (activeRequests.add(update.getTrackSourcePlayer())) {
// We had to make sure we were not already asking for this track.
clearDeck(update); // We won't know what it is until our request completes.
new Thread(new Runnable() {
@Override
public void run() {
try {
TrackMetadata data = requestMetadataInternal(trackReference, update.getTrackType(), true);
if (data != null) {
updateMetadata(update, data);
}
} catch (Exception e) {
logger.warn("Problem requesting track metadata from update" + update, e);
} finally {
activeRequests.remove(update.getTrackSourcePlayer());
}
}
}, "MetadataFinder metadata request").start();
}
}
}
} | java | {
"resource": ""
} |
q7426 | WaveformDetail.getColorWaveformBits | train | private int getColorWaveformBits(final ByteBuffer waveBytes, final int segment) {
final int base = (segment * 2);
final int big = Util.unsign(waveBytes.get(base));
final int small = Util.unsign(waveBytes.get(base + 1));
return big * 256 + small;
} | java | {
"resource": ""
} |
q7427 | MetadataCache.addCacheFormatEntry | train | private static void addCacheFormatEntry(List<Message> trackListEntries, int playlistId, ZipOutputStream zos) throws IOException {
// Add a marker so we can recognize this as a metadata archive. I would use the ZipFile comment, but
// that is not available until Java 7, and Beat Link is supposed to be backwards compatible with Java 6.
// Since we are doing this anyway, we can also provide information about the nature of the cache, and
// how many metadata entries it contains, which is useful for auto-attachment.
zos.putNextEntry(new ZipEntry(CACHE_FORMAT_ENTRY));
String formatEntry = CACHE_FORMAT_IDENTIFIER + ":" + playlistId + ":" + trackListEntries.size();
zos.write(formatEntry.getBytes("UTF-8"));
} | java | {
"resource": ""
} |
q7428 | MetadataCache.addCacheDetailsEntry | train | private static void addCacheDetailsEntry(SlotReference slot, ZipOutputStream zos, WritableByteChannel channel) throws IOException {
// Record the details of the media being cached, to make it easier to recognize now that we can.
MediaDetails details = MetadataFinder.getInstance().getMediaDetailsFor(slot);
if (details != null) {
zos.putNextEntry(new ZipEntry(CACHE_DETAILS_ENTRY));
Util.writeFully(details.getRawBytes(), channel);
}
} | java | {
"resource": ""
} |
q7429 | MetadataCache.getCacheFormatEntry | train | private String getCacheFormatEntry() throws IOException {
ZipEntry zipEntry = zipFile.getEntry(CACHE_FORMAT_ENTRY);
InputStream is = zipFile.getInputStream(zipEntry);
try {
Scanner s = new Scanner(is, "UTF-8").useDelimiter("\\A");
String tag = null;
if (s.hasNext()) tag = s.next();
return tag;
} finally {
is.close();
}
} | java | {
"resource": ""
} |
q7430 | MetadataCache.getTrackIds | train | public List<Integer> getTrackIds() {
ArrayList<Integer> results = new ArrayList<Integer>(trackCount);
Enumeration<? extends ZipEntry> entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
if (entry.getName().startsWith(CACHE_METADATA_ENTRY_PREFIX)) {
String idPart = entry.getName().substring(CACHE_METADATA_ENTRY_PREFIX.length());
if (idPart.length() > 0) {
results.add(Integer.valueOf(idPart));
}
}
}
return Collections.unmodifiableList(results);
} | java | {
"resource": ""
} |
q7431 | MetadataCache.createMetadataCache | train | public static void createMetadataCache(SlotReference slot, int playlistId, File cache) throws Exception {
createMetadataCache(slot, playlistId, cache, null);
} | java | {
"resource": ""
} |
q7432 | MetadataCache.tryAutoAttaching | train | static void tryAutoAttaching(final SlotReference slot) {
if (!MetadataFinder.getInstance().getMountedMediaSlots().contains(slot)) {
logger.error("Unable to auto-attach cache to empty slot {}", slot);
return;
}
if (MetadataFinder.getInstance().getMetadataCache(slot) != null) {
logger.info("Not auto-attaching to slot {}; already has a cache attached.", slot);
return;
}
if (MetadataFinder.getInstance().getAutoAttachCacheFiles().isEmpty()) {
logger.debug("No auto-attach files configured.");
return;
}
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5); // Give us a chance to find out what type of media is in the new mount.
final MediaDetails details = MetadataFinder.getInstance().getMediaDetailsFor(slot);
if (details != null && details.mediaType == CdjStatus.TrackType.REKORDBOX) {
// First stage attempt: See if we can match based on stored media details, which is both more reliable and
// less disruptive than trying to sample the player database to compare entries.
boolean attached = false;
for (File file : MetadataFinder.getInstance().getAutoAttachCacheFiles()) {
final MetadataCache cache = new MetadataCache(file);
try {
if (cache.sourceMedia != null && cache.sourceMedia.hashKey().equals(details.hashKey())) {
// We found a solid match, no need to probe tracks.
final boolean changed = cache.sourceMedia.hasChanged(details);
logger.info("Auto-attaching metadata cache " + cache.getName() + " to slot " + slot +
" based on media details " + (changed? "(changed since created)!" : "(unchanged)."));
MetadataFinder.getInstance().attachMetadataCacheInternal(slot, cache);
attached = true;
return;
}
} finally {
if (!attached) {
cache.close();
}
}
}
// Could not match based on media details; fall back to older method based on probing track metadata.
ConnectionManager.ClientTask<Object> task = new ConnectionManager.ClientTask<Object>() {
@Override
public Object useClient(Client client) throws Exception {
tryAutoAttachingWithConnection(slot, client);
return null;
}
};
ConnectionManager.getInstance().invokeWithClientSession(slot.player, task, "trying to auto-attach metadata cache");
}
} catch (Exception e) {
logger.error("Problem trying to auto-attach metadata cache for slot " + slot, e);
}
}
}, "Metadata cache file auto-attachment attempt").start();
} | java | {
"resource": ""
} |
q7433 | MetadataCache.gatherCandidateAttachmentGroups | train | private static Map<Integer, LinkedList<MetadataCache>> gatherCandidateAttachmentGroups() {
Map<Integer,LinkedList<MetadataCache>> candidateGroups = new TreeMap<Integer, LinkedList<MetadataCache>>();
final Iterator<File> iterator = MetadataFinder.getInstance().getAutoAttachCacheFiles().iterator();
while (iterator.hasNext()) {
final File file = iterator.next();
try {
final MetadataCache candidate = new MetadataCache(file);
if (candidateGroups.get(candidate.sourcePlaylist) == null) {
candidateGroups.put(candidate.sourcePlaylist, new LinkedList<MetadataCache>());
}
candidateGroups.get(candidate.sourcePlaylist).add(candidate);
} catch (Exception e) {
logger.error("Unable to open metadata cache file " + file + ", discarding", e);
iterator.remove();
}
}
return candidateGroups;
} | java | {
"resource": ""
} |
q7434 | MetadataCache.findTrackIdAtOffset | train | 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();
} | java | {
"resource": ""
} |
q7435 | BeatFinder.isPacketLongEnough | train | 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;
} | java | {
"resource": ""
} |
q7436 | BeatFinder.stop | train | public synchronized void stop() {
if (isRunning()) {
socket.get().close();
socket.set(null);
deliverLifecycleAnnouncement(logger, false);
}
} | java | {
"resource": ""
} |
q7437 | BeatFinder.deliverSyncCommand | train | 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);
}
}
} | java | {
"resource": ""
} |
q7438 | BeatFinder.deliverMasterYieldCommand | train | 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);
}
}
} | java | {
"resource": ""
} |
q7439 | BeatFinder.deliverMasterYieldResponse | train | 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);
}
}
} | java | {
"resource": ""
} |
q7440 | BeatFinder.deliverOnAirUpdate | train | 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);
}
}
} | java | {
"resource": ""
} |
q7441 | BeatFinder.deliverFaderStartCommand | train | 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);
}
}
} | java | {
"resource": ""
} |
q7442 | Message.write | train | public void write(WritableByteChannel channel) throws IOException {
logger.debug("Writing> {}", this);
for (Field field : fields) {
field.write(channel);
}
} | java | {
"resource": ""
} |
q7443 | WaveformFinder.setFindDetails | train | 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);
}
}
});
}
} | java | {
"resource": ""
} |
q7444 | WaveformFinder.setColorPreferred | train | 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);
}
}
} | java | {
"resource": ""
} |
q7445 | WaveformFinder.clearDeckPreview | train | private void clearDeckPreview(TrackMetadataUpdate update) {
if (previewHotCache.remove(DeckReference.getDeckReference(update.player, 0)) != null) {
deliverWaveformPreviewUpdate(update.player, null);
}
} | java | {
"resource": ""
} |
q7446 | WaveformFinder.clearDeckDetail | train | private void clearDeckDetail(TrackMetadataUpdate update) {
if (detailHotCache.remove(DeckReference.getDeckReference(update.player, 0)) != null) {
deliverWaveformDetailUpdate(update.player, null);
}
} | java | {
"resource": ""
} |
q7447 | WaveformFinder.clearWaveforms | train | 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.
}
}
}
} | java | {
"resource": ""
} |
q7448 | WaveformFinder.updatePreview | train | 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);
} | java | {
"resource": ""
} |
q7449 | WaveformFinder.updateDetail | train | 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);
} | java | {
"resource": ""
} |
q7450 | WaveformFinder.getLoadedPreviews | train | @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));
} | java | {
"resource": ""
} |
q7451 | WaveformFinder.getLoadedDetails | train | @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));
} | java | {
"resource": ""
} |
q7452 | WaveformFinder.requestPreviewInternal | train | 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;
} | java | {
"resource": ""
} |
q7453 | WaveformFinder.requestWaveformPreviewFrom | train | 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);
} | java | {
"resource": ""
} |
q7454 | WaveformFinder.getWaveformPreview | train | 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);
} | java | {
"resource": ""
} |
q7455 | WaveformFinder.requestWaveformDetailFrom | train | 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);
} | java | {
"resource": ""
} |
q7456 | WaveformFinder.getWaveformDetail | train | 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);
} | java | {
"resource": ""
} |
q7457 | WaveformFinder.deliverWaveformPreviewUpdate | train | 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);
}
}
}
});
}
} | java | {
"resource": ""
} |
q7458 | WaveformFinder.deliverWaveformDetailUpdate | train | 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);
}
}
}
});
}
} | java | {
"resource": ""
} |
q7459 | WaveformFinder.primeCache | train | 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()));
}
}
}
});
} | java | {
"resource": ""
} |
q7460 | WaveformFinder.stop | train | @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);
}
} | java | {
"resource": ""
} |
q7461 | ArtFinder.clearArt | train | 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);
}
}
} | java | {
"resource": ""
} |
q7462 | ArtFinder.updateArt | train | 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);
} | java | {
"resource": ""
} |
q7463 | ArtFinder.getLoadedArt | train | 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));
} | java | {
"resource": ""
} |
q7464 | ArtFinder.requestArtworkInternal | train | 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;
} | java | {
"resource": ""
} |
q7465 | ArtFinder.requestArtworkFrom | train | 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;
} | java | {
"resource": ""
} |
q7466 | ArtFinder.getArtwork | train | 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());
} | java | {
"resource": ""
} |
q7467 | ArtFinder.findArtInMemoryCaches | train | 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);
} | java | {
"resource": ""
} |
q7468 | ArtFinder.deliverAlbumArtUpdate | train | 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);
}
}
}
} | java | {
"resource": ""
} |
q7469 | AlbumArt.getImage | train | 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;
}
} | java | {
"resource": ""
} |
q7470 | CdjStatus.findTrackSourceSlot | train | private TrackSourceSlot findTrackSourceSlot() {
TrackSourceSlot result = TRACK_SOURCE_SLOT_MAP.get(packetBytes[41]);
if (result == null) {
return TrackSourceSlot.UNKNOWN;
}
return result;
} | java | {
"resource": ""
} |
q7471 | CdjStatus.findTrackType | train | private TrackType findTrackType() {
TrackType result = TRACK_TYPE_MAP.get(packetBytes[42]);
if (result == null) {
return TrackType.UNKNOWN;
}
return result;
} | java | {
"resource": ""
} |
q7472 | CdjStatus.findPlayState1 | train | private PlayState1 findPlayState1() {
PlayState1 result = PLAY_STATE_1_MAP.get(packetBytes[123]);
if (result == null) {
return PlayState1.UNKNOWN;
}
return result;
} | java | {
"resource": ""
} |
q7473 | CdjStatus.findPlayState3 | train | private PlayState3 findPlayState3() {
PlayState3 result = PLAY_STATE_3_MAP.get(packetBytes[157]);
if (result == null) {
return PlayState3.UNKNOWN;
}
return result;
} | java | {
"resource": ""
} |
q7474 | CdjStatus.isPlaying | train | @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);
}
} | java | {
"resource": ""
} |
q7475 | CdjStatus.formatCueCountdown | train | @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 "??.?";
} | java | {
"resource": ""
} |
q7476 | BeatGridFinder.clearDeck | train | private void clearDeck(TrackMetadataUpdate update) {
if (hotCache.remove(DeckReference.getDeckReference(update.player, 0)) != null) {
deliverBeatGridUpdate(update.player, null);
}
} | java | {
"resource": ""
} |
q7477 | BeatGridFinder.clearBeatGrids | train | 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.
}
}
}
} | java | {
"resource": ""
} |
q7478 | BeatGridFinder.updateBeatGrid | train | 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);
} | java | {
"resource": ""
} |
q7479 | BeatGridFinder.getLoadedBeatGrids | train | @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));
} | java | {
"resource": ""
} |
q7480 | BeatGridFinder.requestBeatGridFrom | train | 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);
} | java | {
"resource": ""
} |
q7481 | BeatGridFinder.getBeatGrid | train | 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;
} | java | {
"resource": ""
} |
q7482 | BeatGridFinder.deliverBeatGridUpdate | train | 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);
}
}
}
} | java | {
"resource": ""
} |
q7483 | BeatGridFinder.stop | train | @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);
}
} | java | {
"resource": ""
} |
q7484 | TimeFinder.interpolateTimeSinceUpdate | train | 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;
} | java | {
"resource": ""
} |
q7485 | TimeFinder.interpolateTimeFromUpdate | train | 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));
}
} | java | {
"resource": ""
} |
q7486 | TimeFinder.getTimeFor | train | public long getTimeFor(int player) {
TrackPositionUpdate update = positions.get(player);
if (update != null) {
return interpolateTimeSinceUpdate(update, System.nanoTime());
}
return -1; // We don't know.
} | java | {
"resource": ""
} |
q7487 | TimeFinder.interpolationsDisagree | train | private boolean interpolationsDisagree(TrackPositionUpdate lastUpdate, TrackPositionUpdate currentUpdate) {
long now = System.nanoTime();
return Math.abs(interpolateTimeSinceUpdate(lastUpdate, now) - interpolateTimeSinceUpdate(currentUpdate, now)) >
slack.get();
} | java | {
"resource": ""
} |
q7488 | TimeFinder.stop | train | @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);
}
} | java | {
"resource": ""
} |
q7489 | DeckReference.getDeckReference | train | 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;
} | java | {
"resource": ""
} |
q7490 | VirtualCdj.setDeviceName | train | 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);
} | java | {
"resource": ""
} |
q7491 | VirtualCdj.setTempoMaster | train | 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);
}
} | java | {
"resource": ""
} |
q7492 | VirtualCdj.setMasterTempo | train | 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);
}
} | java | {
"resource": ""
} |
q7493 | VirtualCdj.processUpdate | train | 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);
} | java | {
"resource": ""
} |
q7494 | VirtualCdj.processBeat | train | void processBeat(Beat beat) {
if (isRunning() && beat.isTempoMaster()) {
setMasterTempo(beat.getEffectiveTempo());
deliverBeatAnnouncement(beat);
}
} | java | {
"resource": ""
} |
q7495 | VirtualCdj.findMatchingAddress | train | 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;
} | java | {
"resource": ""
} |
q7496 | VirtualCdj.findUnreachablePlayers | train | 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);
} | java | {
"resource": ""
} |
q7497 | VirtualCdj.stop | train | 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);
}
} | java | {
"resource": ""
} |
q7498 | VirtualCdj.sendAnnouncement | train | 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();
}
} | java | {
"resource": ""
} |
q7499 | VirtualCdj.deliverMasterChangedAnnouncement | train | 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);
}
}
} | java | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.