Question

I have a server-side function that draws an image with the Python Imaging Library. The Java client requests an image, which is returned via socket and converted to a BufferedImage.

I prefix the data with the size of the image to be sent, followed by a CR. I then read this number of bytes from the socket input stream and attempt to use ImageIO to convert to a BufferedImage.

In abbreviated code for the client:

public String writeAndReadSocket(String request) {
    // Write text to the socket
    BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    bufferedWriter.write(request);
    bufferedWriter.flush();

    // Read text from the socket
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

    // Read the prefixed size
    int size = Integer.parseInt(bufferedReader.readLine());

    // Get that many bytes from the stream
    char[] buf = new char[size];
    bufferedReader.read(buf, 0, size);
    return new String(buf);
}

public BufferedImage stringToBufferedImage(String imageBytes) {
    return ImageIO.read(new ByteArrayInputStream(s.getBytes()));
}

and the server:

# Twisted server code here

# The analog of the following method is called with the proper client
# request and the result is written to the socket.
def worker_thread():
    img = draw_function()
    buf = StringIO.StringIO()
    img.save(buf, format="PNG")
    img_string = buf.getvalue()
    return "%i\r%s" % (sys.getsizeof(img_string), img_string)

This works for sending and receiving Strings, but image conversion (usually) fails. I’m trying to understand why the images are not being read properly. My best guess is that the client is not reading the proper number of bytes, but I honestly don’t know why that would be the case.

Side notes:

• I realize that the char[]-to-String-to-bytes-to-BufferedImage Java logic is roundabout, but reading the bytestream directly produces the same errors.
• I have a version of this working where the client socket isn’t persistent, ie. the request is processed and the connection is dropped. That version works fine, as I don’t need to care about the image size, but I want to learn why the proposed approach doesn’t work.

Answer 1

1. BufferedReader.read() isn’t guaranteed to fill the buffer, and converting the image to String and back is not only pointless but wrong.

2. String is not a container for binary data, and the round-trip isn’t guaranteed to work.

It would be better to redesign the protocol so that you can get rid of the readLine(), and send the length in binary and can read the entire stream with a DataInputStream.

In general when dealing with binary protocols, the answer is always DataInputStream and DataOutputStream, unless the byte order isn’t the canonical network byte order, which is a protocol design mistake, and in which case you need to look into byte-ordered ByteBuffers.