@Override
public void update() {
if (!transmitting) {
super.update();
ArrayList deadMonsters = new ArrayList();
Monster monster = null;
try {
for (String key : monsters.keySet()) {
monster = (Monster) monsters.get(key);
if (monster != null) {
monster.update();
if (monster.getIsDead()) {
deadMonsters.add(key);
}
}
}
if (deadMonsters.size() > 0) {
for (int i = 0; i < deadMonsters.size(); i++) {
// EIError.debugMsg((String) deadMonsters.get(i));
monsters.remove((String) deadMonsters.get(i));
}
}
} catch (ConcurrentModificationException concEx) {
// another thread was trying to modify monsters while iterating
// we'll continue and the new item can be grabbed on the next update
}
}
}
@Override
public void setTransient(Registry rg) {
super.setTransient(rg);
spawnCoolDowns = new HashMap<String, Integer>();
try {
for (String key : monsters.keySet()) {
Monster monster = (Monster) monsters.get(key);
monster.setTransient(rg, this);
}
} catch (ConcurrentModificationException concEx) {
// another thread was trying to modify monsters while iterating
// we'll continue and the new item can be grabbed on the next update
}
}
/** Create the DataSink. */
DataSink createDataSink(Processor p, MediaLocator outML) {
DataSource ds;
if ((ds = p.getDataOutput()) == null) {
System.err.println(
"Something is really wrong: the processor does not have an output DataSource");
return null;
}
DataSink dsink;
try {
System.err.println("- Create DataSink for: " + outML);
dsink = Manager.createDataSink(ds, outML);
dsink.open();
} catch (Exception e) {
System.err.println("Cannot create the DataSink: " + e);
return null;
}
return dsink;
}
public void capture(String device) {
CaptureDeviceInfo deviceInfo = CaptureDeviceManager.getDevice(device);
System.out.println("-----------------------------------------------------------");
System.out.println("CaptureDevice Name is " + deviceInfo.getName());
System.out.println("-----------------------------------------------------------");
System.out.println("CaptureDevice is " + deviceInfo);
System.out.println("-----------------------------------------------------------");
Format[] formatsSupported = deviceInfo.getFormats();
System.out.println("Supports " + formatsSupported.length + " formats");
for (int findex = 0; findex < formatsSupported.length; findex++) {
System.out.println("Unique encoding name is " + formatsSupported[findex].getEncoding());
System.out.println("Format attributes are " + formatsSupported[findex]);
}
System.out.println("-----------------------------------------------------------");
System.out.println("Media Locator is " + deviceInfo.getLocator());
System.out.println("***********************************************************");
try {
player = Manager.createPlayer(deviceInfo.getLocator());
} catch (java.io.IOException e) {
System.out.println("IOException");
} catch (javax.media.NoPlayerException npe) {
System.out.println("NoPlayerException");
}
player.addControllerListener(this);
System.out.println("About to call start on player");
player.realize();
waitForState(player.Realized);
addVisualElements();
setVisible(true);
player.start();
System.out.println("Called start on player");
waitForState(player.Started);
System.out.println("Player started");
}
// Creates an RTP transmit data sink. This is the easiest way to create
// an RTP transmitter. The other way is to use the RTPSessionManager API.
// Using an RTP session manager gives you more control if you wish to
// fine tune your transmission and set other parameters.
private String createTransmitter() {
// Create a media locator for the RTP data sink.
// For example:
// rtp://129.130.131.132:42050/video
String rtpURL = "rtp://" + ipAddress + ":" + port + "/video";
MediaLocator outputLocator = new MediaLocator(rtpURL);
// Create a data sink, open it and start transmission. It will wait
// for the processor to start sending data. So we need to start the
// output data source of the processor. We also need to start the
// processor itself, which is done after this method returns.
try {
rtptransmitter = Manager.createDataSink(dataOutput, outputLocator);
rtptransmitter.open();
rtptransmitter.start();
dataOutput.start();
} catch (MediaException me) {
return "Couldn't create RTP data sink";
} catch (IOException ioe) {
return "Couldn't create RTP data sink";
}
return null;
}
public WebcamCaptureAndFadePanel(String saveDir, String layout) {
System.out.println("Using " + saveDir + " as directory for the images.");
saveDirectory = saveDir;
getImages();
images_used = new ArrayList<Integer>();
images_lastadded = new ArrayList<Integer>();
images_nevershown = new ArrayList<Integer>();
Vector devices = (Vector) CaptureDeviceManager.getDeviceList(null).clone();
Enumeration enumeration = devices.elements();
System.out.println("- Available cameras -");
ArrayList<String> names = new ArrayList<String>();
while (enumeration.hasMoreElements()) {
CaptureDeviceInfo cdi = (CaptureDeviceInfo) enumeration.nextElement();
String name = cdi.getName();
if (name.startsWith("vfw:")) {
names.add(name);
System.out.println(name);
}
}
// String str1 = "vfw:Logitech USB Video Camera:0";
// String str2 = "vfw:Microsoft WDM Image Capture (Win32):0";
if (names.size() == 0) {
JOptionPane.showMessageDialog(
null,
"Ingen kamera funnet. " + "Du må koble til et kamera for å kjøre programmet.",
"Feil",
JOptionPane.ERROR_MESSAGE);
System.exit(0);
} else if (names.size() > 1) {
JOptionPane.showMessageDialog(
null,
"Fant mer enn 1 kamera. " + "Velger da:\n" + names.get(0),
"Advarsel",
JOptionPane.WARNING_MESSAGE);
}
String str2 = names.get(0);
di = CaptureDeviceManager.getDevice(str2);
ml = di.getLocator();
try {
player = Manager.createRealizedPlayer(ml);
formatControl = (FormatControl) player.getControl("javax.media.control.FormatControl");
/*
Format[] formats = formatControl.getSupportedFormats();
for (int i=0; i<formats.length; i++)
System.out.println(formats[i].toString());
*/
player.start();
} catch (javax.media.NoPlayerException e) {
JOptionPane.showMessageDialog(
null,
"Klarer ikke å starte" + " programmet pga. feil med kamera. Sjekk at det er koblet til.",
"IOException",
JOptionPane.ERROR_MESSAGE);
System.exit(0);
} catch (Exception e) {
e.printStackTrace();
System.exit(0);
}
/*
* Layout
*
* Add
* - comp
* - imagepanels
*/
if (layout.equals("1024v2")) {
layout1024v2();
} else if (layout.equals("1280")) {
layout1280();
} else {
layout1024();
}
// Capture Window
if (captureWindow) {
cw = new JFrame("Capture from webcam");
cw.setAlwaysOnTop(true);
cw.setSize(sizeCaptureWindow_x, sizeCaptureWindow_y);
cw.addKeyListener(new captureWindowKeyListner());
cw.setUndecorated(true);
// Add webcam
if ((comp = player.getVisualComponent()) != null) {
cw.add(comp);
}
// Add panel to window and set location of window
cw.setLocation(cwLocation_x, cwLocation_y);
}
// Text window
cwText = new rotatedText("");
/*
* Timer for update
*/
Timer thread = new Timer();
thread.schedule(new frameUpdateTask(), 0, (1000 / fps));
}
/**
* Given an array of input media locators and an output locator, this method will concatenate the
* input media files to generate a single concatentated output.
*/
public boolean doIt(MediaLocator inML[], MediaLocator outML) {
// Guess the output content descriptor from the file extension.
ContentDescriptor cd;
if ((cd = fileExtToCD(outML.getRemainder())) == null) {
System.err.println("Couldn't figure out from the file extension the type of output needed!");
return false;
}
// Build the ProcInfo data structure for each processor.
ProcInfo pInfo[] = new ProcInfo[inML.length];
for (int i = 0; i < inML.length; i++) {
pInfo[i] = new ProcInfo();
pInfo[i].ml = inML[i];
try {
System.err.println("- Create processor for: " + inML[i]);
pInfo[i].p = Manager.createProcessor(inML[i]);
} catch (Exception e) {
System.err.println("Yikes! Cannot create a processor from the given url: " + e);
return false;
}
}
// Try to match the tracks from different processors.
if (!matchTracks(pInfo, cd)) {
System.err.println("Failed to match the tracks.");
return false;
}
// Program each processors to perform the necessary transcoding
// to concatenate the tracks.
if (!buildTracks(pInfo)) {
System.err.println("Failed to build processors for the inputs.");
return false;
}
// Generate a super glue data source from the processors.
SuperGlueDataSource ds = new SuperGlueDataSource(pInfo);
// Create the processor to generate the final output.
Processor p;
try {
p = Manager.createProcessor(ds);
} catch (Exception e) {
System.err.println("Failed to create a processor to concatenate the inputs.");
return false;
}
p.addControllerListener(this);
// Put the Processor into configured state.
if (!waitForState(p, Processor.Configured)) {
System.err.println("Failed to configure the processor.");
return false;
}
// Set the output content descriptor on the final processor.
System.err.println("- Set output content descriptor to: " + cd);
if ((p.setContentDescriptor(cd)) == null) {
System.err.println("Failed to set the output content descriptor on the processor.");
return false;
}
// We are done with programming the processor. Let's just
// realize it.
if (!waitForState(p, Controller.Realized)) {
System.err.println("Failed to realize the processor.");
return false;
}
// Now, we'll need to create a DataSink.
DataSink dsink;
if ((dsink = createDataSink(p, outML)) == null) {
System.err.println("Failed to create a DataSink for the given output MediaLocator: " + outML);
return false;
}
dsink.addDataSinkListener(this);
fileDone = false;
System.err.println("- Start concatenation...");
// OK, we can now start the actual concatenation.
try {
p.start();
dsink.start();
} catch (IOException e) {
System.err.println("IO error during concatenation");
return false;
}
// Wait for EndOfStream event.
waitForFileDone();
// Cleanup.
try {
dsink.close();
} catch (Exception e) {
}
p.removeControllerListener(this);
System.err.println(" ...done concatenation.");
return true;
}
private String createProcessor() {
if (locator == null) return "Locator is null";
DataSource ds;
DataSource clone;
try {
ds = Manager.createDataSource(locator);
} catch (Exception e) {
return "Couldn't create DataSource";
}
// Try to create a processor to handle the input media locator
try {
processor = Manager.createProcessor(ds);
} catch (NoProcessorException npe) {
return "Couldn't create processor";
} catch (IOException ioe) {
return "IOException creating processor";
}
// Wait for it to configure
boolean result = waitForState(processor, Processor.Configured);
if (result == false) return "Couldn't configure processor";
// Get the tracks from the processor
TrackControl[] tracks = processor.getTrackControls();
// Do we have atleast one track?
if (tracks == null || tracks.length < 1) return "Couldn't find tracks in processor";
boolean programmed = false;
// Search through the tracks for a video track
for (int i = 0; i < tracks.length; i++) {
Format format = tracks[i].getFormat();
if (tracks[i].isEnabled() && format instanceof VideoFormat && !programmed) {
// Found a video track. Try to program it to output JPEG/RTP
// Make sure the sizes are multiple of 8's.
Dimension size = ((VideoFormat) format).getSize();
float frameRate = ((VideoFormat) format).getFrameRate();
int w = (size.width % 8 == 0 ? size.width : (int) (size.width / 8) * 8);
int h = (size.height % 8 == 0 ? size.height : (int) (size.height / 8) * 8);
VideoFormat jpegFormat =
new VideoFormat(
VideoFormat.JPEG_RTP,
new Dimension(w, h),
Format.NOT_SPECIFIED,
Format.byteArray,
frameRate);
tracks[i].setFormat(jpegFormat);
System.err.println("Video transmitted as:");
System.err.println(" " + jpegFormat);
// Assume succesful
programmed = true;
} else tracks[i].setEnabled(false);
}
if (!programmed) return "Couldn't find video track";
// Set the output content descriptor to RAW_RTP
ContentDescriptor cd = new ContentDescriptor(ContentDescriptor.RAW_RTP);
processor.setContentDescriptor(cd);
// Realize the processor. This will internally create a flow
// graph and attempt to create an output datasource for JPEG/RTP
// video frames.
result = waitForState(processor, Controller.Realized);
if (result == false) return "Couldn't realize processor";
// Set the JPEG quality to .5.
setJPEGQuality(processor, 0.5f);
// Get the output data source of the processor
dataOutput = processor.getDataOutput();
return null;
}
