通过套接字将屏幕快照从Java发送到CPP-接收图像问题

Question

Java (server):

take screenshot method

    //Take screenshot of active application
    robot.keyPress(KeyEvent.VK_CONTROL);
    robot.keyPress(KeyEvent.VK_ALT);
    robot.keyPress(KeyEvent.VK_PRINTSCREEN);
    robot.delay(5);
    robot.keyRelease(KeyEvent.VK_PRINTSCREEN);
    robot.keyRelease(KeyEvent.VK_CONTROL);
    robot.keyRelease(KeyEvent.VK_ALT);

    Clipboard cb = Toolkit.getDefaultToolkit().getSystemClipboard();
    flavors = cb.getAvailableDataFlavors();
    for (DataFlavor flavor : flavors) {
        if (flavor.toString().indexOf("java.awt.Image") <= 0) {
            continue;
        }
        i[0] = (Image) cb.getData(flavor);
    }
    robot.delay(50);

    bi = new BufferedImage(i[0].getWidth(null), i[0].getHeight(null),
            BufferedImage.TYPE_BYTE_GRAY); // keep buffered image as gray scale

    // resize image since I don't need large res
    resizedImage = new BufferedImage(IMG_WIDTH, IMG_HEIGHT, BufferedImage.TYPE_BYTE_GRAY);
    g = resizedImage.createGraphics();
    g.drawImage(i[0], 0, 0,IMG_WIDTH, IMG_HEIGHT, null);

    g.dispose();

    ByteArrayOutputStream baos = new ByteArrayOutputStream(); // <-- This is irrelevant!
    ImageIO.write(resizedImage, "jpg", baos);
    baos.flush();
    byte[] imageInByte = baos.toByteArray();
    baos.close();
    return imageInByte;

open socket and send image

    byte[] screenShot = SaveScreenshot();
    ServerSocket serverSocket = null; 
    Socket slientSocket = null;
    Socket clientSocket = null;
    try {
        serverSocket = new ServerSocket(4447);
        clientSocket = serverSocket.accept();

OutputStreamWriter(clientSocket.getOutputStream()));

        OutputStream out = clientSocket.getOutputStream();
        ByteArrayOutputStream bScrn = new ByteArrayOutputStream();

        out.write((Integer.toString(screenShot.length)).getBytes());
        out.write(screenShot,0,screenShot.length);

        serverSocket.close();
        clientSocket.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

CPP (client):

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <cstdio>
#include <cstddef>
#include <cstdlib>
#include <strings.h>


using namespace std;
int main()
{
int sockfd; // socket file descriptor 
int portno; // port number
struct sockaddr_in serv_addr;
struct hostent *server;

char ip[] = "127.0.0.1"; // ip of server
portno = 4447; // port number

sockfd = socket(AF_INET, SOCK_STREAM, 0); // generate file descriptor 
if (sockfd < 0)
    perror("ERROR opening socket");

server = gethostbyname(ip); //the ip address (or server name) of the listening server.
if (server == NULL) {
    fprintf(stderr,"ERROR, no such host\n");
    exit(0);
}

bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr, (char *)&serv_addr.sin_addr.s_addr, server->h_length);
serv_addr.sin_port = htons(portno);

if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
    perror("ERROR connecting");

char rbuff[256];
//int rbuff;
int rbytes;

rbytes = recv(sockfd, rbuff, sizeof(rbuff), 0); // similar to read(), but return -1 if socket closed
rbuff[rbytes] = '\0'; // set null terminal
printf("Message: %s  %d\n", rbuff, atoi(rbuff));

unsigned char *ssByte = new unsigned char[atoi(rbuff)];
rbytes = recv(sockfd, ssByte, sizeof(ssByte), 0);

FILE *fp=fopen("/home/chen/Pictures/recv.jpeg","w");
fwrite(ssByte,sizeof(ssByte),1, fp);

return 0;
}

1. Java opens socket
2. Cpp connects
3. Java sends ByteArray size (int)
4. Cpp creates unsigned char* array that size
5. Java sends the image
6. Cpp attempts to save

Made sure in Java, saved the Image and all goes well. Checked that the size of the Image I receive from the Java into Cpp is identical between the two.

In the Java application, if I direct the ImageIO.write function to

new File("/dir/test.jpg")

I receive a proper working jpg.

That leads me to think the issue isn't with the jpg "header" but somewhere else.

Thanks for any help given!

** EDIT #1 ** Changed the receive (cpp) to the following code:

do {
     rbytes = recv(sockfd, ssByte, sizeof(ssByte), 0);
     if ( rbytes > 0 )
         printf("Bytes received: %d\n", rbytes);
     else if ( rbytes == 0 )
         printf("Connection closed\n");
     else
         printf("recv failed\n");
} while( rbytes > 0 );

What I see is that every incoming message is of 8 Bytes maximum (the last is 3 Bytes). I'll try to combine the inputs and see if they build up a properly working JPG, question is if I can force the Java to send at larger packet sizes - especially since this is over localhost and not over the NIC.

** EDIT 2 - Alternative solution **

In addition to the solution by Alnitak, you can also do:

This will keep the whole stream into byte array and then dump into file (in case you need to do further manipulation before saving).

unsigned char ssByte[atoi(rbuff)];
int last = 0;

if ( rbytes > 0 ) { // rbytes is from the last call, to make sure socket still open and the image isn't zero size
        do {
             rbytes = recv(sockfd, &ssByte[last], 4096, 0);
             if ( rbytes > 0 ){
                //printf("Bytes received: %d\n", rbytes);
                last += rbytes;
             }
             else if ( rbytes == 0 )
                 printf("Connection closed\n");
             else
                 printf("recv failed\n");
        } while( rbytes > 0 );

        printf("Image: %d\n", last);

        FILE *fp=fopen("/home/chen/Pictures/recv.jpg","w");
        fwrite(ssByte,sizeof(unsigned char),last, fp);
        fclose(fp);
}
return 0;

Thanks to all that helped!

Answer 1

Your problem is that sizeof ssByte is not the size of the array, it's the size of that pointer. There's no problem with your network transmission or packet sizes - on TCP streams that's normally controlled by the O/S and not the application.

In any event, it would be more common to create a modest-sized byte array of fixed size, and then use a while() loop to read chunks of that much data at a time, finishing once you have the specified number of bytes.

You can also then write that data to the file as it's read. I'd also note that there's no good reason to use <stdio> for writing the file since there's no need to buffer or format any output. It would be simpler to just use open() and write() :

unsigned char buf[4096];  // nb: no "new", and sizeof *does* work on arrays

int filefd = open(..., O_WRONLY | O_CREAT);
while (rbytes > 0) {
    int n = recv(sockfd, buf, sizeof buf, 0);
    if (n > 0) {
        int w = write(filefd, buf, n); // assumes file writes are all or nothing
        if (w < 0) {
            // error
        }
        rbytes -= n;
    } else if (n == 0) {
        // closed
    } else {
        // error
    }
}

close(filefd);
close(sockfd);

// no need to deallocate buf as it's on the stack, not the heap