class RemindTask_send_update extends TimerTask {
Runtime rxrunti = Runtime.getRuntime();
public void
run() { // ************************************************************************************
krypton_update_token update = new krypton_update_token(tokenx_buffer);
// krypton_net_client.send_unconfirmed_update(tokenx_buffer);
krypton_database_load load = new krypton_database_load();
} // runx***************************************************************************************************
} // remindtask
class RemindTask_restart extends TimerTask {
Runtime rxrunti = Runtime.getRuntime();
public void
run() { // **************************************************************************************
try {
restartApplication();
} catch (Exception e) {
e.printStackTrace();
}
} // runx***************************************************************************************************
} // remindtask
protected BufferedImage makeImage() {
BufferedImage image =
new BufferedImage(IMAGE_SIZE, IMAGE_SIZE, BufferedImage.TYPE_4BYTE_ABGR);
Graphics2D g = image.createGraphics();
g.setPaint(Color.WHITE);
g.fill3DRect(0, 0, IMAGE_SIZE, IMAGE_SIZE, false);
g.setPaint(Color.RED);
g.setFont(Font.decode("ARIAL-BOLD-50"));
g.drawString(Long.toString(++this.counter) + " frames", 10, IMAGE_SIZE / 4);
g.drawString(
Long.toString((System.currentTimeMillis() - start) / 1000) + " sec", 10, IMAGE_SIZE / 2);
g.drawString(
"Heap:" + Long.toString(Runtime.getRuntime().totalMemory()), 10, 3 * IMAGE_SIZE / 4);
g.dispose();
return image;
}
class RemindTask_server extends TimerTask {
Runtime rxrunti = Runtime.getRuntime();
public void
run() { // ************************************************************************************
String jsonText2 = new String("");
JSONObject obj_out = new JSONObject();
ServerSocket welcomeSocket;
while (true) {
try { // *********************************************************
welcomeSocket = new ServerSocket(network.api_port, 0, InetAddress.getByName("localhost"));
Socket connectionSocket = welcomeSocket.accept();
BufferedReader inFromClient =
new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
clientSentence = inFromClient.readLine();
JSONParser parser = new JSONParser();
try { // *********************************************************
statex = "0";
responsex = "e00";
jsonText = "";
if (!clientSentence.contains("")) {
throw new EmptyStackException();
}
Object obj = parser.parse(clientSentence);
jsonObject = (JSONObject) obj;
String request = (String) jsonObject.get("request");
String item_id = new String("");
String item_array = new String("");
String old_key = new String("");
String node = new String("");
try {
item_id = (String) jsonObject.get("item_id").toString();
} catch (Exception e) {
System.out.println("extra info no item_id...");
}
try {
item_array = (String) jsonObject.get("item_array").toString();
} catch (Exception e) {
System.out.println("extra info no item_array...");
}
try {
old_key = (String) jsonObject.get("key").toString();
} catch (Exception e) {
System.out.println("extra info no key...");
}
try {
node = (String) jsonObject.get("node").toString();
} catch (Exception e) {
System.out.println("extra info no node...");
}
while (network.database_in_use == 1 && !request.equals("status")) {
System.out.println("Database in use...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
} // **************************************************************
if (request.equals("status")) {
statex = "1";
responsex = get_status();
} // ***************************
else if (request.equals("get_version")) {
statex = "1";
responsex = network.versionx;
} //
else if (request.equals("get_tor_active")) {
statex = "1";
responsex = Integer.toString(network.tor_active);
} //
else if (request.equals("get_last_block")) {
statex = "1";
responsex = network.last_block_id;
} //
else if (request.equals("get_last_block_timestamp")) {
statex = "1";
responsex = network.last_block_timestamp;
} //
else if (request.equals("get_last_block_hash")) {
statex = "1";
responsex = network.last_block_idx;
} //
else if (request.equals("get_difficulty")) {
statex = "1";
responsex = Long.toString(network.difficultyx);
} //
else if (request.equals("get_last_mining_id")) {
statex = "1";
responsex = network.last_block_mining_idx;
} //
else if (request.equals("get_prev_mining_id")) {
statex = "1";
responsex = network.prev_block_mining_idx;
} //
else if (request.equals("get_last_unconfirmed_id")) {
statex = "1";
responsex = get_item_ids();
} //
else if (request.equals("get_my_token_total")) {
statex = "1";
responsex = Integer.toString(network.database_listings_owner);
} //
else if (request.equals("get_my_id_list")) {
statex = "1";
responsex = get_item_ids();
} //
else if (request.equals("get_my_ids_limit")) {
statex = "1";
responsex = get_item_ids();
} //
else if (request.equals("get_token")) {
statex = "1";
responsex = get_item_array(item_id);
} //
else if (request.equals("get_settings")) {
statex = "1";
responsex = get_settings_array();
} //
else if (request.equals("get_mining_info")) {
statex = "1";
responsex = get_item_array(item_id);
} //
else if (request.equals("get_new_keys")) {
statex = "1";
responsex = build_keysx();
} //
else if (request.equals("delete_node")) {
statex = "1";
responsex = delete_node(node);
} //
else if (request.equals("delete_all_nodes")) {
statex = "1";
responsex = delete_all_nodes();
} //
else if (request.equals("set_new_node")) {
statex = "1";
responsex = set_new_node(node);
} //
else if (request.equals("set_old_key")) {
statex = "1";
responsex = set_old_key(old_key);
} //
else if (request.equals("set_new_block")) {
statex = "1";
responsex = set_new_block(item_array);
} //
else if (request.equals("set_edit_block")) {
statex = "1";
update_state = "set_edit_block";
responsex = update_token(item_array);
} //
else if (request.equals("set_transfer_block")) {
statex = "1";
update_state = "set_transfer_block";
responsex = update_token(item_array);
} //
else if (request.equals("system_restart")) {
statex = "1";
responsex = "restarting";
toolkit = Toolkit.getDefaultToolkit();
xtimerx = new Timer();
xtimerx.schedule(new RemindTask_restart(), 0);
} //
else if (request.equals("system_exit")) {
statex = "1";
System.exit(0);
} //
else {
statex = "0";
responsex = "e01 UnknownRequestException";
}
} // try
catch (ParseException e) {
e.printStackTrace();
statex = "0";
responsex = "e02 ParseException";
} catch (Exception e) {
e.printStackTrace();
statex = "0";
responsex = "e03 Exception";
}
JSONObject obj = new JSONObject();
obj.put("response", statex);
try {
obj.put("message", responsex);
} catch (Exception e) {
e.printStackTrace();
}
StringWriter outs = new StringWriter();
obj.writeJSONString(outs);
jsonText = outs.toString();
System.out.println("SEND RESPONSE " + responsex);
outToClient.writeBytes(jsonText + '\n');
welcomeSocket.close();
} catch (Exception e) {
e.printStackTrace();
System.out.println("Server ERROR x3");
}
} // **********while
} // runx***************************************************************************************************
} // remindtask
public synchronized RenderedImage runDCRaw(dcrawMode mode, boolean secondaryPixels)
throws IOException, UnknownImageTypeException, BadImageFileException {
if (!m_decodable || (mode == dcrawMode.full && m_rawColors != 3))
throw new UnknownImageTypeException("Unsuported Camera");
RenderedImage result = null;
File of = null;
try {
if (mode == dcrawMode.preview) {
if (m_thumbWidth >= 1024 && m_thumbHeight >= 768) {
mode = dcrawMode.thumb;
}
}
long t1 = System.currentTimeMillis();
of = File.createTempFile("LZRAWTMP", ".ppm");
boolean four_colors = false;
final String makeModel = m_make + ' ' + m_model;
for (String s : four_color_cameras)
if (s.equalsIgnoreCase(makeModel)) {
four_colors = true;
break;
}
if (secondaryPixels) runDCRawInfo(true);
String cmd[];
switch (mode) {
case full:
if (four_colors)
cmd =
new String[] {
DCRAW_PATH,
"-F",
of.getAbsolutePath(),
"-v",
"-f",
"-H",
"1",
"-t",
"0",
"-o",
"0",
"-4",
m_fileName
};
else if (m_filters == -1 || (m_make != null && m_make.equalsIgnoreCase("SIGMA")))
cmd =
new String[] {
DCRAW_PATH,
"-F",
of.getAbsolutePath(),
"-v",
"-H",
"1",
"-t",
"0",
"-o",
"0",
"-4",
m_fileName
};
else if (secondaryPixels)
cmd =
new String[] {
DCRAW_PATH,
"-F",
of.getAbsolutePath(),
"-v",
"-j",
"-H",
"1",
"-t",
"0",
"-s",
"1",
"-d",
"-4",
m_fileName
};
else
cmd =
new String[] {
DCRAW_PATH,
"-F",
of.getAbsolutePath(),
"-v",
"-j",
"-H",
"1",
"-t",
"0",
"-d",
"-4",
m_fileName
};
break;
case preview:
cmd =
new String[] {
DCRAW_PATH,
"-F",
of.getAbsolutePath(),
"-v",
"-t",
"0",
"-o",
"1",
"-w",
"-h",
m_fileName
};
break;
case thumb:
cmd = new String[] {DCRAW_PATH, "-F", of.getAbsolutePath(), "-v", "-e", m_fileName};
break;
default:
throw new IllegalArgumentException("Unknown mode " + mode);
}
String ofName = null;
synchronized (DCRaw.class) {
Process p = null;
InputStream dcrawStdErr;
InputStream dcrawStdOut;
if (ForkDaemon.INSTANCE != null) {
ForkDaemon.INSTANCE.invoke(cmd);
dcrawStdErr = ForkDaemon.INSTANCE.getStdErr();
dcrawStdOut = ForkDaemon.INSTANCE.getStdOut();
} else {
p = Runtime.getRuntime().exec(cmd);
dcrawStdErr = new BufferedInputStream(p.getErrorStream());
dcrawStdOut = p.getInputStream();
}
String line, args;
// output expected on stderr
while ((line = readln(dcrawStdErr)) != null) {
// System.out.println(line);
if ((args = match(line, DCRAW_OUTPUT)) != null)
ofName = args.substring(0, args.indexOf(" ..."));
}
// Flush stdout just in case...
while ((line = readln(dcrawStdOut)) != null) ; // System.out.println(line);
if (p != null) {
dcrawStdErr.close();
try {
p.waitFor();
} catch (InterruptedException e) {
e.printStackTrace();
}
m_error = p.exitValue();
p.destroy();
} else m_error = 0;
}
System.out.println("dcraw value: " + m_error);
if (m_error > 0) {
of.delete();
throw new BadImageFileException(of);
}
if (!ofName.equals(of.getPath())) {
of.delete();
of = new File(ofName);
}
if (of.getName().endsWith(".jpg") || of.getName().endsWith(".tiff")) {
if (of.getName().endsWith(".jpg")) {
try {
LCJPEGReader jpegReader = new LCJPEGReader(of.getPath());
result = jpegReader.getImage();
} catch (Exception e) {
e.printStackTrace();
}
} else {
try {
LCTIFFReader tiffReader = new LCTIFFReader(of.getPath());
result = tiffReader.getImage(null);
} catch (Exception e) {
e.printStackTrace();
}
}
long t2 = System.currentTimeMillis();
int totalData =
result.getWidth()
* result.getHeight()
* result.getColorModel().getNumColorComponents()
* (result.getColorModel().getTransferType() == DataBuffer.TYPE_BYTE ? 1 : 2);
System.out.println("Read " + totalData + " bytes in " + (t2 - t1) + "ms");
} else {
ImageData imageData;
try {
imageData = readPPM(of);
} catch (Exception e) {
e.printStackTrace();
throw new BadImageFileException(of, e);
}
// do not change the initial image geometry
// m_width = Math.min(m_width, imageData.width);
// m_height = Math.min(m_height, imageData.height);
long t2 = System.currentTimeMillis();
int totalData =
imageData.width
* imageData.height
* imageData.bands
* (imageData.dataType == DataBuffer.TYPE_BYTE ? 1 : 2);
System.out.println("Read " + totalData + " bytes in " + (t2 - t1) + "ms");
final ColorModel cm;
if (mode == dcrawMode.full) {
if (imageData.bands == 1) {
cm =
new ComponentColorModel(
ColorSpace.getInstance(ColorSpace.CS_GRAY),
false,
false,
Transparency.OPAQUE,
DataBuffer.TYPE_USHORT);
} else {
cm = JAIContext.colorModel_linear16;
}
} else {
if (imageData.bands == 3)
cm =
new ComponentColorModel(
JAIContext.sRGBColorSpace,
false,
false,
Transparency.OPAQUE,
DataBuffer.TYPE_BYTE);
else if (imageData.bands == 4)
cm =
new ComponentColorModel(
JAIContext.CMYKColorSpace,
false,
false,
Transparency.OPAQUE,
imageData.dataType);
else throw new UnknownImageTypeException("Weird number of bands: " + imageData.bands);
}
final DataBuffer buf =
imageData.dataType == DataBuffer.TYPE_BYTE
? new DataBufferByte(
(byte[]) imageData.data, imageData.bands * imageData.width * imageData.height)
: new DataBufferUShort(
(short[]) imageData.data, imageData.bands * imageData.width * imageData.height);
final WritableRaster raster =
Raster.createInterleavedRaster(
buf,
imageData.width,
imageData.height,
imageData.bands * imageData.width,
imageData.bands,
imageData.bands == 3 ? new int[] {0, 1, 2} : new int[] {0},
null);
result = new BufferedImage(cm, raster, false, null);
}
} catch (IOException e) {
if (of != null) of.delete();
throw e;
} finally {
if (of != null) of.delete();
}
return result;
}
private void runDCRawInfo(boolean secondary) throws IOException {
String info[] = {DCRAW_PATH, "-v", "-i", "-t", "0", m_fileName};
String secondaryInfo[] = {DCRAW_PATH, "-v", "-i", "-s", "1", "-t", "0", m_fileName};
synchronized (DCRaw.class) {
Process p = null;
InputStream dcrawStdOut;
InputStream dcrawStdErr;
if (ForkDaemon.INSTANCE != null) {
ForkDaemon.INSTANCE.invoke(secondary ? secondaryInfo : info);
dcrawStdOut = ForkDaemon.INSTANCE.getStdOut();
dcrawStdErr = ForkDaemon.INSTANCE.getStdErr();
} else {
p = Runtime.getRuntime().exec(secondary ? secondaryInfo : info);
dcrawStdOut = p.getInputStream();
dcrawStdErr = new BufferedInputStream(p.getErrorStream());
}
// output expected on stdout
String line, args;
while ((line = readln(dcrawStdOut)) != null) {
// System.out.println(line);
String search;
if (secondary) {
if (line.startsWith(search = CAMERA_MULTIPLIERS)) {
String multipliers[] = line.substring(search.length()).split("\\s");
m_secondary_cam_mul[0] = Float.parseFloat(multipliers[0]);
m_secondary_cam_mul[1] = Float.parseFloat(multipliers[1]);
m_secondary_cam_mul[2] = Float.parseFloat(multipliers[2]);
m_secondary_cam_mul[3] = Float.parseFloat(multipliers[3]);
}
} else {
// if (line.startsWith(search = FILENAME)) {
// String filename = line.substring(search.length());
// } else
if (line.startsWith(search = TIMESTAMP)) {
String timestamp = line.substring(search.length());
try {
m_captureDateTime = new SimpleDateFormat().parse(timestamp).getTime();
} catch (ParseException e) {
m_captureDateTime = 0;
}
} else if (line.startsWith(search = CAMERA)) {
String camera = line.substring(search.length());
m_make = camera.substring(0, camera.indexOf(' '));
m_model = camera.substring(m_make.length() + 1);
} else if (line.startsWith(search = ISO)) {
String iso = line.substring(search.length());
m_iso = Integer.decode(iso);
} else if (line.startsWith(search = SHUTTER)) {
String shutterSpeed = line.substring(search.length() + 2);
float exposureTime = 0;
try {
exposureTime = Float.valueOf(shutterSpeed.substring(0, shutterSpeed.indexOf(" sec")));
if (exposureTime != 0) m_shutterSpeed = 1 / exposureTime;
} catch (NumberFormatException e) {
}
} else if (line.startsWith(search = APERTURE)) {
String aperture = line.substring(search.length() + 2);
try {
m_aperture = Float.valueOf(aperture);
} catch (NumberFormatException e) {
}
} else if (line.startsWith(search = FOCAL_LENGTH)) {
String focalLenght = line.substring(search.length());
try {
m_focalLength = Float.valueOf(focalLenght.substring(0, focalLenght.indexOf(" mm")));
} catch (NumberFormatException e) {
}
// } else if (line.startsWith(search = NUM_RAW_IMAGES)) {
// String numRawImages = line.substring(search.length());
// } else if (line.startsWith(search = EMBEDDED_ICC_PROFILE)) {
// String embeddedICCProfile = line.substring(search.length());
} else if (line.startsWith(CANNOT_DECODE)) {
m_decodable = false;
} else if ((args = match(line, THUMB_SIZE)) != null) {
String sizes[] = args.split(" x ");
m_thumbWidth = Integer.decode(sizes[0]);
m_thumbHeight = Integer.decode(sizes[1]);
} else if ((args = match(line, FULL_SIZE)) != null) {
String sizes[] = args.split(" x ");
m_fullWidth = Integer.decode(sizes[0]);
m_fullHeight = Integer.decode(sizes[1]);
} else if ((args = match(line, IMAGE_SIZE)) != null) {
String sizes[] = args.split(" x ");
m_rawWidth = Integer.decode(sizes[0]);
m_rawHeight = Integer.decode(sizes[1]);
} else if ((args = match(line, OUTPUT_SIZE)) != null) {
String sizes[] = args.split(" x ");
m_width = Integer.decode(sizes[0]);
m_height = Integer.decode(sizes[1]);
} else if (line.startsWith(search = RAW_COLORS)) {
String rawColors = line.substring(search.length());
m_rawColors = Integer.decode(rawColors);
} else if (line.startsWith(search = FILTER_PATTERN)) {
String pattern = line.substring(search.length());
if (pattern.length() >= 8 && !pattern.substring(0, 4).equals(pattern.substring(4, 8)))
m_filters = -1;
else if (pattern.startsWith("BGGR")) m_filters = 0x16161616;
else if (pattern.startsWith("GRBG")) m_filters = 0x61616161;
else if (pattern.startsWith("GBRG")) m_filters = 0x49494949;
else if (pattern.startsWith("RGGB")) m_filters = 0x94949494;
else m_filters = -1;
} else if (line.startsWith(search = DAYLIGHT_MULTIPLIERS)) {
String multipliers[] = line.substring(search.length()).split("\\s");
m_pre_mul[0] = Float.parseFloat(multipliers[0]);
m_pre_mul[1] = Float.parseFloat(multipliers[1]);
m_pre_mul[2] = Float.parseFloat(multipliers[2]);
m_pre_mul[3] = m_pre_mul[1];
} else if (line.startsWith(search = CAMERA_MULTIPLIERS)) {
String multipliers[] = line.substring(search.length()).split("\\s");
m_cam_mul[0] = Float.parseFloat(multipliers[0]);
m_cam_mul[1] = Float.parseFloat(multipliers[1]);
m_cam_mul[2] = Float.parseFloat(multipliers[2]);
m_cam_mul[3] = Float.parseFloat(multipliers[3]);
} else if (line.startsWith(CAMERA_RGB_PROFILE)) {
String rgb_cam[] = line.substring(CAMERA_RGB_PROFILE.length()).split("\\s");
m_rgb_cam = new float[9];
for (int i = 0; i < 9; i++) {
m_rgb_cam[i] = Float.parseFloat(rgb_cam[i]);
}
} else if (line.startsWith(CAMERA_XYZ_PROFILE)) {
String xyz_cam[] = line.substring(CAMERA_XYZ_PROFILE.length()).split("\\s");
m_xyz_cam = new float[9];
for (int i = 0; i < 9; i++) {
m_xyz_cam[i] = Float.parseFloat(xyz_cam[i]);
}
}
}
}
// Flush stderr just in case...
while ((line = readln(dcrawStdErr)) != null) ; // System.out.println(line);
if (p != null) {
dcrawStdOut.close();
try {
p.waitFor();
} catch (InterruptedException e) {
e.printStackTrace();
}
m_error = p.exitValue();
p.destroy();
} else m_error = 0;
}
}
