code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
@SuppressWarnings("SameParameterValue")
private byte[] readResponseWithExpectedSize(InputStream is, int size, String description) throws IOException {
byte[] result = receiveBytes(is);
if (result.length != size) {
logger.warn("Expected " + size + " bytes while reading " + description + " response, received " + result.length);
}
return result;
} | java |
private synchronized void closeIdleClients() {
List<Client> candidates = new LinkedList<Client>(openClients.values());
logger.debug("Scanning for idle clients; " + candidates.size() + " candidates.");
for (Client client : candidates) {
if ((useCounts.get(client) < 1) &&
((timestamps.get(client) + idleLimit.get() * 1000) <= System.currentTimeMillis())) {
logger.debug("Idle time reached for unused client {}", client);
closeClient(client);
}
}
} | java |
public synchronized void start() throws SocketException {
if (!isRunning()) {
DeviceFinder.getInstance().addLifecycleListener(lifecycleListener);
DeviceFinder.getInstance().addDeviceAnnouncementListener(announcementListener);
DeviceFinder.getInstance().start();
for (DeviceAnnouncement device: DeviceFinder.getInstance().getCurrentDevices()) {
requestPlayerDBServerPort(device);
}
new Thread(null, new Runnable() {
@Override
public void run() {
while (isRunning()) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
logger.warn("Interrupted sleeping to close idle dbserver clients");
}
closeIdleClients();
}
logger.info("Idle dbserver client closer shutting down.");
}
}, "Idle dbserver client closer").start();
running.set(true);
deliverLifecycleAnnouncement(logger, true);
}
} | java |
public synchronized void stop() {
if (isRunning()) {
running.set(false);
DeviceFinder.getInstance().removeDeviceAnnouncementListener(announcementListener);
dbServerPorts.clear();
for (Client client : openClients.values()) {
try {
client.close();
} catch (Exception e) {
logger.warn("Problem closing " + client + " when stopping", e);
}
}
openClients.clear();
useCounts.clear();
deliverLifecycleAnnouncement(logger, false);
}
} | java |
private SearchableItem buildSearchableItem(Message menuItem) {
return new SearchableItem((int) ((NumberField) menuItem.arguments.get(1)).getValue(),
((StringField) menuItem.arguments.get(3)).getValue());
} | java |
private ColorItem buildColorItem(Message menuItem) {
final int colorId = (int) ((NumberField) menuItem.arguments.get(1)).getValue();
final String label = ((StringField) menuItem.arguments.get(3)).getValue();
return buildColorItem(colorId, label);
} | java |
private ColorItem buildColorItem(int colorId, String label) {
Color color;
String colorName;
switch (colorId) {
case 0:
color = new Color(0, 0, 0, 0);
colorName = "No Color";
break;
case 1:
color = Color.PINK;
colorName = "Pink";
break;
case 2:
color = Color.RED;
colorName = "Red";
break;
case 3:
color = Color.ORANGE;
colorName = "Orange";
break;
case 4:
color = Color.YELLOW;
colorName = "Yellow";
break;
case 5:
color = Color.GREEN;
colorName = "Green";
break;
case 6:
color = Color.CYAN;
colorName = "Aqua";
break;
case 7:
color = Color.BLUE;
colorName = "Blue";
break;
case 8:
color = new Color(128, 0, 128);
colorName = "Purple";
break;
default:
color = new Color(0, 0, 0, 0);
colorName = "Unknown Color";
}
return new ColorItem(colorId, label, color, colorName);
} | java |
private void parseMetadataItem(Message item) {
switch (item.getMenuItemType()) {
case TRACK_TITLE:
title = ((StringField) item.arguments.get(3)).getValue();
artworkId = (int) ((NumberField) item.arguments.get(8)).getValue();
break;
case ARTIST:
artist = buildSearchableItem(item);
break;
case ORIGINAL_ARTIST:
originalArtist = buildSearchableItem(item);
break;
case REMIXER:
remixer = buildSearchableItem(item);
case ALBUM_TITLE:
album = buildSearchableItem(item);
break;
case LABEL:
label = buildSearchableItem(item);
break;
case DURATION:
duration = (int) ((NumberField) item.arguments.get(1)).getValue();
break;
case TEMPO:
tempo = (int) ((NumberField) item.arguments.get(1)).getValue();
break;
case COMMENT:
comment = ((StringField) item.arguments.get(3)).getValue();
break;
case KEY:
key = buildSearchableItem(item);
break;
case RATING:
rating = (int) ((NumberField)item.arguments.get(1)).getValue();
break;
case COLOR_NONE:
case COLOR_AQUA:
case COLOR_BLUE:
case COLOR_GREEN:
case COLOR_ORANGE:
case COLOR_PINK:
case COLOR_PURPLE:
case COLOR_RED:
case COLOR_YELLOW:
color = buildColorItem(item);
break;
case GENRE:
genre = buildSearchableItem(item);
break;
case DATE_ADDED:
dateAdded = ((StringField) item.arguments.get(3)).getValue();
break;
case YEAR:
year = (int) ((NumberField) item.arguments.get(1)).getValue();
break;
case BIT_RATE:
bitRate = (int) ((NumberField) item.arguments.get(1)).getValue();
break;
default:
logger.warn("Ignoring track metadata item with unknown type: {}", item);
}
} | java |
@SuppressWarnings("WeakerAccess")
public ByteBuffer getRawData() {
if (rawData != null) {
rawData.rewind();
return rawData.slice();
}
return null;
} | java |
private RekordboxAnlz.BeatGridTag findTag(RekordboxAnlz anlzFile) {
for (RekordboxAnlz.TaggedSection section : anlzFile.sections()) {
if (section.body() instanceof RekordboxAnlz.BeatGridTag) {
return (RekordboxAnlz.BeatGridTag) section.body();
}
}
throw new IllegalArgumentException("No beat grid found inside analysis file " + anlzFile);
} | java |
private int beatOffset(int beatNumber) {
if (beatCount == 0) {
throw new IllegalStateException("There are no beats in this beat grid.");
}
if (beatNumber < 1 || beatNumber > beatCount) {
throw new IndexOutOfBoundsException("beatNumber (" + beatNumber + ") must be between 1 and " + beatCount);
}
return beatNumber - 1;
} | java |
@SuppressWarnings("WeakerAccess")
public int findBeatAtTime(long milliseconds) {
int found = Arrays.binarySearch(timeWithinTrackValues, milliseconds);
if (found >= 0) { // An exact match, just change 0-based array index to 1-based beat number
return found + 1;
} else if (found == -1) { // We are before the first beat
return found;
} else { // We are after some beat, report its beat number
return -(found + 1);
}
} | java |
public List<Message> requestTrackMenuFrom(final SlotReference slotReference, final int sortOrder)
throws Exception {
ConnectionManager.ClientTask<List<Message>> task = new ConnectionManager.ClientTask<List<Message>>() {
@Override
public List<Message> useClient(Client client) throws Exception {
return MetadataFinder.getInstance().getFullTrackList(slotReference.slot, client, sortOrder);
}
};
return ConnectionManager.getInstance().invokeWithClientSession(slotReference.player, task, "requesting track menu");
} | java |
public List<Message> requestArtistMenuFrom(final SlotReference slotReference, final int sortOrder)
throws Exception {
ConnectionManager.ClientTask<List<Message>> task = new ConnectionManager.ClientTask<List<Message>>() {
@Override
public List<Message> useClient(Client client) throws Exception {
if (client.tryLockingForMenuOperations(MetadataFinder.MENU_TIMEOUT, TimeUnit.SECONDS)) {
try {
logger.debug("Requesting Artist menu.");
Message response = client.menuRequest(Message.KnownType.ARTIST_MENU_REQ, Message.MenuIdentifier.MAIN_MENU, slotReference.slot,
new NumberField(sortOrder));
return client.renderMenuItems(Message.MenuIdentifier.MAIN_MENU, slotReference.slot, CdjStatus.TrackType.REKORDBOX, response);
} finally {
client.unlockForMenuOperations();
}
} else {
throw new TimeoutException("Unable to lock player for menu operations.");
}
}
};
return ConnectionManager.getInstance().invokeWithClientSession(slotReference.player, task, "requesting artist menu");
} | java |
public List<Message> requestFolderMenuFrom(final SlotReference slotReference, final int sortOrder, final int folderId)
throws Exception {
ConnectionManager.ClientTask<List<Message>> task = new ConnectionManager.ClientTask<List<Message>>() {
@Override
public List<Message> useClient(Client client) throws Exception {
if (client.tryLockingForMenuOperations(MetadataFinder.MENU_TIMEOUT, TimeUnit.SECONDS)) {
try {
logger.debug("Requesting Key menu.");
Message response = client.menuRequestTyped(Message.KnownType.FOLDER_MENU_REQ, Message.MenuIdentifier.MAIN_MENU, slotReference.slot,
CdjStatus.TrackType.UNANALYZED, new NumberField(sortOrder), new NumberField(folderId), new NumberField(0xffffff));
return client.renderMenuItems(Message.MenuIdentifier.MAIN_MENU, slotReference.slot, CdjStatus.TrackType.UNANALYZED, response);
} finally {
client.unlockForMenuOperations();
}
} else {
throw new TimeoutException("Unable to lock player for menu operations.");
}
}
};
return ConnectionManager.getInstance().invokeWithClientSession(slotReference.player, task, "requesting folder menu");
} | java |
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 |
public void write(WritableByteChannel channel) throws IOException {
logger.debug("..writing> {}", this);
Util.writeFully(getBytes(), channel);
} | java |
@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 |
@SuppressWarnings("WeakerAccess")
public TrackMetadata requestMetadataFrom(final DataReference track, final CdjStatus.TrackType trackType) {
return requestMetadataInternal(track, trackType, false);
} | java |
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 |
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 |
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 |
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 |
private void clearDeck(CdjStatus update) {
if (hotCache.remove(DeckReference.getDeckReference(update.getDeviceNumber(), 0)) != null) {
deliverTrackMetadataUpdate(update.getDeviceNumber(), null);
}
} | java |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
private void removeMount(SlotReference slot) {
mediaDetails.remove(slot);
if (mediaMounts.remove(slot)) {
deliverMountUpdate(slot, false);
}
} | java |
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 |
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 |
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 |
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 |
public void removeMetadataProvider(MetadataProvider provider) {
for (Set<MetadataProvider> providers : metadataProviders.values()) {
providers.remove(provider);
}
} | java |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
public static void createMetadataCache(SlotReference slot, int playlistId, File cache) throws Exception {
createMetadataCache(slot, playlistId, cache, null);
} | java |
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 |
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 |
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 |
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 |
public synchronized void stop() {
if (isRunning()) {
socket.get().close();
socket.set(null);
deliverLifecycleAnnouncement(logger, false);
}
} | java |
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 |
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 |
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 |
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 |
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 |
public void write(WritableByteChannel channel) throws IOException {
logger.debug("Writing> {}", this);
for (Field field : fields) {
field.write(channel);
}
} | java |
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 |
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 |
private void clearDeckPreview(TrackMetadataUpdate update) {
if (previewHotCache.remove(DeckReference.getDeckReference(update.player, 0)) != null) {
deliverWaveformPreviewUpdate(update.player, null);
}
} | java |
private void clearDeckDetail(TrackMetadataUpdate update) {
if (detailHotCache.remove(DeckReference.getDeckReference(update.player, 0)) != null) {
deliverWaveformDetailUpdate(update.player, null);
}
} | java |
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 |
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 |
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 |
@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 |
@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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
@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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
private TrackSourceSlot findTrackSourceSlot() {
TrackSourceSlot result = TRACK_SOURCE_SLOT_MAP.get(packetBytes[41]);
if (result == null) {
return TrackSourceSlot.UNKNOWN;
}
return result;
} | java |
private TrackType findTrackType() {
TrackType result = TRACK_TYPE_MAP.get(packetBytes[42]);
if (result == null) {
return TrackType.UNKNOWN;
}
return result;
} | java |
private PlayState1 findPlayState1() {
PlayState1 result = PLAY_STATE_1_MAP.get(packetBytes[123]);
if (result == null) {
return PlayState1.UNKNOWN;
}
return result;
} | java |
private PlayState3 findPlayState3() {
PlayState3 result = PLAY_STATE_3_MAP.get(packetBytes[157]);
if (result == null) {
return PlayState3.UNKNOWN;
}
return result;
} | java |
@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 |
@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 |
private void clearDeck(TrackMetadataUpdate update) {
if (hotCache.remove(DeckReference.getDeckReference(update.player, 0)) != null) {
deliverBeatGridUpdate(update.player, null);
}
} | java |
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 |
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 |
@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 |
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 |
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 |
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 |
@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 |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.