piccolo aiuto con java

[asdf]

Ciao.
Volevo crearmi un programmino java che mi avviasse tutti i programmi necessari a convertirmi un file .mpg in un .avi, prendendo spunto da quello che fa GordianKnot (che purtroppo non mi funziona piu' dopo che ho installato l'ultima versione di divx).
Riesco a fare tutti i passaggi, l''unico problema e' che mi si accavallano i vari processi, e per ora l'unica soluzione che ho trovato e' stata quella di far comparire una finestra con un pulsante di ok per segnalare quando il processo precedente ha terminato, ma ovviamente questa soluzione e' molto scomoda.

Ho anche provato a fare un .bat, ma li avevo dei problemi a creare alcuni script dove dovevo sostituire le \ con \\.

Ecco qui il codice che ho scritto finora (che richiede di avere nel path i programmi virtualdub, nandub, dgindex e besweet (quest'ultimo voglio vedere se posso sostituirlo con lame mt, cosi' mi sfrutta il multicore)):

import java.io.BufferedWriter;
import java.io.FileWriter;

import javax.swing.JOptionPane;

/**
* @author Emanuele
*
*/
public class MpgConverter {

/**
* @param args
*/
public static void main(String[] args) {

String fileName=args[0].substring(0,args[0].lastIndexOf("."));
Runtime rt = Runtime.getRuntime();
Process proc;
BufferedWriter myOutput;


try{

//mpg --> d2v & mpa
proc = rt.exec("dgindex -IF=["+fileName+".mpg] -OF=["+fileName+"] -EXIT");
JOptionPane.showMessageDialog(null, "Clicca qui quando il parsing del file mpg è finito", "alert", JOptionPane.INFORMATION_MESSAGE);

//d2v --> avs
String avsScript="LoadPlugin(\"C:\\PROGRA~1\\GORDIA~1\\DGMPGDec\\DGDecode.dll\")\nmpeg2source(\""+fileName+".d2v\")\nFieldDeinterlace()\nBilinearResize(544,392)";
myOutput = new BufferedWriter(new FileWriter(fileName+".avs"));
myOutput.write(avsScript);
myOutput.close();

//mpa --> mp3
//JOptionPane.showMessageDialog(null, "besweet -core( -input \""+fileName+" T01 DELAY 0ms.mpa\" -output \""+fileName+".mp3\" ) -ota( -hybridgain ) -azid( -c normal ) -lame( -h --cbr -b 128 )", "alert", JOptionPane.INFORMATION_MESSAGE);
//myOutput = new BufferedWriter(new FileWriter("prova.txt"));
//myOutput.write("besweet -core( -input \""+fileName+" T01 DELAY 0ms.mpa\" -output \""+fileName+".mp3\" ) -ota( -hybridgain ) -azid( -c normal ) -lame( -h --cbr -b 128 )");
//myOutput.close();
proc = rt.exec("besweet -core( -input \""+fileName+" T01 DELAY 0ms.mpa\" -output \""+fileName+".mp3\" ) -ota( -hybridgain ) -azid( -c normal ) -lame( -h --cbr -b 128 )");

//avs --> avi

//chiedo conferma per lo svuotamento della lista dei job
//if(JOptionPane.showConfirmDialog(null,"Vuoi svuotare la lista dei job?", "Vuoi svuotare la lista dei job?", JOptionPane.YES_NO_OPTION)==0) {
// proc = rt.exec("virtualdub /c /x");
// Thread.currentThread().sleep(1000);
//}

//accodo un job per ogni passo
Thread.currentThread().sleep(1000);
proc = rt.exec("virtualdub /s 1p.vcf /p \""+fileName+".avs\" \""+fileName+"_movie.avi\" /x");
Thread.currentThread().sleep(1000);
proc = rt.exec("virtualdub /s 2p.vcf /p \""+fileName+".avs\" \""+fileName+"_movie.avi\" /x");
Thread.currentThread().sleep(1000);

//chiedo conferma per la conversione immediata
if(JOptionPane.showConfirmDialog(null,"Vuoi avviare ora la conversione?", "Vuoi avviare ora la conversione?", JOptionPane.YES_NO_OPTION)==0){
proc = rt.exec("virtualdub /r /x");

JOptionPane.showMessageDialog(null, "Clicca qui quando la conversione è terminata", "alert", JOptionPane.INFORMATION_MESSAGE);

//unione avi/mp3
String fileNameWithDoubleSlash=fileName.replace("\\","\\\\");
String audioJoinScript="VirtualDub.Open(\""+fileNameWithDoubleSlash+"_movie.avi\",0,0);\nVirtualDub.audio.SetSource(\""+fileNameWithDoubleSlash+".mp3\");\nVirtualDub.video.SetMode(0);\nVirtualDub.SaveAVI(\""+fileNameWithDoubleSlash+".avi\");\nVirtualDub.Close();";
myOutput = new BufferedWriter(new FileWriter(fileName+"-audioJoin.vcf"));
myOutput.write(audioJoinScript);
myOutput.close();
proc = rt.exec("nandub /s\""+fileName+"-audioJoin.vcf\"");

}


}
catch (Exception e){e.printStackTrace();}

}

}



Grazie in anticipo per l'aiuto

[asdf]

Forse ho trovato la soluzione (la provo stasera a casa): dovrebbe bastare l'uso dell'istruzione proc.waitFor(); dopo l'exec.

Confermate?
Grazie.

[ally]

...potresti associare un readLine ad ogni porocesso in attesa del comando di chiusura dell'applicativo richiamato da riga di comando...così avresti la certezza di eseguire l'operazione successiva nel solo caso in cui tutto si stia svolgendo correttamente...

...ciao...

[lovaz]

Forse ho trovato la soluzione (la provo stasera a casa): dovrebbe bastare l'uso dell'istruzione proc.waitFor(); dopo l'exec.

Confermate?
Grazie.
Confermo.
Oppure puoi leggere stdout e stderr di ogni programma,
in questo modo dovrebbe aspettare la terminazione prima di proseguire.

[asdf]

Grazie per l'aiuto.
Sono riuscito a risolvere il problema con proc.waitFor(), eccetto che col programme besweet che ho dovuto utilizzare assieme ad una classe che avevo scaricato qualche mese fa (si chiama StreamGobbler) e che utilizza i metodi stdout e stderr che mi ha consigliato lovaz.

Ho pero' altro quesito da porvi:
ho realizzanto anche un'interfaccia grafica con una coda delle conversioni da fare, e mi piacerebbe fare in modo che se c'e' gia' un'istanza del programma in esecuzione all'apertura di un nuovo file (ad esempio da linea di comando) non mi venga avviata una nuova istanza del programma ma che il nuovo file da convertire venga accodato alla coda di quello gia' aperto.
In parole povere voglio impedire che ci siano istanze multiple del programma.
E' possibile realizzarlo? Se si come si fa?

Grazie

[ally]

...StreamGobbler è un package?...potresti gentilmente postare la soluzione a cui sei arrivato?...

...ciao...

[asdf]

Il sorgente di StreamGobbler e':

import java.io.*;

/**
* Stampa nel terminale uno stream di dati utilizzando un thread separato da quello del programma principale.<br>
* Usato per catturare l'output di javac (sia l'InputStream che l'ErrorStream) evitando il blocco del programma in caso di errori di compilazione.
*/
public class StreamGobbler extends Thread
{
InputStream is;
String prefix;

public StreamGobbler(InputStream is)
{
this.is = is;
}

public void run()
{
try
{
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line=null;
while ( (line = br.readLine()) != null)
System.out.println(line);
} catch (IOException ioe)
{
ioe.printStackTrace();
}
}
}


Il sorgente del programma e' (per ora, visto che voglio aggiungere un po' di opzioni) (ps, ho usato eclipse per l'interfaccia, i miei metodi sono gli ultimi due):

import java.awt.Event;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.swing.DefaultListModel;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JList;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.KeyStroke;

/**
*
*/

/**
* @author Emanuele
*
*/
public class MpgConverter extends JFrame implements Runnable {
private static boolean isConverting=false;
private static MpgConverter interfaccia;
private Thread conversionThread=null;
final JFileChooser fc = new JFileChooser();
private DefaultListModel operationsListModel= new DefaultListModel();
private DefaultListModel waitingFilesListModel= new DefaultListModel();
private static SimpleDateFormat dateFormatter=new SimpleDateFormat("HH:mm:ss");

private JMenuBar jJMenuBar = null;

private JMenu fileMenu = null;

private JMenu editMenu = null;

private JMenu helpMenu = null;

private JMenuItem exitMenuItem = null;

private JMenuItem aboutMenuItem = null;

private JMenuItem cutMenuItem = null;

private JMenuItem copyMenuItem = null;

private JMenuItem pasteMenuItem = null;

private JMenuItem saveMenuItem = null;

private JScrollPane jScrollPane = null;

private JList operationsList = null;

private JList waitingFilesList = null;

private JSplitPane jSplitPane = null;

private JScrollPane jScrollPane1 = null;
/**
* This is the default constructor
*/
public MpgConverter() {
super();
initialize();
}

/**
* This method initializes this
*
* @return void
*/
private void initialize() {
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setContentPane(getJSplitPane());
this.setJMenuBar(getJJMenuBar());
this.setSize(750, 500);
this.setTitle("MpgConverter");
}

/**
* This method initializes jJMenuBar
*
* @return javax.swing.JMenuBar
*/
private JMenuBar getJJMenuBar() {
if (jJMenuBar == null) {
jJMenuBar = new JMenuBar();
jJMenuBar.add(getFileMenu());
jJMenuBar.add(getEditMenu());
jJMenuBar.add(getHelpMenu());
}
return jJMenuBar;
}

/**
* This method initializes jMenu
*
* @return javax.swing.JMenu
*/
private JMenu getFileMenu() {
if (fileMenu == null) {
fileMenu = new JMenu();
fileMenu.setText("File");
fileMenu.add(getOpenMenuItem());
fileMenu.add(getExitMenuItem());
}
return fileMenu;
}

/**
* This method initializes jMenu
*
* @return javax.swing.JMenu
*/
private JMenu getEditMenu() {
if (editMenu == null) {
editMenu = new JMenu();
editMenu.setText("Edit");
editMenu.add(getCutMenuItem());
editMenu.add(getCopyMenuItem());
editMenu.add(getPasteMenuItem());
}
return editMenu;
}

/**
* This method initializes jMenu
*
* @return javax.swing.JMenu
*/
private JMenu getHelpMenu() {
if (helpMenu == null) {
helpMenu = new JMenu();
helpMenu.setText("Help");
helpMenu.add(getAboutMenuItem());
}
return helpMenu;
}

/**
* This method initializes jMenuItem
*
* @return javax.swing.JMenuItem
*/
private JMenuItem getExitMenuItem() {
if (exitMenuItem == null) {
exitMenuItem = new JMenuItem();
exitMenuItem.setText("Exit");
exitMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.exit(0);
}
});
}
return exitMenuItem;
}

/**
* This method initializes jMenuItem
*
* @return javax.swing.JMenuItem
*/
private JMenuItem getAboutMenuItem() {
if (aboutMenuItem == null) {
aboutMenuItem = new JMenuItem();
aboutMenuItem.setText("About");
aboutMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(interfaccia,
"Programma per convertire i file .mpg in .avi\n\n" +
"Necessita dei seguenti programmi:\nVirtualdub, Nandub, BeSweet, DGMPGDec\n(gli ultimi due li avete già se avete installato GordianKnot)\n\n" +
"Questi programmi devono essere inseriti nel PATH DI SISTEMA (vedi su google)\n\n" +
"Programma realizzato da Debenedetti Emanuele\n" +
"http://sanremo.too.it");
//new JDialog(MpgConverter.this, "About", true).add(aboutPanel).show();
}
});
}
return aboutMenuItem;
}

/**
* This method initializes jMenuItem
*
* @return javax.swing.JMenuItem
*/
private JMenuItem getCutMenuItem() {
if (cutMenuItem == null) {
cutMenuItem = new JMenuItem();
cutMenuItem.setText("Cut");
cutMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X,
Event.CTRL_MASK, true));
}
return cutMenuItem;
}

/**
* This method initializes jMenuItem
*
* @return javax.swing.JMenuItem
*/
private JMenuItem getCopyMenuItem() {
if (copyMenuItem == null) {
copyMenuItem = new JMenuItem();
copyMenuItem.setText("Copy");
copyMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,
Event.CTRL_MASK, true));
}
return copyMenuItem;
}

/**
* This method initializes jMenuItem
*
* @return javax.swing.JMenuItem
*/
private JMenuItem getPasteMenuItem() {
if (pasteMenuItem == null) {
pasteMenuItem = new JMenuItem();
pasteMenuItem.setText("Paste");
pasteMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V,
Event.CTRL_MASK, true));
}
return pasteMenuItem;
}

/**
* This method initializes jMenuItem
*
* @return javax.swing.JMenuItem
*/
private JMenuItem getOpenMenuItem() {
if (saveMenuItem == null) {
saveMenuItem = new JMenuItem();
saveMenuItem.setText("Open");
saveMenuItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,
Event.CTRL_MASK, true));
saveMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
openFile();
}
});
}
return saveMenuItem;
}

/**
* This method initializes jScrollPane
*
* @return javax.swing.JScrollPane
*/
private JScrollPane getJScrollPane() {
if (jScrollPane == null) {
jScrollPane = new JScrollPane();
jScrollPane.setViewportView(getOperationsList());
}
return jScrollPane;
}

/**
* This method initializes operationsList
*
* @return javax.swing.JList
*/
private JList getOperationsList() {
if (operationsList == null) {
operationsList = new JList(operationsListModel);
}
return operationsList;
}

/**
* This method initializes waitingFilesList
*
* @return javax.swing.JList
*/
private JList getWaitingFilesList() {
if (waitingFilesList == null) {
waitingFilesList = new JList(waitingFilesListModel);
}
return waitingFilesList;
}

/**
* This method initializes jSplitPane
*
* @return javax.swing.JSplitPane
*/
private JSplitPane getJSplitPane() {
if (jSplitPane == null) {
jSplitPane = new JSplitPane();
jSplitPane.setPreferredSize(new java.awt.Dimension(450,50));
jSplitPane.setDividerSize(5);
jSplitPane.setDividerLocation(245);
jSplitPane.setLeftComponent(getJScrollPane1());
jSplitPane.setRightComponent(getJScrollPane());
}
return jSplitPane;
}

/**
* This method initializes jScrollPane1
*
* @return javax.swing.JScrollPane
*/
private JScrollPane getJScrollPane1() {
if (jScrollPane1 == null) {
jScrollPane1 = new JScrollPane();
jScrollPane1.setViewportView(getWaitingFilesList());
}
return jScrollPane1;
}

/*****************************************************************/

/** Avvia l'applicazione */
public static void main(String[] args) {
interfaccia = new MpgConverter();
interfaccia.setVisible(true);

//se non ho avviato il programma da linea di comando
//o cliccando su un file a cui è associato
//mostro sulla shell il possibile uso del programma
if(args.length==0) {
System.out.println("Usage:\njava -jar MpgConverter.jar --> apre il programma\njava -jar MpgConverter.jar nomeFile1 ... nomeFileN --> apre il programma ed accoda automaticamente gli N files nella coda di conversione");
return;
}

//controllo che i files ricevuti come argomento siano effettivamente dei files mpg
//e che esistino veramente
for(String arg:args) checkAndEnqueueFile(arg);

//se almeno uno dei file ricevuti come argomento era valido
//e se non ci sono altre conversioni in corso
//avvio la conversione
if(!isConverting && interfaccia.waitingFilesListModel.getSize()>0){
interfaccia.conversionThread=new Thread(interfaccia); //conversionThread per la copia (implementato nel metodo run)
interfaccia.conversionThread.start(); //avvio il conversionThread
}
}

/*****************************************************************/

/**
* Mostra la finestra per scegliere un file da convertire,
* controlla se è un file valido
* ed infine ne avvia la conversione
*/
private void openFile(){
ExampleFileFilter filter = new ExampleFileFilter();
filter.addExtension("mpg");
filter.addExtension("mpeg");
filter.setDescription("Mpg & Mpeg");
fc.setFileFilter(filter);

fc.setAcceptAllFileFilterUsed(false);

int returnVal = fc.showOpenDialog(interfaccia);
if (returnVal == JFileChooser.APPROVE_OPTION) {

//controllo che il file segnalato dall'utente sia effettivamente
//un file .mpg e che esisti veramente
checkAndEnqueueFile(fc.getSelectedFile().toString());

//se il file era valido e se non ci sono altre conversioni in corso
//avvio la conversione
if(!isConverting && interfaccia.waitingFilesListModel.getSize()>0){
interfaccia.conversionThread=new Thread(interfaccia); //conversionThread per la copia (implementato nel metodo run)
interfaccia.conversionThread.start(); //avvio il conversionThread
}
}
}

/*****************************************************************/

/**
* Controlla che un file che l'utente vuole convertire sia un file mpg
* ed esista veramente: se così è accoda il file nella coda dei files da convertire
*/
private static boolean checkAndEnqueueFile(String fileName){

//controllo l'estensione
int lastPointIndex=fileName.lastIndexOf(".");
if(lastPointIndex>-1 && !fileName.substring(lastPointIndex).equalsIgnoreCase(".mpg") && !fileName.substring(lastPointIndex).equalsIgnoreCase(".mpeg")) {
showError("Puoi convertire solo files con estensione .mpg o .mpeg");
return false;
}

//verifico l'effettiva esistenza del file
if(!new File(fileName).exists()) {
showError("Il file indicato non esisite");
return false;
}

//accodo il file alla coda delle conversioni
interfaccia.waitingFilesListModel.addElement(fileName);
return true;

}

/*****************************************************************/

/** Aggiunge un titolo alla board delle informazioni */
private static void addMessageToBoard(String message){
interfaccia.operationsListModel.addElement(getTime()+" - "+message);
interfaccia.operationsList.setSelectedIndex(interfaccia.operationsListModel.getSize()-1);
interfaccia.operationsList.ensureIndexIsVisible(interfaccia.operationsListModel.getSize()-1);
}

/*****************************************************************/

/** Aggiunge un titolo alla board delle informazioni come titolo */
private static void addMessageToBoardAsTitle(String message){
interfaccia.operationsListModel.addElement("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
interfaccia.operationsListModel.addElement(getTime()+" - "+message);
interfaccia.operationsListModel.addElement("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
interfaccia.operationsList.setSelectedIndex(interfaccia.operationsListModel.getSize()-2);
interfaccia.operationsList.ensureIndexIsVisible(interfaccia.operationsListModel.getSize()-1);
}

/*****************************************************************/

/** Aggiunge un titolo alla board delle informazioni */
private static void addMessageToBoardAsError(String message){
interfaccia.operationsListModel.addElement("\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/");
interfaccia.operationsListModel.addElement(getTime()+" - "+message);
interfaccia.operationsListModel.addElement("\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/|\\|/");
interfaccia.operationsList.setSelectedIndex(interfaccia.operationsListModel.getSize()-2);
interfaccia.operationsList.ensureIndexIsVisible(interfaccia.operationsListModel.getSize()-1);
}

/*****************************************************************/

/** Segnala che è avvenuto un errore */
private static void showError(String errorString){

//stampo l'errore nella board delle informazioni
addMessageToBoardAsError(errorString);

//avvio un suono di errore
interfaccia.playSound("audio3.wav");

//mostro una dialog che segnala l'errore
JOptionPane.showMessageDialog(interfaccia, errorString, "Errore", JOptionPane.ERROR_MESSAGE);

//fermo per un secondo il thread in attesa che termini il file audio
try{Thread.sleep(1000);}catch(Exception e){e.printStackTrace();}
}

/*****************************************************************/

/** Torna l'ora corrente */
private static String getTime(){
//endDate=new Date();
//end=endDate.getTime();
//SimpleDateFormat dateFormatter=new SimpleDateFormat("mm:ss:SSS");
//System.out.println("COMPILATION COMPLETED WITH SUCCESS (in "+dateFormatter.format(new Date(end-start))+")");

return dateFormatter.format(new Date());

}

/*****************************************************************/

/** Esegue il suono passato come parametro */
private void playSound(String fileName){
try{
//recupero il file audio dal jar file e lo eseguo
ClassLoader jarFile=getClass().getClassLoader();
AudioInputStream ais=AudioSystem.getAudioInputStream(jarFile.getResourceAsStream(fileName));
DataLine.Info info = new DataLine.Info(Clip.class, ais.getFormat(), ((int) ais.getFrameLength() * 2));
Clip ol = (Clip) AudioSystem.getLine(info);
ol.open(ais); //APRE l'input stream
ol.loop(0);
}
catch (Exception e){e.printStackTrace();}
}

/*****************************************************************/

/** Thread che si occupa della conversione (necessario per impedire il blocco totale dell'interfaccia durante la conversione) */
public void run() {
//converto i vari files presenti nella lista
isConverting=true;
while(interfaccia.waitingFilesListModel.getSize()>0){
interfaccia.waitingFilesList.ensureIndexIsVisible(0);
convertFile(""+interfaccia.waitingFilesListModel.getElementAt(0));
interfaccia.waitingFilesListModel.removeElementAt(0);
}
isConverting=false;

//segnalo con un suono che sono terminate le conversioni
interfaccia.playSound("audio2.wav");

//mostro una dialog che informa che sono terminate le conversioni
JOptionPane.showMessageDialog(interfaccia, "Tutte le conversioni accodate sono terminate", "Conversioni terminate", JOptionPane.INFORMATION_MESSAGE);

}

/*****************************************************************/

/** Esegue tutte le operazioni necessarie a convertire un file */
private static void convertFile(String fileNameOrig){
interfaccia.waitingFilesListModel.setElementAt(">>> "+fileNameOrig,0);
String fileName=fileNameOrig.substring(0,fileNameOrig.lastIndexOf("."));
Runtime rt = Runtime.getRuntime();
Process proc;
BufferedWriter myOutput;

//mostro messaggio nella board dei messaggi
addMessageToBoardAsTitle("Conversione del file \""+fileNameOrig+"\"");

try{

//mpg --> d2v & mpa
addMessageToBoard("Analisi del file mpg e creazione dei files .d2v e .mpa con DGIndex");
proc = rt.exec("dgindex -IF=["+fileName+".mpg] -OF=["+fileName+"] -EXIT");
proc.waitFor();
//addMessageToBoard("Fatto");

//mpa --> mp3
addMessageToBoard("Conversione .mpa --> .mp3 con BeSweet");
proc = rt.exec("besweet -core( -input \""+fileName+" T01 DELAY 0ms.mpa\" -output \""+fileName+".mp3\" ) -ota( -hybridgain ) -azid( -c normal ) -lame( -h --cbr -b 128 )");
StreamGobbler errorGobbler = new StreamGobbler(proc.getErrorStream());
StreamGobbler outputGobbler = new StreamGobbler(proc.getInputStream());
errorGobbler.start();
outputGobbler.start();
proc.waitFor();
//addMessageToBoard("Fatto");

//d2v --> avs
addMessageToBoard("Creazione script .avs per il file .d2v");
//String avsScript="LoadPlugin(\"C:\\PROGRA~1\\GORDIA~1\\DGMPGDec\\DGDecode.dll\")\nmpeg2source(\""+fileName+".d2v\")\nFieldDeinterlace()\nBilinearResize(544,392)";
String avsScript="LoadPlugin(\"DGDecode.dll\")\nmpeg2source(\""+fileName+".d2v\")\nFieldDeinterlace()\nBilinearResize(544,392)";
myOutput = new BufferedWriter(new FileWriter(fileName+".avs"));
myOutput.write(avsScript);
myOutput.close();
//addMessageToBoard("Fatto");

//avs --> avi

//chiedo conferma per lo svuotamento della lista dei job
//if(JOptionPane.showConfirmDialog(null,"Vuoi svuotare la lista dei job?", "Vuoi svuotare la lista dei job?", JOptionPane.YES_NO_OPTION)==0) {
// proc = rt.exec("virtualdub /c /x");
// Thread.currentThread().sleep(1000);
//}

//accodo un job per ogni passo
addMessageToBoard("Esecuzione 1° passo con Virtualdub (basandosi sul file 1p.vcf)");
proc = rt.exec("virtualdub /s 1p.vcf /p \""+fileName+".avs\" \""+fileName+"_movie.avi\" /x");
proc.waitFor();
proc = rt.exec("virtualdub /r /x");
proc.waitFor();
//addMessageToBoard("Fatto");

addMessageToBoard("Esecuzione 2° passo con Virtualdub (basandosi sul file 2p.vcf)");
proc = rt.exec("virtualdub /s 2p.vcf /p \""+fileName+".avs\" \""+fileName+"_movie.avi\" /x");
proc.waitFor();
proc = rt.exec("virtualdub /r /x");
proc.waitFor();
//addMessageToBoard("Fatto");

//unione avi/mp3
addMessageToBoard("Unione .avi e .mp3");
String fileNameWithDoubleSlash=fileName.replace("\\","\\\\");
String audioJoinScript="VirtualDub.Open(\""+fileNameWithDoubleSlash+"_movie.avi\",0,0);\nVirtualDub.audio.SetSource(\""+fileNameWithDoubleSlash+".mp3\");\nVirtualDub.video.SetMode(0);\nVirtualDub.SaveAVI(\""+fileNameWithDoubleSlash+".avi\");\nVirtualDub.Close();";
myOutput = new BufferedWriter(new FileWriter(fileName+"-audioJoin.vcf"));
myOutput.write(audioJoinScript);
myOutput.close();
proc = rt.exec("nandub /s\""+fileName+"-audioJoin.vcf\" /x");
proc.waitFor();
//addMessageToBoard("Fatto");



//chiedo conferma per la cancellazione dei files temporanei
addMessageToBoard("Cancellazione files temporanei");
new File(fileName+".d2v").delete();
new File(fileName+" T01 DELAY 0ms.mpa").delete();
new File(fileName+".mp3").delete();
new File(fileName+".avs").delete();
new File(fileName+"_movie.avi").delete();
new File(fileName+"-audioJoin.vcf").delete();
//addMessageToBoard("Fatto");

addMessageToBoardAsTitle("Conversione del file \""+fileNameOrig+"\" terminata");

//eseguo suono per segnalare la fine di una delle conversioni della coda
interfaccia.playSound("audio1.wav");
Thread.sleep(1000);

}
catch (Exception e){e.printStackTrace();}

}

} // @jve:decl-index=0:visual-constraint="7,3"



Gia che ci sono: ogni tanto non si aggiorna bene l'interfaccia: da cosa puo' dipendere?

Grazie (ps, ora devo andare, quindi posso rispondere solo domani)

[asdf]

Nessuno sa come evitare le istanze multiple di un programma java (come ho descritto due post fa)?

PS. Ho aggiornato il codice che avevo inserito ieri perche' era scritto un po' alla cavolo, ed inoltre c'ho aggiunto nuove feature (file audio, apertura file da interfaccia, thread per evitare il blocco dell'interfaccia, etc.)

Ciao

[ally]

...potresti creare una classe specifica per questa operazione ed in base a cio' che restituisci decidi o meno se avanzare l'elaborazione...



public class TrackConverter {

private Process prc;
private Thread stdoutThread;
private boolean wait;
private boolean trackAcquired;

public boolean getTrack() throws Exception{

trackAcquired = false;
wait = true;

try {
String exec = "programma ...";
System.out.println(exec);
prc = Runtime.getRuntime().exec(exec);
InputStream is = prc.getErrorStream();
final BufferedReader stdout = new BufferedReader(new InputStreamReader(is));
stdoutThread = new Thread() {
public void run() {
stdoutThread.setPriority(Thread.MIN_PRIORITY);
int l;
String line;
try {
for (l = 0; (line = stdout.readLine()) != null;)
{
if (line.length() > 0)
{
l++;
}
if (line.indexOf("successfully")>-1)
{
System.out.println("ok");
trackAcquired = true;
}
if (line.indexOf("incorrect")>-1)
{
System.out.println("errore");
}
}
stdout.close();
wait=false;
} catch (IOException ie) {}
}
};
stdoutThread.start();
stdoutThread.setPriority(Thread.MIN_PRIORITY);
}catch(Exception e){
System.out.println("error " +e);
}

while(wait)
try {
Thread.sleep(200);
} catch (InterruptedException e) {

}

if(!trackAcquired)
{
Exception e = new Exception();
throw e;
}

return trackAcquired;

}
}


...ciao...

[lovaz]

Nessuno sa come evitare le istanze multiple di un programma java (come ho descritto due post fa)?
Al momento mi vengono in mente un paio di soluzioni:
1. creare un file di lock all'avvio del programma, in modo che le seguenti invocazioni,
trovando il file di lock, riconoscano che c'e' un'altra istanza che sta girando, ma in
questo caso avrai il problema di comunicare all'istanza che sta girando
il nome del file da processare;
2. fare un programma server - io lo farei con RMI, ma non dovrebbe essere molto piu'
difficile con i socket - con cui le seguenti invocazioni comunicano al server i nuovi
file da processare; se la connessione al server fallisce si lancia il server.

Forse la seconda idea e' un po' eccessiva :D

In ogni caso attenzione alla concorrenza!

[asdf]

Grazie mille per le risposte.
Ci darò un'occhiata la prossima settimana.

Ciao

[TempestaT400]

basta semplicemente usare il pattern Singleton per la programmazione.!.
Se non hai mai programmato usando i pattern ti posto una classe esempio senza utilizzare scappatoie tipo file o cose del genere.

Naturalmente ti posto una linea guida!


public class Test {
private static Test instance;

private Test(){
...
}

public static Test getInstance(){
if(istance == null)
instance = new Test();
return istance;
}

}


cmq c'è anche una versione di Singleton per il multithread!

[lovaz]

Sì, ma qui si tratta di due jvm diverse...

[TempestaT400]

Mi sembra di aver letto se c'era un modo per risolvere le istanza multiple in un programma java!
Se si usa il pattern Singleton come starter, è sicuro che l'istanza sarà solamente una!

[lovaz]

Ma le classi singleton sono una per virtual machine, quindi possono essere piu' di una.

Prova a modificare cosi' il codice che hai postato:

import java.util.Date;

public class Test {
private static Test instance;
private static Date d;

private Test()
{
d = new Date();
}

public static Test getInstance()
{
if(instance == null)
instance = new Test();
return instance;
}

public String toString()
{
return d.toString();
}

public static void main(String[] args)
throws Exception
{
System.out.println("Io sono l'oggetto creato il "
+ getInstance() );

Thread.sleep(20000);
}
}

e prova ad eseguirlo due volte, a distanza di qualche secondo, vedrai che le
date si discostano di qualche secondo, ovvero il costruttore e' stato chiamato piu'
di una volta!

[TempestaT400]

Ma, la JVM in esecuzione non è una sola!?!
cioè più JVM in esecuzione sullo stesso calcolatore è come dire che si hanno due sistemi operativi che vengono eseguiti allo stesso momento!
è logico che poi Singleton non funziona come dovrebbe!!!

[lovaz]

Ogni volta che esegui
java ...
avvii una virtual machine diversa.

[cionci]

Se ho capito bene...basterebbe un file di lock...

[TellaspallaBob]

Brevemente....

I singletone non funzionano in tali casi, semplicemente perchè avviare un programma java significa usare ISTANZE della VM diverse...

Il singletone serve per altro!!! Vedere il GOF, design pattern etc.

Per quanto riguarda il problema del ridisegno...
Le swing usano un thread per fare le operazioni di rendering dei componenti...
Se il tuo thread principale fa operazioni molto gravose, quello swing rimane al palo....
Un tipico esempio di questo è fare una ProgressBar che mostra lo stato di connessione di un'applicazione ad un URL e il suo read....
Sono operazioni bloccanti... Vedi la progress andare avanti solo quando in realtà tutti i luoop sono stati già eseguiti...

Soluzione??? Fare l'operazione bloccante in un Thread e monitorizzarlo mediante pattern Observer Observable.... in sostanza un listener!!!
;)

Ciao

[TempestaT400]

Ma il pattern Singleton è usato per assicurare una singola istanza di una classe!
Non pensavo ci fossero in gioco più istanze del programma...

il Gof design pattern...
Molto bello e fatto bene!

Lo sto usando per fare i progetti di ingegneria del software!