jsampler/task/Audio.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005-2006 Grigor Iliev <grigor@grigoriliev.com>
 *
 *   This file is part of JSampler.
 *
 *   JSampler is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   JSampler is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with JSampler; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 */

package org.jsampler.task;

import java.util.logging.Level;

import org.jsampler.AudioDeviceModel;
import org.jsampler.CC;
import org.jsampler.HF;
import org.jsampler.SamplerModel;

import org.linuxsampler.lscp.AudioOutputDevice;
import org.linuxsampler.lscp.AudioOutputDriver;
import org.linuxsampler.lscp.Parameter;

import static org.jsampler.JSI18n.i18n;


/**
 * Provides the audio specific tasks.
 * @author Grigor Iliev
 */
public class Audio {
        /** Forbits the instantiation of this class. */
        private Audio() { }

        /**
         * This task retrieves all audio output drivers currently
         * available for the LinuxSampler instance.
         */
        public static class GetDrivers extends EnhancedTask<AudioOutputDriver[]> {
                /** Creates a new instance of <code>GetDrivers</code>. */
                public
                GetDrivers() {
                        setTitle("Audio.GetDrivers_task");
                        setDescription(i18n.getMessage("Audio.GetDrivers.desc"));
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try { setResult(CC.getClient().getAudioOutputDrivers()); }
                        catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }
        
        /**
         * This task retrieves detailed information about all parameters
         * of the specified audio output driver.
         */
        public static class GetDriverParametersInfo extends EnhancedTask<Parameter[]> {
                private String driver;
                Parameter[] depList;
                
                /**
                 * Creates a new instance of <code>GetDriverParametersInfo</code>.
                 * @param depList - A dependences list.
                 */
                public
                GetDriverParametersInfo(String driver, Parameter... depList) {
                        setTitle("Audio.GetDriverParametersInfo_task");
                        setDescription(i18n.getMessage("Audio.GetDriverParametersInfo.desc"));
                        
                        this.driver = driver;
                        this.depList = depList;
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try {
                                AudioOutputDriver d;
                                d = CC.getClient().getAudioOutputDriverInfo(driver, depList);
                                setResult(d.getParameters());
                        }
                        catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }

        /**
         * This task creates a new audio output device.
         */
        public static class CreateDevice extends EnhancedTask<Integer> {
                private String driver;
                private Parameter[] parameters;
        
        
                /**
                 * Creates a new instance of <code>CreateDevice</code>.
                 * @param driver The desired audio output system.
                 * @param parameters An optional list of driver specific parameters.
                 */
                public
                CreateDevice(String driver, Parameter... parameters) {
                        setTitle("Audio.CreateDevice_task");
                        setDescription(i18n.getMessage("Audio.CreateDevice.desc"));
                
                        this.driver = driver;
                        this.parameters = parameters;
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try {
                                // TODO: move this to jlscp
                                java.util.Vector<Parameter> v = new java.util.Vector<Parameter>();
                                for(Parameter p : parameters) {
                                        if(p.getValue() != null) v.add(p);
                                }
                                parameters = v.toArray(new Parameter[v.size()]);
                                ///////
                                
                                Integer deviceId =
                                        CC.getClient().createAudioOutputDevice(driver, parameters);
                                setResult(deviceId);
                        } catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }
        
        /**
         * This task destroys the specified audio output device.
         */
        public static class DestroyDevice extends EnhancedTask {
                private int deviceId;
        
        
                /**
                 * Creates a new instance of <code>DestroyDevice</code>.
                 * @param deviceId The ID of the audio output device to be destroyed.
                 */
                public
                DestroyDevice(int deviceId) {
                        setTitle("Audio.DestroyDevice_task");
                        setDescription(i18n.getMessage("Audio.DestroyDevice.desc", deviceId));
                
                        this.deviceId = deviceId;
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try { CC.getClient().destroyAudioOutputDevice(deviceId); }
                        catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }
        
        /**
         * This task enables/disables a specific audio output device.
         */
        public static class EnableDevice extends EnhancedTask {
                private int dev;
                private boolean enable;
        
                /**
                 * Creates new instance of <code>EnableDevice</code>.
                 * @param dev The id of the device to be enabled/disabled.
                 * @param enable Specify <code>true</code> to enable the audio device;
                 * code>false</code> to disable it.
                 */
                public
                EnableDevice(int dev, boolean enable) {
                        setTitle("Audio.EnableDevice_task");
                        setDescription(i18n.getMessage("Audio.EnableDevice.desc", dev));
                
                        this.dev = dev;
                        this.enable = enable;
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try { 
                                CC.getClient().enableAudioOutputDevice(dev, enable);
                        
                                // Not needed, but eventually speeds up the change.
                                CC.getSamplerModel().getAudioDeviceById(dev).setActive(enable);
                        } catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }

        /**
         * This task alters a specific setting of an audio output device.
         */
        public static class SetDeviceParameter extends EnhancedTask {
                private int dev;
                private Parameter prm;
        
                /**
                 * Creates new instance of <code>SetDeviceParameter</code>.
                 * @param dev The id of the device whose parameter should be set.
                 * @param prm The parameter to be set.
                 */
                public
                SetDeviceParameter(int dev, Parameter prm) {
                        setTitle("Audio.SetDeviceParameter_task");
                        setDescription(i18n.getMessage("Audio.SetDeviceParameter.desc", dev));
                
                        this.dev = dev;
                        this.prm = prm;
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try { CC.getClient().setAudioOutputDeviceParameter(dev, prm); }
                        catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }

        /**
         * This task alters a specific setting of an audio output channel.
         */
        public static class SetChannelParameter extends EnhancedTask {
                private int dev;
                private int channel;
                private Parameter prm;
        
                /**
                 * Creates new instance of <code>SetChannelParameter</code>.
                 * @param dev The id of the device whose channel parameter should be set.
                 * @param channel The channel number.
                 * @param prm The parameter to be set.
                 */
                public
                SetChannelParameter(int dev, int channel, Parameter prm) {
                        setTitle("Audio.SetChannelParameter_task");
                        setDescription(i18n.getMessage("Audio.SetChannelParameter.desc"));
                
                        this.dev = dev;
                        this.channel = channel;
                        this.prm = prm;
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try { CC.getClient().setAudioOutputChannelParameter(dev, channel, prm); }
                        catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }
        
        /**
         * This task changes the channel number of the speicifed audio output device.
         */
        public static class SetChannelCount extends EnhancedTask {
                private int deviceId;
                private int channels;
        
                /**
                 * Creates new instance of <code>SetChannelCount</code>.
                 * @param deviceId The id of the device whose channels number will be changed.
                 * @param channels The new number of audio channels.
                 */
                public
                SetChannelCount(int deviceId, int channels) {
                        setTitle("SetAudioOutputChannelCount_task");
                        setDescription(i18n.getMessage("Audio.SetChannelCount.desc", deviceId));
                
                        this.deviceId = deviceId;
                        this.channels = channels;
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try { CC.getClient().setAudioOutputChannelCount(deviceId, channels); }
                        catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }


        /**
         * This task updates the setting of an audio output device.
         */
        public static class UpdateDeviceInfo extends EnhancedTask {
                private int dev;
                
                /**
                 * Creates new instance of <code>UpdateDeviceInfo</code>.
                 * @param dev The id of the device, which settings should be updated.
                 */
                public
                UpdateDeviceInfo(int dev) {
                        setTitle("Audio.UpdateDeviceInfo_task");
                        setDescription(i18n.getMessage("Audio.UpdateDeviceInfo.desc", dev));
                
                        this.dev = dev;
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try { 
                                AudioOutputDevice d = CC.getClient().getAudioOutputDeviceInfo(dev);
                                CC.getSamplerModel().getAudioDeviceById(dev).setDeviceInfo(d);
                        } catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }

        /**
         * This task updates the audio output device list.
         */
        public static class UpdateDevices extends EnhancedTask {
                /** Creates a new instance of <code>UpdateDevices</code>. */
                public
                UpdateDevices() {
                        setTitle("Audio.UpdateDevices_task");
                        setDescription(i18n.getMessage("Audio.UpdateDevices.desc"));
                }
        
                /** The entry point of the task. */
                public void
                run() {
                        try { 
                                SamplerModel sm = CC.getSamplerModel();
                                Integer[] devIDs = CC.getClient().getAudioOutputDeviceIDs();
                        
                                boolean found = false;
                                
                                for(AudioDeviceModel m : sm.getAudioDevices()) {
                                        for(int i = 0; i < devIDs.length; i++) {
                                                if(m.getDeviceId() == devIDs[i]) {
                                                        devIDs[i] = -1;
                                                        found = true;
                                                }
                                        }
                                
                                        if(!found) sm.removeAudioDeviceById(m.getDeviceId());
                                        found = false;
                                }
                        
                                AudioOutputDevice d;
                                
                                for(int id : devIDs) {
                                        if(id >= 0) {
                                                d = CC.getClient().getAudioOutputDeviceInfo(id);
                                                sm.addAudioDevice(d);
                                        }
                                }
                        } catch(Exception x) {
                                setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
                                CC.getLogger().log(Level.FINE, getErrorMessage(), x);
                        }
                }
        }

}
1	iliev	1144	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4			* Copyright (C) 2005-2006 Grigor Iliev <grigor@grigoriliev.com>
5			*
6			* This file is part of JSampler.
7			*
8			* JSampler is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License version 2
10			* as published by the Free Software Foundation.
11			*
12			* JSampler is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with JSampler; if not, write to the Free Software
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20			* MA 02111-1307 USA
21			*/
22
23			package org.jsampler.task;
24
25			import java.util.logging.Level;
26
27			import org.jsampler.AudioDeviceModel;
28			import org.jsampler.CC;
29			import org.jsampler.HF;
30			import org.jsampler.SamplerModel;
31
32			import org.linuxsampler.lscp.AudioOutputDevice;
33			import org.linuxsampler.lscp.AudioOutputDriver;
34			import org.linuxsampler.lscp.Parameter;
35
36			import static org.jsampler.JSI18n.i18n;
37
38
39			/**
40			* Provides the audio specific tasks.
41			* @author Grigor Iliev
42			*/
43			public class Audio {
44			/** Forbits the instantiation of this class. */
45			private Audio() { }
46
47			/**
48			* This task retrieves all audio output drivers currently
49			* available for the LinuxSampler instance.
50			*/
51			public static class GetDrivers extends EnhancedTask<AudioOutputDriver[]> {
52			/** Creates a new instance of <code>GetDrivers</code>. */
53			public
54			GetDrivers() {
55			setTitle("Audio.GetDrivers_task");
56			setDescription(i18n.getMessage("Audio.GetDrivers.desc"));
57			}
58
59			/** The entry point of the task. */
60			public void
61			run() {
62			try { setResult(CC.getClient().getAudioOutputDrivers()); }
63			catch(Exception x) {
64			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
65			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
66			}
67			}
68			}
69	iliev	1327
70			/**
71			* This task retrieves detailed information about all parameters
72			* of the specified audio output driver.
73			*/
74			public static class GetDriverParametersInfo extends EnhancedTask<Parameter[]> {
75			private String driver;
76			Parameter[] depList;
77
78			/**
79			* Creates a new instance of <code>GetDriverParametersInfo</code>.
80			* @param depList - A dependences list.
81			*/
82			public
83			GetDriverParametersInfo(String driver, Parameter... depList) {
84			setTitle("Audio.GetDriverParametersInfo_task");
85			setDescription(i18n.getMessage("Audio.GetDriverParametersInfo.desc"));
86
87			this.driver = driver;
88			this.depList = depList;
89			}
90
91			/** The entry point of the task. */
92			public void
93			run() {
94			try {
95			AudioOutputDriver d;
96			d = CC.getClient().getAudioOutputDriverInfo(driver, depList);
97			setResult(d.getParameters());
98			}
99			catch(Exception x) {
100			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
101			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
102			}
103			}
104			}
105	iliev	1144
106			/**
107			* This task creates a new audio output device.
108			*/
109			public static class CreateDevice extends EnhancedTask<Integer> {
110			private String driver;
111			private Parameter[] parameters;
112
113
114			/**
115			* Creates a new instance of <code>CreateDevice</code>.
116			* @param driver The desired audio output system.
117			* @param parameters An optional list of driver specific parameters.
118			*/
119			public
120			CreateDevice(String driver, Parameter... parameters) {
121			setTitle("Audio.CreateDevice_task");
122			setDescription(i18n.getMessage("Audio.CreateDevice.desc"));
123
124			this.driver = driver;
125			this.parameters = parameters;
126			}
127
128			/** The entry point of the task. */
129			public void
130			run() {
131			try {
132	iliev	1285	// TODO: move this to jlscp
133			java.util.Vector<Parameter> v = new java.util.Vector<Parameter>();
134			for(Parameter p : parameters) {
135			if(p.getValue() != null) v.add(p);
136			}
137			parameters = v.toArray(new Parameter[v.size()]);
138			///////
139
140	iliev	1144	Integer deviceId =
141			CC.getClient().createAudioOutputDevice(driver, parameters);
142			setResult(deviceId);
143			} catch(Exception x) {
144			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
145			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
146			}
147			}
148			}
149
150			/**
151			* This task destroys the specified audio output device.
152			*/
153			public static class DestroyDevice extends EnhancedTask {
154			private int deviceId;
155
156
157			/**
158			* Creates a new instance of <code>DestroyDevice</code>.
159			* @param deviceId The ID of the audio output device to be destroyed.
160			*/
161			public
162			DestroyDevice(int deviceId) {
163			setTitle("Audio.DestroyDevice_task");
164			setDescription(i18n.getMessage("Audio.DestroyDevice.desc", deviceId));
165
166			this.deviceId = deviceId;
167			}
168
169			/** The entry point of the task. */
170			public void
171			run() {
172			try { CC.getClient().destroyAudioOutputDevice(deviceId); }
173			catch(Exception x) {
174			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
175			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
176			}
177			}
178			}
179
180			/**
181			* This task enables/disables a specific audio output device.
182			*/
183			public static class EnableDevice extends EnhancedTask {
184			private int dev;
185			private boolean enable;
186
187			/**
188			* Creates new instance of <code>EnableDevice</code>.
189			* @param dev The id of the device to be enabled/disabled.
190			* @param enable Specify <code>true</code> to enable the audio device;
191			* code>false</code> to disable it.
192			*/
193			public
194			EnableDevice(int dev, boolean enable) {
195			setTitle("Audio.EnableDevice_task");
196			setDescription(i18n.getMessage("Audio.EnableDevice.desc", dev));
197
198			this.dev = dev;
199			this.enable = enable;
200			}
201
202			/** The entry point of the task. */
203			public void
204			run() {
205			try {
206			CC.getClient().enableAudioOutputDevice(dev, enable);
207
208			// Not needed, but eventually speeds up the change.
209	iliev	1204	CC.getSamplerModel().getAudioDeviceById(dev).setActive(enable);
210	iliev	1144	} catch(Exception x) {
211			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
212			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
213			}
214			}
215			}
216
217			/**
218	iliev	1357	* This task alters a specific setting of an audio output device.
219			*/
220			public static class SetDeviceParameter extends EnhancedTask {
221			private int dev;
222			private Parameter prm;
223
224			/**
225			* Creates new instance of <code>SetDeviceParameter</code>.
226			* @param dev The id of the device whose parameter should be set.
227			* @param prm The parameter to be set.
228			*/
229			public
230			SetDeviceParameter(int dev, Parameter prm) {
231			setTitle("Audio.SetDeviceParameter_task");
232			setDescription(i18n.getMessage("Audio.SetDeviceParameter.desc", dev));
233
234			this.dev = dev;
235			this.prm = prm;
236			}
237
238			/** The entry point of the task. */
239			public void
240			run() {
241			try { CC.getClient().setAudioOutputDeviceParameter(dev, prm); }
242			catch(Exception x) {
243			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
244			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
245			}
246			}
247			}
248
249			/**
250	iliev	1144	* This task alters a specific setting of an audio output channel.
251			*/
252			public static class SetChannelParameter extends EnhancedTask {
253			private int dev;
254			private int channel;
255			private Parameter prm;
256
257			/**
258			* Creates new instance of <code>SetChannelParameter</code>.
259	iliev	1357	* @param dev The id of the device whose channel parameter should be set.
260	iliev	1144	* @param channel The channel number.
261			* @param prm The parameter to be set.
262			*/
263			public
264			SetChannelParameter(int dev, int channel, Parameter prm) {
265			setTitle("Audio.SetChannelParameter_task");
266			setDescription(i18n.getMessage("Audio.SetChannelParameter.desc"));
267
268			this.dev = dev;
269			this.channel = channel;
270			this.prm = prm;
271			}
272
273			/** The entry point of the task. */
274			public void
275			run() {
276			try { CC.getClient().setAudioOutputChannelParameter(dev, channel, prm); }
277			catch(Exception x) {
278			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
279			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
280			}
281			}
282			}
283
284			/**
285			* This task changes the channel number of the speicifed audio output device.
286			*/
287			public static class SetChannelCount extends EnhancedTask {
288			private int deviceId;
289			private int channels;
290
291			/**
292			* Creates new instance of <code>SetChannelCount</code>.
293			* @param deviceId The id of the device whose channels number will be changed.
294			* @param channels The new number of audio channels.
295			*/
296			public
297			SetChannelCount(int deviceId, int channels) {
298			setTitle("SetAudioOutputChannelCount_task");
299			setDescription(i18n.getMessage("Audio.SetChannelCount.desc", deviceId));
300
301			this.deviceId = deviceId;
302			this.channels = channels;
303			}
304
305			/** The entry point of the task. */
306			public void
307			run() {
308			try { CC.getClient().setAudioOutputChannelCount(deviceId, channels); }
309			catch(Exception x) {
310			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
311			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
312			}
313			}
314			}
315
316
317			/**
318			* This task updates the setting of an audio output device.
319			*/
320			public static class UpdateDeviceInfo extends EnhancedTask {
321			private int dev;
322
323			/**
324			* Creates new instance of <code>UpdateDeviceInfo</code>.
325			* @param dev The id of the device, which settings should be updated.
326			*/
327			public
328			UpdateDeviceInfo(int dev) {
329			setTitle("Audio.UpdateDeviceInfo_task");
330			setDescription(i18n.getMessage("Audio.UpdateDeviceInfo.desc", dev));
331
332			this.dev = dev;
333			}
334
335			/** The entry point of the task. */
336			public void
337			run() {
338			try {
339			AudioOutputDevice d = CC.getClient().getAudioOutputDeviceInfo(dev);
340	iliev	1204	CC.getSamplerModel().getAudioDeviceById(dev).setDeviceInfo(d);
341	iliev	1144	} catch(Exception x) {
342			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
343			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
344			}
345			}
346			}
347
348			/**
349			* This task updates the audio output device list.
350			*/
351			public static class UpdateDevices extends EnhancedTask {
352			/** Creates a new instance of <code>UpdateDevices</code>. */
353			public
354			UpdateDevices() {
355			setTitle("Audio.UpdateDevices_task");
356			setDescription(i18n.getMessage("Audio.UpdateDevices.desc"));
357			}
358
359			/** The entry point of the task. */
360			public void
361			run() {
362			try {
363			SamplerModel sm = CC.getSamplerModel();
364			Integer[] devIDs = CC.getClient().getAudioOutputDeviceIDs();
365
366			boolean found = false;
367
368	iliev	1204	for(AudioDeviceModel m : sm.getAudioDevices()) {
369	iliev	1144	for(int i = 0; i < devIDs.length; i++) {
370			if(m.getDeviceId() == devIDs[i]) {
371			devIDs[i] = -1;
372			found = true;
373			}
374			}
375
376	iliev	1204	if(!found) sm.removeAudioDeviceById(m.getDeviceId());
377	iliev	1144	found = false;
378			}
379
380			AudioOutputDevice d;
381
382			for(int id : devIDs) {
383			if(id >= 0) {
384			d = CC.getClient().getAudioOutputDeviceInfo(id);
385			sm.addAudioDevice(d);
386			}
387			}
388			} catch(Exception x) {
389			setErrorMessage(getDescription() + ": " + HF.getErrorMessage(x));
390			CC.getLogger().log(Level.FINE, getErrorMessage(), x);
391			}
392			}
393			}
394
395			}