I am struggling with base64.
I would like to decode an image which comes though wysiwyg editor.
I build a source like below.(it is part of...)
InputStream is = request.getInputStream();
byte b[] = IOUtils.toByteArray(is);
String base64DataString = Base64.encodeBase64String(b);
String aaa = Base64.encodeBase64URLSafeString(b);
base64DataString = "data:image/" + ext + ";base64," + aaa;
if(aaa == "a"){}
if(is != null) {
is.close();
}
I got InputStream from request and make it as byte array.
size of byte[] b is exactly same with size of file I uploaded.
Then I combine a String to put src attribute of image tag.
After all of this when I look at in HTML. It has a broken image.
output looks like below :
<img src="data:image/jpeg;base64,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
" title="gaebul.jpeg">
What is the suspicious part of my code?
Thanks for sweet answer :D bb
You seem to be encoding two times without the real need, you should just do
byte[] encodeBase64 = Base64.encodeBase64(b);
String base64DataString = new String(encodeBase64 , "UTF-8");
and than just
src="data:image/jpeg;base64,[the value of your base64DataString]"
Related
I am trying to print image on zebra printer(LP-2844-Z) using zpl language. In ZPL documentaion it says you have to convert image into ASCII HexaDecimal. Then by using GF command you can print image.
I tried below code to get image and convert it into hexa decimal
URL oracle = new URL(urlString);
URLConnection yc = oracle.openConnection();
BufferedImage bufferedImage = ImageIO.read(yc.getInputStream());
int rowsData = bufferedImage.getWidth()/8;
System.out.println(rowsData);
byte[] pixel = ((DataBufferByte)bufferedImage.getRaster().getDataBuffer()).getData();
System.out.println(pixel.length);
System.out.println(Hex.encodeHex(pixel, false));
And then I tried to print this data using zebra printer but it is not printing correct image. I tried another code to get image bytes and converted it into hexa decimal
URL oracle = new URL(urlString);
URLConnection yc = oracle.openConnection();
InputStream inputStream = yc.getInputStream();
byte[] imageData = IOUtils.toByteArray(inputStream);
System.out.println(Hex.encodeHex(pixel, false));
Still I am not able to print correct image. I follow following URL (http://labelary.com/viewer.html) and tried to see code when we upload image. What I found that after uploading image, the base64 generated by zebra viewer is totally different which I generated using above code. I go through several post on stackoverflow but still I am not able to solve out this problem.
I know where I am doing mistake but I don't know how to solve it. Actually I am not able to generate ASCII Hex Base64 code for given image. This is my thought.
Any help is appriciated.
Thanks,
Give this function a try:
private static String zplEncode(String graphicFileLocation) {
Path imagePath = Paths.get(URI.create("file://" + graphicFileLocation));
String returnResults = "";
try {
byte[] binaryData = Files.readAllBytes(imagePath);
for (byte b : binaryData)
{
String hexRep = String.format("{0:X}", b);
if (hexRep.length() == 1)
hexRep = "0" + hexRep;
returnResults += hexRep;
}
} catch (IOException ex) {
// Do something here
}
return returnResults;
}
I based it upon this answer from 2012.
WHAT I'M DOING
I need to send via HTTPS request a JsonArray with some data and images in Base64 encoded strings. This works well if data is stored in memory.
Now, I need to avoid load all data in memory and I'm creating a temporally file in android device with all data that I need to send.
To create the file, I'm writting lots of JsonObjects inside him. Some of this JsonObjects have a field that represents the image. When I detect one, I get the image path and I encode it with Base64 as a String.
UPDATE:
First of all, I inicialize the file and I get the bufferedWriter
File f = new File(privateSincronizePath+File.separator+"upload_"+timefile+".json");
f.createNewFile();
FileWriter fw = new FileWriter(f.getAbsoluteFile(), true);
BufferedWriter bw = new BufferedWriter(fw);
Here is the code that create the image when exists:
JSONObject jobInf = new JSONObject();
jobInf.put("xx", "INSERT");
jobInf.put("xx", c.getString(c.getColumnIndex("xx")));
jobInf.put("xx", ""+c.getInt(c.getColumnIndex("xx")));
jobInf.put("xx", c.getString(c.getColumnIndex("xx")));
JSONObject jsonObject = new JSONObject(docu.filtre(dades, docu.getXx()));
Iterator<?> keys = jsonObject.keys();
boolean updated = false;
while(keys.hasNext() && !updated){
String key = (String)keys.next();
if (key != null && key.equals("path") && key.length() > 0){
jsonObject.put(key, getBase64EncodeFromImage(jsonObject.getString(key)));
updated = true;
}
}
jobInf.put("object", jsonObject);
escriure(bw, ","+jobInf.toString());
Method escriure():
UPDATE: This method is called every time I complete the creation of the JsonObject. Only append JsonObject as String to the file.
private void escriure(BufferedWriter bw, String s) throws IOException {
uploadLength += s.length();
bw.append(s);
}
Finally, when file is created, I'm reading it and, using OutputStream, I'm sending the data as Post parameters to the server:
this.Https_url = new URL(url+"/sync.php?");
HttpsURLConnection con = (HttpsURLConnection) Https_url.openConnection();
con.setReadTimeout(60000);
con.setConnectTimeout(60000);
con.setRequestMethod("POST");
con.setDoInput(true);
con.setDoOutput(true);
con.setFixedLengthStreamingMode(uploadLength);
OutputStream os = con.getOutputStream();
InputStream inp = new FileInputStream(new File(privateSincronizePath+File.separator+"upload_"+timefile+".json"));
byte[] buffer = new byte[1024];
int len;
while ((len = inp.read(buffer)) != -1) {
os.write(buffer, 0, len);
}
inp.close();
os.close();
// Establim la connexió:
con.connect();
WHAT IS THE PROBLEM
The problem is simple. When i open the image in the server, the file is corrupted and doesn't show the image.
WHAT I NOTICED
If I capture the image Base64 string encoded, before write in the file, and uploads it in the server, the image is Ok! Then, after write in the file, the image seems to be corrupted.
After investigate, I noticed that the Base64 encoded string after be written in the file, it have a lot of "\n" every x characters.
If I delete all of this "\n" or breaklines, the image can be opened by the server correctly.
THE QUESTION
Who is putting this breaklines? How can I write the Base64 encoded as String "as is" ?
Thanks all for your help in advance!
THE ANSWER
As Schoenobates answer, the solution was use the flag NO_WRAP.
To add more information, we put in the server side this function to read the encoded Base64 string with flag URL_SAFE
The function, obtained in on coment of TOM in php.net is:
<?php
function base64url_decode($base64url)
{
$base64 = strtr($base64url, '-_', '+/');
$plainText = base64_decode($base64);
return ($plainText);
}
?>
Thanks to StackOverflow, Axel and Schoenobates for your time!
That'll be the Android Base64 class - you need to set the flags to remove the newlines:
byte[] image = ...;
Base64.encodeToString(image, Base64.NO_WRAP | Base64.URL_SAFE);
I am trying to load a .swf file in my page, i would like to make this load faster by converting it to Base64, rather providing a src. This is working great with image formats by using the below code
Java code
BufferedImage buffImg = ImageIO.read(new File(imagePath));
ImageIO.write(buffImg, imgExtension, bos);
byte[] imageBytes = bos.toByteArray();
BASE64Encoder encoder = new BASE64Encoder();
imageString = encoder.encode(imageBytes);
but this is not working for swf file. is there any possible way to achieve this.
Html
<object width="10" height="10" data="data:application/x-shockwave-flash;base64, RldTCSEAAABIAZAAZAAADAEARBEIAAAAQwIAAP9AAAAA"></object>
thanks in advance.
Trying to get the file in base64 will not speed up the file transfer, it's just the opposite as it will convert the file which is stored in bytes (base256 if it can be said that way) to base64 (64 printable characters), so the final amount of data you will be transfering is more.
The only "win" is that you might be able to load it as part of the page instead of the browser making another call for the swf file, which should be no issue on http 1.1.
Unless you have some other good reason to do this, I would not suggest this kind of practice.
If you have your swf file(s) in a database as a blob, you could just make a servlet which sets the proper contenttype and write the whole file with the ServletOutputStream, without any tags. In your html code, you would have to reference to the servlet instead of a fixed file.
If you still want to convert the file to base64, you shouldn't use some image API, but get the file in a standard way for binary files, here's a sample that should do the job:
http://www.javapractices.com/topic/TopicAction.do?Id=245
You can still do the encoding as you did it once you have a byte array:
File file = new File(imagePath);
log("File size: " + file.length());
byte[] result = null;
try {
InputStream input = new BufferedInputStream(new FileInputStream(file));
result = readAndClose(input);
}
catch (FileNotFoundException ex){
log(ex);
}
BASE64Encoder encoder = new BASE64Encoder();
imageString = encoder.encode(result);
And the readAndClose method:
byte[] readAndClose(InputStream aInput){
byte[] bucket = new byte[32*1024];
ByteArrayOutputStream result = null;
try {
try {
result = new ByteArrayOutputStream(bucket.length);
int bytesRead = 0;
while(bytesRead != -1){
bytesRead = aInput.read(bucket);
if(bytesRead > 0){
result.write(bucket, 0, bytesRead);
}
}
}
finally {
aInput.close();
}
}
catch (IOException ex){
log(ex);
}
return result.toByteArray();
}
This should do the trick, maybe some fine tunings to adapt the code to your specific situation, optimize it and better error handling...
here is my java code that construct the base64 String from image. Then place the base64 String html, to view
the constructed image, but image is not constructed somehow
public void getBase64String() throws FileNotFoundException {
FileInputStream itStrm = new FileInputStream(
"E:\\image\\56255254-flower.jpg");//image is lying at http://danny.oz.au/travel/mongolia/p/56255254-flower.jpg
String str = itStrm.toString();
byte[] b3 = str.getBytes();
String base64String = new sun.misc.BASE64Encoder().encode(b3);
//output of base64String is amF2YS5pby5GaWxlSW5wdXRTdHJlYW1AMTdlMDYwMA==
}
Now in html page i placed the output of base64String in img tag to view the image.But image does not shows up
(instead it display the cross image icon). I am not getting image is not displayed from base64 String below?
<HTML>
<BODY>
<img src="data:image/jpeg;base64,amF2YS5pby5GaWxlSW5wdXRTdHJlYW1AMTdlMDYwMA=="/>
</BODY>
</HTML>
EDIT:- Thanks Folks, i used byte[] bytes = IOUtils.toByteArray(is);. It worked for me!!
This: String str = itStrm.toString() is not the image but the toString() representation of the FileInputStream instance.
You'll have to read the bytes from the stream and store them in a byte array. And, for performance reasons, buffer the stream:
BufferedInputStream itStrm = new BufferedInputStream(FileInputStream(
"E:\\image\\56255254-flower.jpg"));
Further reading (Spoiler: solution inside)
Convert InputStream to byte array in Java
You would need to use the read() method of the FileInputStream instance instead of the toString() to get the content of the image. Then you are able to encode it and should work as you expected.
Something like:
int c;
StringBuffer result = new StringBuffer("");
while((c = fileInputStream.read()) != -1)
{
result .append((char)c);
}
In the end, my ultimate goals are:
Read from a URL (what this question is about)
Save the retrieved [PDF] content to a BLOB field in a DB (already have that nailed down)
Read from the BLOB field and attach that content to an email
All without going to a filesystem
The goal with the following method is to get a byte[] that can be used downstream as an email attachment (to avoid writing to disk):
public byte[] retrievePDF() {
HttpClient httpClient = new HttpClient();
GetMethod httpGet = new GetMethod("http://website/document.pdf");
httpClient.executeMethod(httpGet);
InputStream is = httpGet.getResponseBodyAsStream();
byte[] byteArray = new byte[(int) httpGet.getResponseContentLength()];
is.read(byteArray, 0, byteArray.length);
return byteArray;
}
For a particular PDF, the getResponseContentLength() method returns 101,689 as the length. The strange part is that if I set a break-point and interrogate the byteArray variable, it has 101,689 byte elements, however, after byte #3744 the remaining bytes of the array are all zeroes (0). The resulting PDF is then not readable by a PDF-reader client, like Adobe Reader.
Why would that happen?
Retrieving this same PDF via browser and saving to disk, or using a method like the following (which I patterned after an answer to this StackOverflow post), results in a readable PDF:
public void retrievePDF() {
FileOutputStream fos = null;
URL url;
ReadableByteChannel rbc = null;
url = new URL("http://website/document.pdf");
DataSource urlDataSource = new URLDataSource(url);
/* Open a connection, then set appropriate time-out values */
URLConnection conn = url.openConnection();
conn.setConnectTimeout(120000);
conn.setReadTimeout(120000);
rbc = Channels.newChannel(conn.getInputStream());
String filePath = "C:\\temp\\";
String fileName = "testing1234.pdf";
String tempFileName = filePath + fileName;
fos = new FileOutputStream(tempFileName);
fos.getChannel().transferFrom(rbc, 0, 1 << 24);
fos.flush();
/* Clean-up everything */
fos.close();
rbc.close();
}
For both approaches, the size of the resulting PDF is 101,689-bytes when doing a Right-click > Properties... in Windows.
Why would the byte array essentially "stop" part-way through?
InputStream.read reads up to byteArray.length bytes but might not read exactly that much. It returns how many bytes it read. You should call it repeatedly to fully read the data, like this:
int bytesRead = 0;
while (true) {
int n = is.read(byteArray, bytesRead, byteArray.length);
if (n == -1) break;
bytesRead += n;
}
Check the return value of InputStream.read. It's not going to read all at one go. You have to write a loop. Or, better yet, use Apache Commons IO to copy the stream.
101689 = 2^16 + 36153 so it would look like, that there is a 16 bit limitation on buffer size.
The difference between 36153 and 3744 maybe stems from the header part having been read in an extra small 1K buffer or so, and already containing some bytes.