path: root/main.go

package main

import (
	"bytes"
	"flag"
	"fmt"
	"image"
	"log"
	"net"
	"os"
)

var (
	host = flag.String("host", "127.0.0.1", "Server address (v4)")
	port = flag.String("port", "1337", "Server port")
	address string

	imagePath = flag.String("image", "", "Relative image path")
	imageOffsetX = flag.Int("xoffset", 0, "xoffset")
	imageOffsetY = flag.Int("yoffset", 0, "yoffset")

	canvasWidth = flag.Int("width", 1920, "canvas width")
	canvasHeight = flag.Int("height", 1080, "canvas height")

	testConn = flag.Bool("t", false, "test the connection before escalating completely")

	fill = flag.Bool("fill", true, "fill the complete canvas")
	color = flag.String("col", "000000", "define a color")

	cores = flag.Int("cores", 1, "Amount of cores to use")
)

// parse the command line
func parseFlags() {
	flag.Parse()

	address = fmt.Sprintf("%s:%s", *host, *port)
}

// test the connection to the given server if the -t flag was set
func testConnection() {
	if *testConn == true {
		log.Printf("[ ] Testing Connection: True")

		log.Println("[ ] Testing TCP Connection...")
		testConnectionProtocol("tcp")

	} else {
		log.Printf("[ ] Testing Connection: False")
	}
}

// test connecting to the server using the given protocol ("udp" or "tcp")
func testConnectionProtocol(protocol string) {
	connection, netDialErr := net.Dial(protocol, address)
	if netDialErr != nil {
		log.Fatal(netDialErr)
	}
	connectionCloseError := connection.Close()
	if connectionCloseError != nil {
		log.Fatal(connectionCloseError)
	}
}

func buildSendString(start int, end int, doneChannel chan bool, stripBufferChannel chan bytes.Buffer) {
	fmt.Printf("start: %d \t end: %d\n", start, end)

	var stripBuffer bytes.Buffer
	var currentCommand string

	for x := start; x < end; x++ {
		for y := 0; y < *canvasHeight; y++ {
			// prepare the command that should be written
			currentCommand = fmt.Sprintf("PX %d %d %s\n", x, y, *color)
			stripBuffer.Write([]byte(currentCommand))
		}
	}

	doneChannel <- true
	stripBufferChannel <- stripBuffer
}

// openImage opens an image at the given path and returns an image.Image
func openImage(imagePath string) image.Image {
	log.Println("AA")
	reader, openErr := os.Open(imagePath)
	if openErr != nil {
		log.Fatal(openErr)
	}
	log.Println("AB")

	fmt.Println(*reader)

	img, _, imageDecodeErr := image.Decode(reader)
	if imageDecodeErr != nil {
		log.Fatal(openErr)
	}
	log.Println("AC")

	return img
}

func buildSendStringImage(image image.Image, start int, end int, doneChannel chan bool, stripBufferChannel chan bytes.Buffer) {

	var imageHeight = image.Bounds().Max.Y
	var stripBuffer bytes.Buffer

	fmt.Printf("ImageHeight: %d", imageHeight)

	for x := start; x < end; x++ {
		for y := 0; y < imageHeight; y++ {
			r, g, b, _ := image.At(x, y).RGBA()
			fmt.Printf("%v %v %v", r, g, b)
			command := fmt.Sprintf("PX %d %d %.2x%.2x%.2x", x, y, r, g, b)
			stripBuffer.Write([]byte(command))
		}
	}

	doneChannel <- true
	stripBufferChannel <- stripBuffer
}

func main() {
	log.Printf("[ ] %s -> %s:%s at (%d, %d)", *imagePath, *host, *port, imageOffsetX, imageOffsetY)
	parseFlags()
	testConnection()

	if *fill == true {
		// define channels used to bundle the data generated and get information
		doneChannel := make(chan bool)
		stripBufferChannel := make(chan bytes.Buffer)
		var completeBuffer bytes.Buffer

		// calculate the width of the individual stripes
		var stripwidth int = *canvasWidth / *cores

		// create a new buildStringBot generating the stripes
		for thread := 0; thread < *cores; thread++ {
			log.Printf("Starting thread %d", thread)
			go buildSendString(thread * stripwidth, (thread + 1) * stripwidth, doneChannel, stripBufferChannel)
		}

		// catch all threads
		for thread := 0; thread < *cores; thread++ {
			// get a "Done" message from each worker
			_ = <- doneChannel

			// get the buffer generated and append it to the complete buffer by writing it there
			stripBufferChannelOutput := <- stripBufferChannel
			completeBuffer.Write(stripBufferChannelOutput.Bytes())

			log.Printf("Thread %d done!", thread)
		}

		// write the command to the server
		connection, netDialError := net.Dial("tcp", address)
		if netDialError != nil {
			log.Fatal(netDialError)
		}


		i := 0
		for i < 500 {
			// actual write
			_, writeErr := connection.Write(completeBuffer.Bytes())
			if writeErr != nil {
				log.Fatal(writeErr)
			}

			fmt.Printf(".")
			i++
		}

		fmt.Printf("\n")

		// close the connection
		connectionCloseError := connection.Close()
		if connectionCloseError != nil {
			log.Fatal(connectionCloseError)
		}

		// cleanup
		fmt.Printf("cleanup: %d -> %d", *cores * stripwidth, *canvasWidth)
	}

	if *imagePath != "" {
		log.Println("[ ] Drawing the image!")

		log.Println("A")

		// open the image
		var image = openImage(*imagePath)
		fmt.Println(image)
		log.Println("b")

		// define channels used to bundle the data generated and get informations
		doneChannel := make(chan bool)
		stripBufferChannel := make(chan bytes.Buffer)
		var completeBuffer bytes.Buffer
		log.Println("c")

		// calculate the width of the individual stripes
		var stripwidth int = image.Bounds().Max.X / *cores
		log.Println("d")

		// create new buildSendString workers building the string that should be sent to the pixelflut server
		for thread := 0; thread < *cores; thread++ {
			log.Printf("Staring thread %d", thread)
			go buildSendStringImage(image, thread * stripwidth, (thread+1) * stripwidth, doneChannel, stripBufferChannel)
		}
		log.Println("e")

		// catch all the threads
		for thread := 0; thread < *cores; thread++ {
			// get a "Done" message from each worker
			_ = <- doneChannel

			// get the buffer generated and append it to the complete buffer by writing it there
			stripBufferChannelOutput := <- stripBufferChannel
			completeBuffer.Write(stripBufferChannelOutput.Bytes())

			log.Printf("Thread %d done!")
		}
		log.Println("f")

		// write the command to the server
		connection, netDialError := net.Dial("tcp", address)
		if netDialError != nil {
			log.Fatal(netDialError)
		}
		log.Println("g")

		// actual write
		_, writeErr := connection.Write(completeBuffer.Bytes())
		if writeErr != nil {
			log.Fatal(writeErr)
		}
		log.Println("h")

		// close the connection
		connectionCloseError := connection.Close()
		if connectionCloseError != nil {
			log.Fatal(connectionCloseError)
		}
		log.Println("i")

		// cleanup
		fmt.Printf("cleanup: %d -> %d", *cores * stripwidth, *canvasWidth)
	}
}