Merge pull request #8 from bdhood/master

Add -pix_fmt yuv420p

README.md

@@ -18,7 +18,7 @@ library which made this wrapper possible.
        vnc-recorder [global options] command [command options] [arguments...]
 
     VERSION:
-       1.0
+       0.3.0
 
     AUTHOR:
        Daniel Widerin <daniel@widerin.net>

encoder.go

@@ -10,7 +10,7 @@ import (
 	"fmt"
 	vnc "github.com/amitbet/vnc2video"
 	"github.com/amitbet/vnc2video/encoders"
-	log "github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus"
 	"image"
 	"image/color"
 	"io"
@@ -107,11 +107,11 @@ func encodePPMforRGBImage(w io.Writer, img *vnc.RGBImage) error {
 
 type X264ImageCustomEncoder struct {
 	encoders.X264ImageEncoder
-	FFMpegBinPath string
+	FFMpegBinPath      string
-	cmd           *exec.Cmd
+	cmd                *exec.Cmd
-	input         io.WriteCloser
+	input              io.WriteCloser
-	closed        bool
+	closed             bool
-	Framerate     int
+	Framerate          int
 	ConstantRateFactor int
 }
 
@@ -130,6 +130,7 @@ func (enc *X264ImageCustomEncoder) Init(videoFileName string) {
 		"-preset", "veryfast",
 		"-g", "250",
 		"-crf", strconv.Itoa(enc.ConstantRateFactor),
+		"-pix_fmt", "yuv420p",
 		videoFileName,
 	)
 	cmd.Stdout = os.Stdout
@@ -137,7 +138,7 @@ func (enc *X264ImageCustomEncoder) Init(videoFileName string) {
 	encInput, err := cmd.StdinPipe()
 	enc.input = encInput
 	if err != nil {
-		log.Error("can't get ffmpeg input pipe")
+		logrus.WithError(err).Error("can't get ffmpeg input pipe.")
 	}
 	enc.cmd = cmd
 }
@@ -147,10 +148,10 @@ func (enc *X264ImageCustomEncoder) Run(videoFileName string) error {
 	}
 
 	enc.Init(videoFileName)
-	log.Infof("launching binary: %v", enc.cmd)
+	logrus.Infof("launching binary: %v", enc.cmd)
 	err := enc.cmd.Run()
 	if err != nil {
-		log.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
+		logrus.WithError(err).Errorf("error while launching ffmpeg: %v", enc.cmd.Args)
 		return err
 	}
 	return nil
@@ -162,7 +163,7 @@ func (enc *X264ImageCustomEncoder) Encode(img image.Image) {
 
 	err := encodePPM(enc.input, img)
 	if err != nil {
-		log.Error("error while encoding image:", err)
+		logrus.WithError(err).Error("error while encoding image.")
 	}
 }
 
@@ -173,7 +174,7 @@ func (enc *X264ImageCustomEncoder) Close() {
 	enc.closed = true
 	err := enc.input.Close()
 	if err != nil {
-		log.Error("could not close input", err)
+		logrus.WithError(err).Error("could not close input.")
 	}
 
 }

main.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"fmt"
 	vnc "github.com/amitbet/vnc2video"
-	log "github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus"
-	cli "github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v2"
 	"net"
 
 	"os"
@@ -16,16 +16,11 @@ import (
 	"time"
 )
 
-func init() {
-	log.SetOutput(os.Stdout)
-	log.SetLevel(log.InfoLevel)
-}
-
 func main() {
 	app := &cli.App{
 		Name:    path.Base(os.Args[0]),
 		Usage:   "Connect to a vnc server and record the screen to a video.",
-		Version: "1.0",
+		Version: "0.3.0",
 		Authors: []*cli.Author{
 			&cli.Author{
 				Name:  "Daniel Widerin",
@@ -80,20 +75,20 @@ func main() {
 	}
 
 	if err := app.Run(os.Args); err != nil {
-		log.Fatal(err)
+		logrus.WithError(err).Fatal("recording failed.")
 	}
 }
 
 func recorder(c *cli.Context) error {
 	address := fmt.Sprintf("%s:%d", c.String("host"), c.Int("port"))
-	nc, err := net.DialTimeout("tcp", address, 5*time.Second)
+	dialer, err := net.DialTimeout("tcp", address, 5*time.Second)
 	if err != nil {
-		log.Fatalf("Error connecting to VNC host. %v", err)
+		logrus.WithError(err).Error("connection to VNC host failed.")
 		return err
 	}
-	defer nc.Close()
+	defer dialer.Close()
 
-	log.Infof("Connected to %s", address)
+	logrus.WithField("address", address).Info("connection established.")
 
 	// Negotiate connection with the server.
 	cchServer := make(chan vnc.ServerMessage)
@@ -111,7 +106,7 @@ func recorder(c *cli.Context) error {
 		}
 	}
 
-	ccfg := &vnc.ClientConfig{
+	ccflags := &vnc.ClientConfig{
 		SecurityHandlers: secHandlers,
 		DrawCursor:       true,
 		PixelFormat:      vnc.PixelFormat32bit,
@@ -132,30 +127,31 @@ func recorder(c *cli.Context) error {
 		ErrorCh: errorCh,
 	}
 
-	cc, err := vnc.Connect(context.Background(), nc, ccfg)
+	vncConnection, err := vnc.Connect(context.Background(), dialer, ccflags)
-	defer cc.Close()
+	defer vncConnection.Close()
-
-	screenImage := cc.Canvas
 	if err != nil {
-		log.Fatalf("Error negotiating connection to VNC host. %v", err)
+		logrus.WithError(err).Error("connection negotiation to VNC host failed.")
 		return err
 	}
+	screenImage := vncConnection.Canvas
 
-	ffmpeg_path, err := exec.LookPath(c.String("ffmpeg"))
+	ffmpegPath, err := exec.LookPath(c.String("ffmpeg"))
 	if err != nil {
-		panic(err)
+		logrus.WithError(err).Error("ffmpeg binary not found.")
+		return err
 	}
-	log.Infof("Using %s for encoding", ffmpeg_path)
+	logrus.WithField("ffmpeg", ffmpegPath).Info("ffmpeg binary for recording found")
+
 	vcodec := &X264ImageCustomEncoder{
-		FFMpegBinPath: ffmpeg_path,
+		FFMpegBinPath:      ffmpegPath,
-		Framerate:     c.Int("framerate"),
+		Framerate:          c.Int("framerate"),
 		ConstantRateFactor: c.Int("crf"),
 	}
 
 	//goland:noinspection GoUnhandledErrorResult
 	go vcodec.Run(c.String("outfile"))
 
-	for _, enc := range ccfg.Encodings {
+	for _, enc := range ccflags.Encodings {
 		myRenderer, ok := enc.(vnc.Renderer)
 
 		if ok {
@@ -163,7 +159,7 @@ func recorder(c *cli.Context) error {
 		}
 	}
 
-	cc.SetEncodings([]vnc.EncodingType{
+	vncConnection.SetEncodings([]vnc.EncodingType{
 		vnc.EncCursorPseudo,
 		vnc.EncPointerPosPseudo,
 		vnc.EncCopyRect,
@@ -206,20 +202,28 @@ func recorder(c *cli.Context) error {
 		case err := <-errorCh:
 			panic(err)
 		case msg := <-cchClient:
-			log.Debugf("Received client message type:%v msg:%v\n", msg.Type(), msg)
+			logrus.WithFields(logrus.Fields{
+				"messageType": msg.Type(),
+				"message":     msg,
+			}).Debug("client message received.")
+
 		case msg := <-cchServer:
 			if msg.Type() == vnc.FramebufferUpdateMsgType {
 				secsPassed := time.Now().Sub(timeStart).Seconds()
 				frameBufferReq++
 				reqPerSec := float64(frameBufferReq) / secsPassed
-				log.Debugf("reqs=%d, seconds=%f, Req Per second= %f", frameBufferReq, secsPassed, reqPerSec)
+				logrus.WithFields(logrus.Fields{
+					"reqs":           frameBufferReq,
+					"seconds":        secsPassed,
+					"Req Per second": reqPerSec,
+				}).Debug("framebuffer update")
 
-				reqMsg := vnc.FramebufferUpdateRequest{Inc: 1, X: 0, Y: 0, Width: cc.Width(), Height: cc.Height()}
+				reqMsg := vnc.FramebufferUpdateRequest{Inc: 1, X: 0, Y: 0, Width: vncConnection.Width(), Height: vncConnection.Height()}
-				reqMsg.Write(cc)
+				reqMsg.Write(vncConnection)
 			}
 		case signal := <-sigCh:
 			if signal != nil {
-				log.Info(signal, " received, exit.")
+				logrus.WithField("signal", signal).Info("signal received.")
 				vcodec.Close()
 				// give some time to write the file
 				time.Sleep(time.Second * 1)