yetangitu/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2025-10-04 18:29:37 +02:00
Code Issues Releases Wiki Activity

GP-4516: Improvements

Browse source
This commit is contained in:
Ryan Kurtz 2024-05-02 12:41:22 -04:00
parent a10c00911a
commit 30600863cf
5 changed files with 75 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

86
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/MIDIDataType.java
View file

@ -4,9 +4,9 @@
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@ -15,16 +15,25 @@
*/
package ghidra.program.model.data;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import ghidra.docking.settings.Settings;
import ghidra.program.model.mem.MemBuffer;
import ghidra.program.model.mem.Memory;
import ghidra.util.Msg;
public class MIDIDataType extends BuiltIn implements Dynamic {
public static byte[] MAGIC =
new byte[] { (byte) 'M', (byte) 'T', (byte) 'h', (byte) 'd', (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 'M', (byte) 'T', (byte) 'r', (byte) 'k' };
public static byte[] MAGIC_MASK =
new byte[] { (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff };
public MIDIDataType() {
this(null);
}
@ -40,80 +49,43 @@ public class MIDIDataType extends BuiltIn implements Dynamic {
@Override
public int getLength(MemBuffer buf, int maxLength) {
try {
return computeLength(buf, maxLength);
}
catch (Exception e) {
Msg.debug(this, "Invalid MIDI data at " + buf.getAddress());
}
return -1;
}
private long readUnsignedInteger(InputStream stream) throws IOException {
long value = 0;
for (int index = 0; index < 4; index++) {
int currentByte = stream.read();
if (currentByte == -1) {
throw new EOFException();
}
value = (value << 8) | currentByte;
}
return value;
}
private int readUnsignedShort(InputStream stream) throws IOException {
int value = 0;
for (int index = 0; index < 2; index++) {
int currentByte = stream.read();
if (currentByte == -1) {
throw new EOFException();
}
value = (value << 8) | currentByte;
}
return value;
}
private int computeLength(MemBuffer buf, int maxLength) throws IOException, InvalidDataTypeException {
int computedLength = -1;
try (InputStream stream = buf.getInputStream(0, maxLength > 0 ? maxLength : Integer.MAX_VALUE)) {
try (DataInputStream stream = new DataInputStream(
buf.getInputStream(0, maxLength > 0 ? maxLength : Integer.MAX_VALUE))) {
byte[] chunkType = new byte[4];
if (stream.read(chunkType) < chunkType.length) {
throw new EOFException();
}
if (chunkType[0] != (byte)'M' ||
chunkType[1] != (byte)'T' ||
chunkType[2] != (byte)'h' ||
chunkType[3] != (byte)'d') {
if (chunkType[0] != (byte) 'M' || chunkType[1] != (byte) 'T' ||
chunkType[2] != (byte) 'h' || chunkType[3] != (byte) 'd') {
return -1;
}
long chunkLength = readUnsignedInteger(stream);
long chunkLength = Integer.toUnsignedLong(stream.readInt());
if (chunkLength != 6) {
throw new InvalidDataTypeException("Unexpected header length.");
}
stream.skip(2);
int tracks = readUnsignedShort(stream);
int tracks = Short.toUnsignedInt(stream.readShort());
stream.skip(2);
computedLength = 14;
int computedLength = 14;
while (tracks > 0) {
if (stream.read(chunkType) < chunkType.length) {
throw new EOFException();
}
chunkLength = readUnsignedInteger(stream);
chunkLength = Integer.toUnsignedLong(stream.readInt());
stream.skip(chunkLength);
computedLength += 8 + chunkLength;
if (chunkType[0] != (byte)'M' ||
chunkType[1] != (byte)'T' ||
chunkType[2] != (byte)'r' ||
chunkType[3] != (byte)'k') {
if (chunkType[0] != (byte) 'M' || chunkType[1] != (byte) 'T' ||
chunkType[2] != (byte) 'r' || chunkType[3] != (byte) 'k') {
continue;
}
tracks--;
}
} finally {
return computedLength;
}
catch (Exception e) {
Msg.debug(this, "Invalid MIDI data at " + buf.getAddress());
return -1;
}
return computedLength;
}
@Override

50
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/ScorePlayer.java
View file

@ -19,29 +19,24 @@ import java.awt.event.MouseEvent;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MetaEventListener;
import javax.sound.midi.MetaMessage;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;
import javax.sound.midi.*;
import javax.swing.Icon;
import generic.theme.GIcon;
import ghidra.util.Msg;
import ghidra.util.Swing;
/**
* Plays a MIDI score
*/
public class ScorePlayer implements Playable, MetaEventListener {
private static final Icon MIDI_ICON = new GIcon("icon.data.type.audio.player");
private static final int END_OF_TRACK_MESSAGE = 47;
private static final Icon AUDIO_ICON = new GIcon("icon.data.type.audio.player");
// This currently only allows one sequence to be played for the entire application,
// which seems good enough. The MIDI instance variables are currently synchronized
// by the Swing thread.
private static volatile Sequence currentSequence;
private static volatile Sequencer currentSequencer;
private byte[] bytes;
@ -52,30 +47,23 @@ public class ScorePlayer implements Playable, MetaEventListener {
@Override
public Icon getImageIcon() {
return AUDIO_ICON;
return MIDI_ICON;
}
@Override
public void clicked(MouseEvent event) {
try {
// any new request should stop any previous sequence being played
if (currentSequence != null && currentSequencer != null) {
assert currentSequencer.isOpen();
currentSequencer.stop();
currentSequence = null; // this field is also updated when the sound thread calls back
currentSequencer = null; // same as above
// Any new request should stop any previous sequence being played
if (currentSequencer != null) {
stop();
return;
}
Sequencer sequencer = MidiSystem.getSequencer(true);
sequencer.addMetaEventListener(this);
sequencer.setLoopCount(0);
Sequence sequence = MidiSystem.getSequence(new ByteArrayInputStream(bytes));
if (!sequencer.isOpen()) {
sequencer.open();
}
sequencer.setSequence(sequence);
currentSequence = sequence;
sequencer.setSequence(MidiSystem.getSequence(new ByteArrayInputStream(bytes)));
sequencer.open();
currentSequencer = sequencer;
currentSequencer.start();
}
@ -86,16 +74,18 @@ public class ScorePlayer implements Playable, MetaEventListener {
@Override
public void meta(MetaMessage message) {
if (message.getType() != END_OF_TRACK_MESSAGE) {
if (message.getType() == END_OF_TRACK_MESSAGE) {
Swing.runNow(() -> stop());
}
}
private void stop() {
if (currentSequencer == null) {
return;
}
assert currentSequencer != null && currentSequence != null;
currentSequencer.removeMetaEventListener(this);
currentSequencer.stop();
Swing.runNow(() -> {
currentSequence = null;
currentSequencer = null;
});
currentSequencer.close();
currentSequencer = null;
}
}