Sieci Komputerowe

Streaming

Do przesyłania danych video najczęściej stosuje się protokoły warstwy aplikacji wspomagające transmisje danych video i dźwięku RTP

https://en.wikipedia.org/wiki/Real-time_Transport_Protocol

oraz RTSP

https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol

implementacje RTSP w javie można znaleźć np. tutaj

https://inst.eecs.berkeley.edu/~ee122/sp06/ProgAsgns/pa3.html

Co nie znaczy, że nie możemy przesyłać ramek video korzystając z innych protokołów, np. HTTP.

Kamera

Do utworzenia serwera video na naszym telefonie może posłużyć np. aplikacja IP WebCam

https://play.google.com/store/apps/details?id=com.pas.webcam&hl=pl

Z reguły rozwiązania takie pozwalają na przesyłanie video tylko w sieci lokalnej, ale nadal dają duże możliwości. Aplikacja ta wykorzystuje protokół HTTP do przesyłania Video.

KOD

Do pobrania tutaj

http://mw.home.amu.edu.pl/zajecia/SIK2018/SIKZSTREAM.zip

Klient

Prosty klient korzystający z biblioteki OpenCV do odbioru ramek Video:

import org.bytedeco.javacpp.opencv_core;
import org.bytedeco.javacv.*;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;

public class Stream  {

    public static BufferedImage getBufferedImage(Frame frame) {
        OpenCVFrameConverter.ToIplImage toIplImage = new OpenCVFrameConverter.ToIplImage();
        Java2DFrameConverter frameConverter = new Java2DFrameConverter();
        return frameConverter.convert(frame);
    }

    public static void main(String[] args) throws Exception {

        FFmpegFrameGrabber frameGrabber = new FFmpegFrameGrabber("http://192.167.1.100:8080/video");
        frameGrabber.start();

        BufferedImage image = getBufferedImage(frameGrabber.grabFrame());

        CanvasFrame canvasFrame = new CanvasFrame("Camera");
        canvasFrame.setCanvasSize(image.getWidth(), image.getHeight());

        int czy = 1000;
        while (canvasFrame.isVisible() && (image != null)) {
            image = getBufferedImage(frameGrabber.grabFrame());
            canvasFrame.showImage(image);
        }

        frameGrabber.stop();
        canvasFrame.dispose();
        System.exit(0);
    }
}

Utwórz nowy projekt Java typu Maven Project z danymi

<groupId>SIK</groupId>

<artifactId>SIKSTREAM</artifactId>

Zależności w Mavenowym pliku POM potrzebne do uruchomienia pliku przechwytującego ramki:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>SIK</groupId>
    <artifactId>SIKSTREAM</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.openpnp</groupId>
            <artifactId>opencv</artifactId>
            <version>3.2.0-0</version>
        </dependency>
        <dependency>
            <groupId>org.bytedeco.javacpp-presets</groupId>
            <artifactId>opencv</artifactId>
            <version>3.4.0-1.4</version>
        </dependency>
        <dependency>
            <groupId>org.bytedeco</groupId>
            <artifactId>javacv-platform</artifactId>
            <version>1.4.1</version>
        </dependency>

    </dependencies>

</project>

Przesyłanie plików binarnych w sieci

Serwer odbiera plik jako strumień bitów:

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.Charset;

public class FileSerwer {

    public static void main(String[] args) throws IOException {
        ServerSocket servsock = new ServerSocket(8888);
        while (true) {
            Socket sock = servsock.accept();

            System.out.println("Accepted connection : " + sock);

            (new Thread() {
                public void run() {
                    try {
                        InputStream is = sock.getInputStream();
                        byte[] mybytearray = new byte[1000000000];
                        String name = new BufferedReader(new InputStreamReader(is))
                                .readLine();
                        System.out.println(name);
                        OutputStream os = sock.getOutputStream();
                        String mes = "ok\n";
                        os.write(mes.getBytes(Charset.forName("UTF-8")));
                        FileOutputStream fos = new FileOutputStream(name + ".png");
                        BufferedOutputStream bos = new BufferedOutputStream(fos);

                        // read 4 bytes containing the file size
                        byte[] bSize = new byte[4];
                        int offset = 0;
                        while (offset < bSize.length) {
                            int bRead = is.read(bSize, offset, bSize.length - offset);
                            offset += bRead;
                        }
                        // Convert the 4 bytes to an int
                        int fileSize;
                        fileSize = (int) (bSize[0] & 0xff) << 24
                                | (int) (bSize[1] & 0xff) << 16
                                | (int) (bSize[2] & 0xff) << 8
                                | (int) (bSize[3] & 0xff);

                        // buffer to read from the socket
                        // 8k buffer is good enough
                        byte[] data = new byte[8 * 1024];

                        int bToRead;
                        while (fileSize > 0) {
                            // make sure not to read more bytes than filesize
                            if (fileSize > data.length) bToRead = data.length;
                            else bToRead = fileSize;
                            int bytesRead = is.read(data, 0, bToRead);
                            if (bytesRead > 0) {
                                bos.write(data, 0, bytesRead);
                                fileSize -= bytesRead;
                            }
                        }
                        bos.close();

                        is.close();
                        bos.close();
                        sock.close();
                    } catch (Exception e) {
                        System.out.println(e.getStackTrace());
                    }
                }
            }).start();
        }
    }
}

Klient przesyła plik bitowo:

import java.io.*;
import java.net.Socket;

public class FileClient {

    public static void main(String[] argv) throws Exception {

        Socket sock = new Socket("127.0.0.1", 8888);
        sock.setTcpNoDelay(true);

        File myFile = new File("saved.png");
        byte[] mybytearray = new byte[(int) myFile.length()];
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(myFile));

        int fSize = (int) myFile.length();
        // Send the file's size
        byte[] bSize = new byte[4];
        bSize[0] = (byte) ((fSize & 0xff000000) >> 24);
        bSize[1] = (byte) ((fSize & 0x00ff0000) >> 16);
        bSize[2] = (byte) ((fSize & 0x0000ff00) >> 8);
        bSize[3] = (byte) (fSize & 0x000000ff);
        // 4 bytes containing the file size
        os.write(bSize, 0, 4);

        int size = bis.read(mybytearray, 0, mybytearray.length);
        sock.getOutputStream().write(mybytearray, 0, size);
        sock.getOutputStream().flush();
        bis.close();
        os.close();
        sock.close();
    }
}

Zadanie (10 pkt)

Prowadzący uruchomi na swojej komórce serwer streamujący obraz. Twoim zadaniem jest napisać kod, który wykona Twoje zdjęcie oraz prześle je do prowadzącego na podany adres.

Proponuję wykorzystać metodę taką, żeby zasłonić kamerę (wykryć czarne piksele) i zachowywać ramkę następującą ileś po tym zasłonięciu.

Do wykrycia koloru piksela można wykorzystać:

http://stackoverflow.com/questions/22391353/get-color-of-each-pixel-of-an-image-using-bufferedimages

Do zapisuj ramki na dysk:

https://docs.oracle.com/javase/tutorial/2d/images/saveimage.html

Klient powinien przesłać do serwera podanego przez prowadzącego plik ze zdjęciem.

Klient powinien najpierw przesłać jako tekst Państwa nazwisko (ten kod trzeba dopisać do powyższego), na które serwer po odebraniu odpowie komunikatem "ok", następnie powinien być przesłany plik ze zdjęciem.

Proszę o przesłanie PUSTEGO pliku na adres:

https://mw.vm.wmi.amu.edu.pl/login