Drop custom logger

Signed-off-by: Daniel Widerin <daniel@widerin.net>
2025-09-17 15:32:11 +00:00 · 2019-05-29 21:46:29 +02:00
parent a1552933c5
commit c99297720f
25 changed files with 193 additions and 369 deletions
--- a/client.go
+++ b/client.go
@@ -5,9 +5,9 @@ import (
 	"context"
 	"encoding/binary"
 	"fmt"
+	log "github.com/sirupsen/logrus"
 	"net"
 	"sync"
-	"vnc2video/logger"
 )

 var (
@@ -36,7 +36,7 @@ func Connect(ctx context.Context, c net.Conn, cfg *ClientConfig) (*ClientConn, e

 	for _, h := range cfg.Handlers {
 		if err := h.Handle(conn); err != nil {
-			logger.Error("Handshake failed, check that server is running: ", err)
+			log.Errorf("Handshake failed, check that server is running: ", err)
 			conn.Close()
 			cfg.ErrorCh <- err
 			return nil, err
@@ -257,7 +257,7 @@ type DefaultClientMessageHandler struct{}

 // Handle handles server messages.
 func (*DefaultClientMessageHandler) Handle(c Conn) error {
-	logger.Trace("starting DefaultClientMessageHandler")
+	log.Debug("starting DefaultClientMessageHandler")
 	cfg := c.Config().(*ClientConfig)
 	var err error
 	var wg sync.WaitGroup
@@ -292,7 +292,7 @@ func (*DefaultClientMessageHandler) Handle(c Conn) error {
 					cfg.ErrorCh <- err
 					return
 				}
-				logger.Infof("========got server message, msgType=%d", messageType)
+				log.Infof("========got server message, msgType=%d", messageType)
 				msg, ok := serverMessages[messageType]
 				if !ok {
 					err = fmt.Errorf("unknown message-type: %v", messageType)
@@ -304,7 +304,7 @@ func (*DefaultClientMessageHandler) Handle(c Conn) error {
 				parsedMsg, err := msg.Read(c)
 				canvas.PaintCursor()
 				//canvas.SwapBuffers()
-				logger.Debugf("============== End Message: type=%d ==============", messageType)
+				log.Debugf("============== End Message: type=%d ==============", messageType)

 				if err != nil {
 					cfg.ErrorCh <- err
@@ -325,11 +325,11 @@ func (*DefaultClientMessageHandler) Handle(c Conn) error {
 	for _, value := range encTypes {
 		v = append(v, value)
 	}
-	logger.Tracef("setting encodings: %v", v)
+	log.Debugf("setting encodings: %v", v)
 	c.SetEncodings(v)

 	firstMsg := FramebufferUpdateRequest{Inc: 0, X: 0, Y: 0, Width: c.Width(), Height: c.Height()}
-	logger.Tracef("sending initial req message: %v", firstMsg)
+	log.Debugf("sending initial req message: %v", firstMsg)
 	firstMsg.Write(c)

 	//wg.Wait()
--- a/encoders/dv8-enc.go
+++ b/encoders/dv8-enc.go
@@ -6,7 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"strings"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 type VP8ImageEncoder struct {
@@ -80,21 +80,21 @@ func (enc *VP8ImageEncoder) Init(videoFileName string) {
 	encInput, err := cmd.StdinPipe()
 	enc.input = encInput
 	if err != nil {
-		logger.Error("can't get ffmpeg input pipe")
+		log.Error("can't get ffmpeg input pipe")
 	}
 	enc.cmd = cmd
 }
 func (enc *VP8ImageEncoder) Run(videoFileName string) {
 	if _, err := os.Stat(enc.FFMpegBinPath); os.IsNotExist(err) {
-		logger.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
+		log.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
 		return
 	}

 	enc.Init(videoFileName)
-	logger.Debugf("launching binary: %v", enc.cmd)
+	log.Debugf("launching binary: %v", enc.cmd)
 	err := enc.cmd.Run()
 	if err != nil {
-		logger.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
+		log.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
 	}
 }
 func (enc *VP8ImageEncoder) Encode(img image.Image) {
@@ -104,7 +104,7 @@ func (enc *VP8ImageEncoder) Encode(img image.Image) {

 	err := encodePPM(enc.input, img)
 	if err != nil {
-		logger.Error("error while encoding image:", err)
+		log.Error("error while encoding image:", err)
 	}
 }

--- a/encoders/dv9-enc.go
+++ b/encoders/dv9-enc.go
@@ -6,7 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"strings"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 type DV9ImageEncoder struct {
@@ -67,27 +67,27 @@ func (enc *DV9ImageEncoder) Init(videoFileName string) {
 	encInput, err := cmd.StdinPipe()
 	enc.input = encInput
 	if err != nil {
-		logger.Error("can't get ffmpeg input pipe")
+		log.Error("can't get ffmpeg input pipe")
 	}
 	enc.cmd = cmd
 }
 func (enc *DV9ImageEncoder) Run(videoFileName string) {
 	if _, err := os.Stat(enc.FFMpegBinPath); os.IsNotExist(err) {
-		logger.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
+		log.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
 		return
 	}

 	enc.Init(videoFileName)
-	logger.Debugf("launching binary: %v", enc.cmd)
+	log.Debugf("launching binary: %v", enc.cmd)
 	err := enc.cmd.Run()
 	if err != nil {
-		logger.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
+		log.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
 	}
 }
 func (enc *DV9ImageEncoder) Encode(img image.Image) {
 	err := encodePPM(enc.input, img)
 	if err != nil {
-		logger.Error("error while encoding image:", err)
+		log.Error("error while encoding image:", err)
 	}
 }
 func (enc *DV9ImageEncoder) Close() {
--- a/encoders/huffyuv-enc.go
+++ b/encoders/huffyuv-enc.go
@@ -7,7 +7,7 @@ import (
 	"os"
 	"os/exec"
 	"strings"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 // this is a very common loseless encoder (but produces huge files)
@@ -80,21 +80,21 @@ func (enc *HuffYuvImageEncoder) Init(videoFileName string) {
 	encInput, err := cmd.StdinPipe()
 	enc.input = encInput
 	if err != nil {
-		logger.Error("can't get ffmpeg input pipe")
+		log.Error("can't get ffmpeg input pipe")
 	}
 	enc.cmd = cmd
 }
 func (enc *HuffYuvImageEncoder) Run(videoFileName string) error {
 	if _, err := os.Stat(enc.FFMpegBinPath); os.IsNotExist(err) {
-		logger.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
+		log.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
 		return errors.New("encoder file doesn't exist in path" + videoFileName)
 	}

 	enc.Init(videoFileName)
-	logger.Debugf("launching binary: %v", enc.cmd)
+	log.Debugf("launching binary: %v", enc.cmd)
 	err := enc.cmd.Run()
 	if err != nil {
-		logger.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
+		log.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
 		return err
 	}
 	return nil
@@ -106,7 +106,7 @@ func (enc *HuffYuvImageEncoder) Encode(img image.Image) {

 	err := encodePPM(enc.input, img)
 	if err != nil {
-		logger.Error("error while encoding image:", err)
+		log.Error("error while encoding image:", err)
 	}
 }

--- a/encoders/mjpeg-enc.go
+++ b/encoders/mjpeg-enc.go
@@ -5,8 +5,7 @@ import (
 	"image"
 	"image/jpeg"
 	"strings"
-	"vnc2video/logger"
-
+	log "github.com/sirupsen/logrus"
 	"github.com/icza/mjpeg"
 )

@@ -30,7 +29,7 @@ func (enc *MJPegImageEncoder) Init(videoFileName string) {
 	}
 	avWriter, err := mjpeg.New(videoFileName, 1024, 768, enc.Framerate)
 	if err != nil {
-		logger.Error("Error during mjpeg init: ", err)
+		log.Error("Error during mjpeg init: ", err)
 	}
 	enc.avWriter = avWriter
 }
@@ -50,14 +49,14 @@ func (enc *MJPegImageEncoder) Encode(img image.Image) {
 	}
 	err := jpeg.Encode(buf, img, jOpts)
 	if err != nil {
-		logger.Error("Error while creating jpeg: ", err)
+		log.Error("Error while creating jpeg: ", err)
 	}

 	//logger.Tracef("buff: %v\n", buf.Bytes())

 	err = enc.avWriter.AddFrame(buf.Bytes())
 	if err != nil {
-		logger.Error("Error while adding frame to mjpeg: ", err)
+		log.Error("Error while adding frame to mjpeg: ", err)
 	}
 }

@@ -66,6 +65,6 @@ func (enc *MJPegImageEncoder) Close() {

 	enc.closed = true
 	if err != nil {
-		logger.Error("Error while closing mjpeg: ", err)
+		log.Error("Error while closing mjpeg: ", err)
 	}
 }
--- a/encoders/qtrle-enc.go
+++ b/encoders/qtrle-enc.go
@@ -7,7 +7,7 @@ import (
 	"os"
 	"os/exec"
 	"strings"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 // QTRLEImageEncoder quick time rle is an efficient loseless codec, uses .mov extension
@@ -79,14 +79,14 @@ func (enc *QTRLEImageEncoder) Init(videoFileName string) {
 	encInput, err := cmd.StdinPipe()
 	enc.input = encInput
 	if err != nil {
-		logger.Error("can't get ffmpeg input pipe")
+		log.Error("can't get ffmpeg input pipe")
 	}
 	enc.cmd = cmd
 }
 func (enc *QTRLEImageEncoder) Run(videoFileName string) error {
 	if _, err := os.Stat(enc.FFMpegBinPath); os.IsNotExist(err) {
 		if _, err := os.Stat(enc.FFMpegBinPath + ".exe"); os.IsNotExist(err) {
-			logger.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
+			log.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
 			return errors.New("encoder file doesn't exist in path" + videoFileName)
 		} else {
 			enc.FFMpegBinPath = enc.FFMpegBinPath + ".exe"
@@ -94,10 +94,10 @@ func (enc *QTRLEImageEncoder) Run(videoFileName string) error {
 	}

 	enc.Init(videoFileName)
-	logger.Debugf("launching binary: %v", enc.cmd)
+	log.Debugf("launching binary: %v", enc.cmd)
 	err := enc.cmd.Run()
 	if err != nil {
-		logger.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
+		log.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
 		return err
 	}
 	return nil
@@ -109,7 +109,7 @@ func (enc *QTRLEImageEncoder) Encode(img image.Image) {

 	err := encodePPM(enc.input, img)
 	if err != nil {
-		logger.Error("error while encoding image:", err)
+		log.Error("error while encoding image:", err)
 	}
 }

--- a/encoders/x264-enc.go
+++ b/encoders/x264-enc.go
@@ -8,7 +8,7 @@ import (
 	"os/exec"
 	"strconv"
 	"strings"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 type X264ImageEncoder struct {
@@ -79,14 +79,14 @@ func (enc *X264ImageEncoder) Init(videoFileName string) {
 	encInput, err := cmd.StdinPipe()
 	enc.input = encInput
 	if err != nil {
-		logger.Error("can't get ffmpeg input pipe")
+		log.Error("can't get ffmpeg input pipe")
 	}
 	enc.cmd = cmd
 }
 func (enc *X264ImageEncoder) Run(videoFileName string) error {
 	if _, err := os.Stat(enc.FFMpegBinPath); os.IsNotExist(err) {
 		if _, err := os.Stat(enc.FFMpegBinPath + ".exe"); os.IsNotExist(err) {
-			logger.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
+			log.Error("encoder file doesn't exist in path:", enc.FFMpegBinPath)
 			return errors.New("encoder file doesn't exist in path" + videoFileName)
 		} else {
 			enc.FFMpegBinPath = enc.FFMpegBinPath + ".exe"
@@ -94,10 +94,10 @@ func (enc *X264ImageEncoder) Run(videoFileName string) error {
 	}

 	enc.Init(videoFileName)
-	logger.Debugf("launching binary: %v", enc.cmd)
+	log.Debugf("launching binary: %v", enc.cmd)
 	err := enc.cmd.Run()
 	if err != nil {
-		logger.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
+		log.Errorf("error while launching ffmpeg: %v\n err: %v", enc.cmd.Args, err)
 		return err
 	}
 	return nil
@@ -109,7 +109,7 @@ func (enc *X264ImageEncoder) Encode(img image.Image) {

 	err := encodePPM(enc.input, img)
 	if err != nil {
-		logger.Error("error while encoding image:", err)
+		log.Error("error while encoding image:", err)
 	}
 }

--- a/encoding_copyrect.go
+++ b/encoding_copyrect.go
@@ -2,9 +2,9 @@ package vnc2video

 import (
 	"encoding/binary"
+	log "github.com/sirupsen/logrus"
 	"image"
 	"image/draw"
-	"vnc2video/logger"
 )

 type CopyRectEncoding struct {
@@ -21,12 +21,12 @@ func (*CopyRectEncoding) Reset() error {
 func (*CopyRectEncoding) Type() EncodingType { return EncCopyRect }

 func (enc *CopyRectEncoding) SetTargetImage(img draw.Image) {
-	//logger.Tracef("!!!!!!!!!!!!!setting image: %v", img.Bounds())
+	//log.Debugf("!!!!!!!!!!!!!setting image: %v", img.Bounds())
 	enc.Image = img
 }

 func (enc *CopyRectEncoding) Read(c Conn, rect *Rectangle) error {
-	logger.Tracef("Reading: CopyRect %v", rect)
+	log.Debugf("Reading: CopyRect %v", rect)
 	if err := binary.Read(c, binary.BigEndian, &enc.SX); err != nil {
 		return err
 	}
--- a/encoding_cursor.go
+++ b/encoding_cursor.go
@@ -2,10 +2,10 @@ package vnc2video

 import (
 	"encoding/binary"
+	log "github.com/sirupsen/logrus"
 	"image"
 	"image/color"
 	"image/draw"
-	"vnc2video/logger"
 )

 type CursorPseudoEncoding struct {
@@ -29,7 +29,7 @@ func (enc *CursorPseudoEncoding) Reset() error {
 func (*CursorPseudoEncoding) Type() EncodingType { return EncCursorPseudo }

 func (enc *CursorPseudoEncoding) Read(c Conn, rect *Rectangle) error {
-	logger.Tracef("CursorPseudoEncoding.Read: got rect: %v", rect)
+	log.Debugf("CursorPseudoEncoding.Read: got rect: %v", rect)
 	//rgba := make([]byte, int(rect.Height)*int(rect.Width)*int(c.PixelFormat().BPP/8))
 	numColors := int(rect.Height) * int(rect.Width)
 	colors := make([]color.Color, numColors)
@@ -67,7 +67,7 @@ func (enc *CursorPseudoEncoding) Read(c Conn, rect *Rectangle) error {
 				cursorImg.Set(x, y, colors[offset])
 				//cursorMask.Set(x, y, color.RGBA{1, 1, 1, 1})
 				cursorMask[x][y] = true
-				//logger.Tracef("CursorPseudoEncoding.Read: setting pixel: (%d,%d) %v", x+int(rect.X), y+int(rect.Y), colors[offset])
+				//log.Debugf("CursorPseudoEncoding.Read: setting pixel: (%d,%d) %v", x+int(rect.X), y+int(rect.Y), colors[offset])
 			}
 		}
 	}
--- a/encoding_hextile.go
+++ b/encoding_hextile.go
@@ -1,11 +1,11 @@
 package vnc2video

 import (
+	log "github.com/sirupsen/logrus"
 	"image"
 	"image/color"
 	"image/draw"
 	"io"
-	"vnc2video/logger"
 )

 const (
@@ -62,7 +62,7 @@ func (z *HextileEncoding) Read(r Conn, rect *Rectangle) error {
 	// defer func() {
 	// 	z.bytes = r.EndByteCollection()
 	// }()
-	logger.Tracef("HextileEncoding.Read: got hextile rect: %v", rect)
+	log.Debugf("HextileEncoding.Read: got hextile rect: %v", rect)
 	for ty := rect.Y; ty < rect.Y+rect.Height; ty += 16 {
 		th := 16
 		if rect.Y+rect.Height-ty < 16 {
@@ -79,7 +79,7 @@ func (z *HextileEncoding) Read(r Conn, rect *Rectangle) error {
 			subencoding, err = ReadUint8(r)

 			if err != nil {
-				logger.Errorf("HextileEncoding.Read: error in hextile reader: %v", err)
+				log.Errorf("HextileEncoding.Read: error in hextile reader: %v", err)
 				return err
 			}

@@ -94,25 +94,25 @@ func (z *HextileEncoding) Read(r Conn, rect *Rectangle) error {

 				bgCol, err = ReadColor(r, &pf)
 				if err != nil {
-					logger.Errorf("HextileEncoding.Read: error in hextile bg color reader: %v", err)
+					log.Errorf("HextileEncoding.Read: error in hextile bg color reader: %v", err)
 					return err
 				}

-				//logger.Tracef("%v %v", rBounds, bgCol)
+				//log.Debugf("%v %v", rBounds, bgCol)
 			}
 			rBounds := image.Rectangle{Min: image.Point{int(tx), int(ty)}, Max: image.Point{int(tx) + int(tw), int(ty) + int(th)}}
-			//logger.Tracef("filling background rect: %v, col: %v", rBounds, bgCol)
+			//log.Debugf("filling background rect: %v, col: %v", rBounds, bgCol)
 			FillRect(z.Image, &rBounds, bgCol)

 			if (subencoding & HextileForegroundSpecified) != 0 {
 				fgCol, err = ReadColor(r, &pf)
 				if err != nil {
-					logger.Errorf("HextileEncoding.Read: error in hextile fg color reader: %v", err)
+					log.Errorf("HextileEncoding.Read: error in hextile fg color reader: %v", err)
 					return err
 				}
 			}
 			if (subencoding & HextileAnySubrects) == 0 {
-				//logger.Trace("hextile reader: no Subrects")
+				//log.Trace("hextile reader: no Subrects")
 				continue
 			}

@@ -127,7 +127,7 @@ func (z *HextileEncoding) Read(r Conn, rect *Rectangle) error {
 				if colorSpecified {
 					color, err = ReadColor(r, &pf)
 					if err != nil {
-						logger.Error("HextileEncoding.Read: problem reading color from connection: ", err)
+						log.Error("HextileEncoding.Read: problem reading color from connection: ", err)
 						return err
 					}
 				} else {
@@ -137,21 +137,21 @@ func (z *HextileEncoding) Read(r Conn, rect *Rectangle) error {
 				fgCol = color
 				dimensions, err = ReadUint8(r) // bits 7-4 for x, bits 3-0 for y
 				if err != nil {
-					logger.Error("HextileEncoding.Read: problem reading dimensions from connection: ", err)
+					log.Error("HextileEncoding.Read: problem reading dimensions from connection: ", err)
 					return err
 				}
 				subtileX := dimensions >> 4 & 0x0f
 				subtileY := dimensions & 0x0f
 				dimensions, err = ReadUint8(r) // bits 7-4 for w, bits 3-0 for h
 				if err != nil {
-					logger.Error("HextileEncoding.Read: problem reading 2nd dimensions from connection: ", err)
+					log.Error("HextileEncoding.Read: problem reading 2nd dimensions from connection: ", err)
 					return err
 				}
 				subtileWidth := 1 + (dimensions >> 4 & 0x0f)
 				subtileHeight := 1 + (dimensions & 0x0f)
 				subrectBounds := image.Rectangle{Min: image.Point{int(tx) + int(subtileX), int(ty) + int(subtileY)}, Max: image.Point{int(tx) + int(subtileX) + int(subtileWidth), int(ty) + int(subtileY) + int(subtileHeight)}}
 				FillRect(z.Image, &subrectBounds, color)
-				//logger.Tracef("%v", subrectBounds)
+				//log.Debugf("%v", subrectBounds)
 			}
 		}
 	}
--- a/encoding_pointer_pos.go
+++ b/encoding_pointer_pos.go
@@ -1,9 +1,9 @@
 package vnc2video

 import (
+	log "github.com/sirupsen/logrus"
 	"image"
 	"image/draw"
-	"vnc2video/logger"
 )

 type CursorPosPseudoEncoding struct {
@@ -28,7 +28,7 @@ func (enc *CursorPosPseudoEncoding) Reset() error {
 func (*CursorPosPseudoEncoding) Type() EncodingType { return EncPointerPosPseudo }

 func (enc *CursorPosPseudoEncoding) Read(c Conn, rect *Rectangle) error {
-	logger.Tracef("CursorPosPseudoEncoding: got cursot pos update: %v", rect)
+	log.Debugf("CursorPosPseudoEncoding: got cursot pos update: %v", rect)
 	canvas := enc.Image.(*VncCanvas)
 	canvas.CursorLocation = &image.Point{X: int(rect.X), Y: int(rect.Y)}
 	return nil
--- a/encoding_tight.go
+++ b/encoding_tight.go
@@ -6,12 +6,12 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	log "github.com/sirupsen/logrus"
 	"image"
 	"image/color"
 	"image/draw"
 	"image/jpeg"
 	"io"
-	"vnc2video/logger"
 )

 //go:generate stringer -type=TightCompression
@@ -135,10 +135,10 @@ func (enc *TightEncoding) Reset() error {
 }

 func (enc *TightEncoding) resetDecoders(compControl uint8) {
-	logger.Tracef("###resetDecoders compctl :%d", 0x0F&compControl)
+	log.Debugf("###resetDecoders compctl :%d", 0x0F&compControl)
 	for i := 0; i < 4; i++ {
 		if (compControl&1) != 0 && enc.decoders[i] != nil {
-			logger.Tracef("###resetDecoders - resetting decoder #%d", i)
+			log.Debugf("###resetDecoders - resetting decoder #%d", i)
 			enc.decoders[i] = nil //.(zlib.Resetter).Reset(nil,nil);
 		}
 		compControl >>= 1
@@ -184,34 +184,34 @@ func (enc *TightEncoding) Read(c Conn, rect *Rectangle) error {
 	// defer func() { counter++ }()
 	// defer jpeg.Encode(out, enc.Image, nil)
 	//////////////
-	logger.Tracef("-----------READ-Tight-encoding compctl=%d -------------", compctl)
+	log.Debugf("-----------READ-Tight-encoding compctl=%d -------------", compctl)

 	if err != nil {
-		logger.Errorf("error in handling tight encoding: %v", err)
+		log.Errorf("error in handling tight encoding: %v", err)
 		return err
 	}
-	//logger.Tracef("bytesPixel= %d, subencoding= %d", bytesPixel, compctl)
+	//log.Debugf("bytesPixel= %d, subencoding= %d", bytesPixel, compctl)
 	enc.resetDecoders(compctl)

 	//move it to position (remove zlib flush commands)
 	compType := compctl >> 4 & 0x0F

-	//logger.Tracef("afterSHL:%d", compType)
+	//log.Debugf("afterSHL:%d", compType)
 	switch compType {
 	case TightCompressionFill:
-		logger.Tracef("--TIGHT_FILL: reading fill size=%d,counter=%d", bytesPixel, counter)
+		log.Debugf("--TIGHT_FILL: reading fill size=%d,counter=%d", bytesPixel, counter)
 		//read color

 		rectColor, err := getTightColor(c, &pixelFmt)
 		if err != nil {
-			logger.Errorf("error in reading tight encoding: %v", err)
+			log.Errorf("error in reading tight encoding: %v", err)
 			return err
 		}

 		//c1 := color.RGBAModel.Convert(rectColor).(color.RGBA)
 		dst := (enc.Image).(draw.Image) // enc.Image.(*image.RGBA)
 		myRect := MakeRectFromVncRect(rect)
-		logger.Tracef("--TIGHT_FILL: fill rect=%v,color=%v", myRect, rectColor)
+		log.Debugf("--TIGHT_FILL: fill rect=%v,color=%v", myRect, rectColor)
 		if !disableFill {
 			FillRect(dst, &myRect, rectColor)
 		}
@@ -221,7 +221,7 @@ func (enc *TightEncoding) Read(c Conn, rect *Rectangle) error {
 		}
 		return nil
 	case TightCompressionJPEG:
-		logger.Tracef("--TIGHT_JPEG,counter=%d", counter)
+		log.Debugf("--TIGHT_JPEG,counter=%d", counter)
 		if pixelFmt.BPP == 8 {
 			return errors.New("Tight encoding: JPEG is not supported in 8 bpp mode")
 		}
@@ -231,7 +231,7 @@ func (enc *TightEncoding) Read(c Conn, rect *Rectangle) error {
 		if err != nil {
 			return err
 		}
-		//logger.Tracef("reading jpeg, size=%d\n", len)
+		//log.Debugf("reading jpeg, size=%d\n", len)
 		jpegBytes, err := ReadBytes(len, c)
 		if err != nil {
 			return err
@@ -240,9 +240,9 @@ func (enc *TightEncoding) Read(c Conn, rect *Rectangle) error {
 		buff := bytes.NewBuffer(jpegBytes)
 		img, err := jpeg.Decode(buff)
 		if err != nil {
-			logger.Error("problem while decoding jpeg:", err)
+			log.Error("problem while decoding jpeg:", err)
 		}
-		//logger.Info("not drawing:", img)
+		//log.Info("not drawing:", img)
 		if !disableJpeg {
 			pos := image.Point{int(rect.X), int(rect.Y)}
 			DrawImage(enc.Image, img, pos)
@@ -254,7 +254,7 @@ func (enc *TightEncoding) Read(c Conn, rect *Rectangle) error {
 	default:

 		if compType > TightCompressionJPEG {
-			logger.Error("Compression control byte is incorrect!")
+			log.Error("Compression control byte is incorrect!")
 		}

 		enc.handleTightFilters(compctl, &pixelFmt, rect, c)
@@ -282,15 +282,15 @@ func (enc *TightEncoding) handleTightFilters(compCtl uint8, pixelFmt *PixelForma
 		filterid, err = ReadUint8(r)

 		if err != nil {
-			logger.Errorf("error in handling tight encoding, reading filterid: %v", err)
+			log.Errorf("error in handling tight encoding, reading filterid: %v", err)
 			return
 		}
-		//logger.Tracef("handleTightFilters: read filter: %d", filterid)
+		//log.Debugf("handleTightFilters: read filter: %d", filterid)
 	}

 	bytesPixel := calcTightBytePerPixel(pixelFmt)

-	//logger.Tracef("handleTightFilters: filter: %d", filterid)
+	//log.Debugf("handleTightFilters: filter: %d", filterid)

 	lengthCurrentbpp := int(bytesPixel) * int(rect.Width) * int(rect.Height)

@@ -299,12 +299,12 @@ func (enc *TightEncoding) handleTightFilters(compCtl uint8, pixelFmt *PixelForma

 		palette, err := enc.readTightPalette(r, bytesPixel)
 		if err != nil {
-			logger.Errorf("handleTightFilters: error in Reading Palette: %v", err)
+			log.Errorf("handleTightFilters: error in Reading Palette: %v", err)
 			return
 		}
-		logger.Debugf("----PALETTE_FILTER,palette len=%d counter=%d, rect= %v", len(palette), counter, rect)
+		log.Debugf("----PALETTE_FILTER,palette len=%d counter=%d, rect= %v", len(palette), counter, rect)

-		//logger.Tracef("got palette: %v", palette)
+		//log.Debugf("got palette: %v", palette)
 		var dataLength int
 		if len(palette) == 2 {
 			dataLength = int(rect.Height) * ((int(rect.Width) + 7) / 8)
@@ -312,22 +312,22 @@ func (enc *TightEncoding) handleTightFilters(compCtl uint8, pixelFmt *PixelForma
 			dataLength = int(rect.Width) * int(rect.Height)
 		}
 		tightBytes, err := enc.ReadTightData(dataLength, r, int(decoderId))
-		//logger.Tracef("got tightBytes: %v", tightBytes)
+		//log.Debugf("got tightBytes: %v", tightBytes)
 		if err != nil {
-			logger.Errorf("handleTightFilters: error in handling tight encoding, reading palette filter data: %v", err)
+			log.Errorf("handleTightFilters: error in handling tight encoding, reading palette filter data: %v", err)
 			return
 		}
-		//logger.Errorf("handleTightFilters: got tight data: %v", tightBytes)
+		//log.Errorf("handleTightFilters: got tight data: %v", tightBytes)
 		if !disablePalette {
 			enc.drawTightPalette(rect, palette, tightBytes)
 		}
 		//enc.Image = myImg
 	case TightFilterGradient: //GRADIENT_FILTER
-		logger.Debugf("----GRADIENT_FILTER: bytesPixel=%d, counter=%d", bytesPixel, counter)
-		//logger.Tracef("usegrad: %d\n", filterid)
+		log.Debugf("----GRADIENT_FILTER: bytesPixel=%d, counter=%d", bytesPixel, counter)
+		//log.Debugf("usegrad: %d\n", filterid)
 		data, err := enc.ReadTightData(lengthCurrentbpp, r, int(decoderId))
 		if err != nil {
-			logger.Errorf("handleTightFilters: error in handling tight encoding, Reading GRADIENT_FILTER: %v", err)
+			log.Errorf("handleTightFilters: error in handling tight encoding, Reading GRADIENT_FILTER: %v", err)
 			return
 		}

@@ -335,19 +335,19 @@ func (enc *TightEncoding) handleTightFilters(compCtl uint8, pixelFmt *PixelForma

 	case TightFilterCopy: //BASIC_FILTER
 		//lengthCurrentbpp1 := int(pixelFmt.BPP/8) * int(rect.Width) * int(rect.Height)
-		logger.Debugf("----BASIC_FILTER: bytesPixel=%d, counter=%d", bytesPixel, counter)
+		log.Debugf("----BASIC_FILTER: bytesPixel=%d, counter=%d", bytesPixel, counter)

 		tightBytes, err := enc.ReadTightData(lengthCurrentbpp, r, int(decoderId))
 		if err != nil {
-			logger.Errorf("handleTightFilters: error in handling tight encoding, Reading BASIC_FILTER: %v", err)
+			log.Errorf("handleTightFilters: error in handling tight encoding, Reading BASIC_FILTER: %v", err)
 			return
 		}
-		logger.Tracef("tightBytes len= %d", len(tightBytes))
+		log.Debugf("tightBytes len= %d", len(tightBytes))
 		if !disableCopy {
 			enc.drawTightBytes(tightBytes, rect)
 		}
 	default:
-		logger.Errorf("handleTightFilters: Bad tight filter id: %d", filterid)
+		log.Errorf("handleTightFilters: Bad tight filter id: %d", filterid)
 		return
 	}

@@ -358,7 +358,7 @@ func (enc *TightEncoding) drawTightPalette(rect *Rectangle, palette color.Palett
 	bytePos := 0
 	bitPos := uint8(7)
 	var palettePos int
-	logger.Tracef("drawTightPalette numbytes=%d", len(tightBytes))
+	log.Debugf("drawTightPalette numbytes=%d", len(tightBytes))

 	for y := 0; y < int(rect.Height); y++ {
 		for x := 0; x < int(rect.Width); x++ {
@@ -371,7 +371,7 @@ func (enc *TightEncoding) drawTightPalette(rect *Rectangle, palette color.Palett
 					palettePos = 1
 				}

-				//logger.Tracef("currByte=%d, bitpos=%d, bytepos=%d, palettepos=%d, mask=%d, totalBytes=%d", currByte, bitPos, bytePos, palettePos, mask, len(tightBytes))
+				//log.Debugf("currByte=%d, bitpos=%d, bytepos=%d, palettepos=%d, mask=%d, totalBytes=%d", currByte, bitPos, bytePos, palettePos, mask, len(tightBytes))

 				if bitPos == 0 {
 					bytePos++
@@ -383,7 +383,7 @@ func (enc *TightEncoding) drawTightPalette(rect *Rectangle, palette color.Palett
 			}
 			//palettePos = palettePos
 			enc.Image.Set(int(rect.X)+x, int(rect.Y)+y, palette[palettePos])
-			//logger.Tracef("(%d,%d): pos: %d col:%d", int(rect.X)+j, int(rect.Y)+i, palettePos, palette[palettePos])
+			//log.Debugf("(%d,%d): pos: %d col:%d", int(rect.X)+j, int(rect.Y)+i, palettePos, palette[palettePos])
 		}

 		// reset bit alignment to first bit in byte (msb)
@@ -393,7 +393,7 @@ func (enc *TightEncoding) drawTightPalette(rect *Rectangle, palette color.Palett
 }
 func (enc *TightEncoding) decodeGradData(rect *Rectangle, buffer []byte) {

-	logger.Tracef("putting gradient size: %v on image: %v", rect, enc.Image.Bounds())
+	log.Debugf("putting gradient size: %v on image: %v", rect, enc.Image.Bounds())

 	prevRow := make([]byte, rect.Width*3+3) //new byte[w * 3];
 	thisRow := make([]byte, rect.Width*3+3) //new byte[w * 3];
@@ -446,7 +446,7 @@ func (enc *TightEncoding) decodeGradData(rect *Rectangle, buffer []byte) {
 			if !disableGradient {
 				enc.Image.Set(idx/3+int(rect.X)-1, int(rect.Y)+i, myColor)
 			}
-			//logger.Tracef("putting pixel: idx=%d, pos=(%d,%d), col=%v", idx, idx/3+int(rect.X), int(rect.Y)+i, myColor)
+			//log.Debugf("putting pixel: idx=%d, pos=(%d,%d), col=%v", idx, idx/3+int(rect.X), int(rect.Y)+i, myColor)

 		}

@@ -458,7 +458,7 @@ func (enc *TightEncoding) decodeGradData(rect *Rectangle, buffer []byte) {
 }

 // func (enc *TightEncoding) decodeGradientData(rect *Rectangle, buf []byte) {
-// 	logger.Tracef("putting gradient on image: %v", enc.Image.Bounds())
+// 	log.Debugf("putting gradient on image: %v", enc.Image.Bounds())
 // 	var dx, dy, c int
 // 	prevRow := make([]byte, rect.Width*3) //new byte[w * 3];
 // 	thisRow := make([]byte, rect.Width*3) //new byte[w * 3];
@@ -475,7 +475,7 @@ func (enc *TightEncoding) decodeGradData(rect *Rectangle, buffer []byte) {
 // 			pix[c] = byte(prevRow[c] + buf[dy*int(rect.Width)*3+c])
 // 			thisRow[c] = pix[c]
 // 		}
-// 		//logger.Tracef("putting pixel:%d,%d,%d at offset: %d, pixArrayLen= %v, rect=x:%d,y:%d,w:%d,h:%d, Yposition=%d", pix[0], pix[1], pix[2], offset, len(dst.Pix), rect.X, rect.Y, rect.Width, rect.Height, dy)
+// 		//log.Debugf("putting pixel:%d,%d,%d at offset: %d, pixArrayLen= %v, rect=x:%d,y:%d,w:%d,h:%d, Yposition=%d", pix[0], pix[1], pix[2], offset, len(dst.Pix), rect.X, rect.Y, rect.Width, rect.Height, dy)
 // 		myColor := color.RGBA{R: (pix[0]), G: (pix[1]), B: (pix[2]), A: 1}
 // 		dst.Set(int(rect.X), dy+int(rect.Y), myColor)

@@ -491,7 +491,7 @@ func (enc *TightEncoding) decodeGradData(rect *Rectangle, buffer []byte) {
 // 				pix[c] = (byte)(byte(est[c]) + buf[(dy*int(rect.Width)+dx)*3+c])
 // 				thisRow[dx*3+c] = pix[c]
 // 			}
-// 			//logger.Tracef("putting pixel:%d,%d,%d at offset: %d, pixArrayLen= %v, rect=x:%d,y:%d,w:%d,h:%d, Yposition=%d", pix[0], pix[1], pix[2], offset, len(dst.Pix), x, y, w, h, dy)
+// 			//log.Debugf("putting pixel:%d,%d,%d at offset: %d, pixArrayLen= %v, rect=x:%d,y:%d,w:%d,h:%d, Yposition=%d", pix[0], pix[1], pix[2], offset, len(dst.Pix), x, y, w, h, dy)
 // 			myColor := color.RGBA{R: pix[0], G: (pix[1]), B: (pix[2]), A: 1}
 // 			dst.Set(dx+int(rect.X), dy+int(rect.Y), myColor)

@@ -509,14 +509,14 @@ func ReadBytes(count int, r io.Reader) ([]byte, error) {

 	//lengthRead, err := r.Read(buff)
 	if lengthRead != count {
-		logger.Errorf("RfbReadHelper.ReadBytes unable to read bytes: lengthRead=%d, countExpected=%d", lengthRead, count)
+		log.Errorf("RfbReadHelper.ReadBytes unable to read bytes: lengthRead=%d, countExpected=%d", lengthRead, count)
 		return nil, errors.New("RfbReadHelper.ReadBytes unable to read bytes")
 	}

 	//err := binary.Read(r, binary.BigEndian, &buff)

 	if err != nil {
-		logger.Errorf("RfbReadHelper.ReadBytes error while reading bytes: ", err)
+		log.Errorf("RfbReadHelper.ReadBytes error while reading bytes: ", err)
 		//if err := binary.Read(d.conn, binary.BigEndian, &buff); err != nil {
 		return nil, err
 	}
@@ -528,16 +528,16 @@ func (enc *TightEncoding) readTightPalette(connReader Conn, bytesPixel int) (col

 	colorCount, err := ReadUint8(connReader)
 	if err != nil {
-		logger.Errorf("handleTightFilters: error in handling tight encoding, reading TightFilterPalette: %v", err)
+		log.Errorf("handleTightFilters: error in handling tight encoding, reading TightFilterPalette: %v", err)
 		return nil, err
 	}

 	paletteSize := colorCount + 1 // add one more
-	//logger.Tracef("----PALETTE_FILTER: paletteSize=%d bytesPixel=%d\n", paletteSize, bytesPixel)
+	//log.Debugf("----PALETTE_FILTER: paletteSize=%d bytesPixel=%d\n", paletteSize, bytesPixel)
 	//complete palette
 	paletteColorBytes, err := ReadBytes(int(paletteSize)*bytesPixel, connReader)
 	if err != nil {
-		logger.Errorf("handleTightFilters: error in handling tight encoding, reading TightFilterPalette.paletteSize: %v", err)
+		log.Errorf("handleTightFilters: error in handling tight encoding, reading TightFilterPalette.paletteSize: %v", err)
 		return nil, err
 	}
 	var paletteColors color.Palette = make([]color.Color, 0)
@@ -550,12 +550,12 @@ func (enc *TightEncoding) readTightPalette(connReader Conn, bytesPixel int) (col

 func (enc *TightEncoding) ReadTightData(dataSize int, c Conn, decoderId int) ([]byte, error) {

-	logger.Tracef(">>> Reading zipped tight data from decoder Id: %d, openSize: %d", decoderId, dataSize)
+	log.Debugf(">>> Reading zipped tight data from decoder Id: %d, openSize: %d", decoderId, dataSize)
 	if int(dataSize) < TightMinToCompress {
 		return ReadBytes(int(dataSize), c)
 	}
 	zlibDataLen, err := readTightLength(c)
-	//logger.Tracef("RfbReadHelper.ReadTightData: compactlen=%d", zlibDataLen)
+	//log.Debugf("RfbReadHelper.ReadTightData: compactlen=%d", zlibDataLen)
 	if err != nil {
 		return nil, err
 	}
@@ -680,12 +680,12 @@ func readTightLength(c Conn) (int, error) {
 */
 func (enc *TightEncoding) drawTightBytes(bytes []byte, rect *Rectangle) {
 	bytesPos := 0
-	logger.Tracef("drawTightBytes: len(bytes)= %d, %v", len(bytes), rect)
+	log.Debugf("drawTightBytes: len(bytes)= %d, %v", len(bytes), rect)

 	for ly := rect.Y; ly < rect.Y+rect.Height; ly++ {
 		for lx := rect.X; lx < rect.X+rect.Width; lx++ {
 			color := color.RGBA{R: bytes[bytesPos], G: bytes[bytesPos+1], B: bytes[bytesPos+2], A: 1}
-			//logger.Tracef("drawTightBytes: setting pixel= (%d,%d): %v", int(lx), int(ly), color)
+			//log.Debugf("drawTightBytes: setting pixel= (%d,%d): %v", int(lx), int(ly), color)
 			enc.Image.Set(int(lx), int(ly), color)

 			bytesPos += 3
--- a/encoding_tightpng.go
+++ b/encoding_tightpng.go
@@ -4,12 +4,12 @@ import (
 	"bytes"
 	"encoding/binary"
 	"fmt"
+	log "github.com/sirupsen/logrus"
 	"image"
 	"image/color"
 	"image/draw"
 	"image/png"
 	"io"
-	"vnc2video/logger"
 )

 func (*TightPngEncoding) Supported(Conn) bool {
@@ -65,7 +65,7 @@ func (*TightPngEncoding) Type() EncodingType { return EncTightPng }

 func (enc *TightPngEncoding) Read(c Conn, rect *Rectangle) error {
 	tcc, err := readTightCC(c)
-	logger.Trace("starting to read a tight rect: %v", rect)
+	log.Debugf("starting to read a tight rect: %v", rect)
 	if err != nil {
 		return err
 	}
--- a/encoding_util.go
+++ b/encoding_util.go
@@ -74,12 +74,12 @@ func (c *VncCanvas) RemoveCursor() image.Image {
 			col := c.CursorBackup.At(x, y)
 			//mask := c.CursorMask.At(x, y).(color.RGBA)
 			mask := c.CursorMask[x][y]
-			//logger.Info("Drawing Cursor: ", x, y, col, mask)
+			//log.Info("Drawing Cursor: ", x, y, col, mask)
 			if mask {
-				//logger.Info("Drawing Cursor for real: ", x, y, col)
+				//log.Info("Drawing Cursor for real: ", x, y, col)
 				img.Set(x+loc.X-c.CursorOffset.X, y+loc.Y-c.CursorOffset.Y, col)
 			}
-			// 	//logger.Tracef("CursorPseudoEncoding.Read: setting pixel: (%d,%d) %v", x+int(rect.X), y+int(rect.Y), colors[offset])
+			// 	//log.Debugf("CursorPseudoEncoding.Read: setting pixel: (%d,%d) %v", x+int(rect.X), y+int(rect.Y), colors[offset])
 			// }
 		}
 	}
@@ -118,14 +118,14 @@ func (c *VncCanvas) PaintCursor() image.Image {
 			//c.CursorBackup.Set(x, y, backup)
 			//backup the previous data at this point

-			//logger.Info("Drawing Cursor: ", x, y, col, mask)
+			//log.Info("Drawing Cursor: ", x, y, col, mask)
 			if mask {

 				c.CursorBackup.Set(x, y, backup)
-				//logger.Info("Drawing Cursor for real: ", x, y, col)
+				//log.Info("Drawing Cursor for real: ", x, y, col)
 				img.Set(x+loc.X-c.CursorOffset.X, y+loc.Y-c.CursorOffset.Y, col)
 			}
-			// 	//logger.Tracef("CursorPseudoEncoding.Read: setting pixel: (%d,%d) %v", x+int(rect.X), y+int(rect.Y), colors[offset])
+			// 	//log.Debugf("CursorPseudoEncoding.Read: setting pixel: (%d,%d) %v", x+int(rect.X), y+int(rect.Y), colors[offset])
 			// }
 		}
 	}
--- a/encoding_zrle.go
+++ b/encoding_zrle.go
@@ -4,10 +4,10 @@ import (
 	"bytes"
 	"compress/zlib"
 	"errors"
+	log "github.com/sirupsen/logrus"
 	"image/color"
 	"image/draw"
 	"io"
-	"vnc2video/logger"
 )

 type ZRLEEncoding struct {
@@ -57,7 +57,7 @@ func CalcBytesPerCPixel(pf *PixelFormat) int {
 }

 func (enc *ZRLEEncoding) Read(r Conn, rect *Rectangle) error {
-	logger.Tracef("reading ZRLE:%v\n", rect)
+	log.Debugf("reading ZRLE:%v\n", rect)
 	len, err := ReadUint32(r)
 	if err != nil {
 		return err
@@ -101,7 +101,7 @@ func (enc *ZRLEEncoding) readZRLERaw(reader io.Reader, pf *PixelFormat, tx, ty,
 }

 func (enc *ZRLEEncoding) renderZRLE(rect *Rectangle, pf *PixelFormat) error {
-	logger.Trace("-----renderZRLE: rendering rect:", rect)
+	log.Debugf("-----renderZRLE: rendering rect:", rect)
 	for tileOffsetY := 0; tileOffsetY < int(rect.Height); tileOffsetY += 64 {

 		tileHeight := Min(64, int(rect.Height)-tileOffsetY)
@@ -111,9 +111,9 @@ func (enc *ZRLEEncoding) renderZRLE(rect *Rectangle, pf *PixelFormat) error {
 			tileWidth := Min(64, int(rect.Width)-tileOffsetX)
 			// read subencoding
 			subEnc, err := ReadUint8(enc.unzipper)
-			logger.Tracef("-----renderZRLE: rendering got tile:(%d,%d) w:%d, h:%d subEnc:%d", tileOffsetX, tileOffsetY, tileWidth, tileHeight, subEnc)
+			log.Debugf("-----renderZRLE: rendering got tile:(%d,%d) w:%d, h:%d subEnc:%d", tileOffsetX, tileOffsetY, tileWidth, tileHeight, subEnc)
 			if err != nil {
-				logger.Errorf("renderZRLE: error while reading subencoding: %v", err)
+				log.Errorf("renderZRLE: error while reading subencoding: %v", err)
 				return err
 			}

@@ -123,14 +123,14 @@ func (enc *ZRLEEncoding) renderZRLE(rect *Rectangle, pf *PixelFormat) error {
 				// Raw subencoding: read cpixels and paint
 				err = enc.readZRLERaw(enc.unzipper, pf, int(rect.X)+tileOffsetX, int(rect.Y)+tileOffsetY, tileWidth, tileHeight)
 				if err != nil {
-					logger.Errorf("renderZRLE: error while reading Raw tile: %v", err)
+					log.Errorf("renderZRLE: error while reading Raw tile: %v", err)
 					return err
 				}
 			case subEnc == 1:
 				// background color tile - just fill
 				color, err := readCPixel(enc.unzipper, pf)
 				if err != nil {
-					logger.Errorf("renderZRLE: error while reading CPixel for bgColor tile: %v", err)
+					log.Errorf("renderZRLE: error while reading CPixel for bgColor tile: %v", err)
 					return err
 				}
 				myRect := MakeRect(int(rect.X)+tileOffsetX, int(rect.Y)+tileOffsetY, tileWidth, tileHeight)
@@ -151,7 +151,7 @@ func (enc *ZRLEEncoding) renderZRLE(rect *Rectangle, pf *PixelFormat) error {
 					return err
 				}
 			default:
-				logger.Errorf("Unknown ZRLE subencoding: %v", subEnc)
+				log.Errorf("Unknown ZRLE subencoding: %v", subEnc)
 			}
 		}
 	}
@@ -168,7 +168,7 @@ func (enc *ZRLEEncoding) handlePaletteRLETile(tileOffsetX, tileOffsetY, tileWidt
 	for j := 0; j < int(paletteSize); j++ {
 		palette[j], err = readCPixel(enc.unzipper, pf)
 		if err != nil {
-			logger.Errorf("renderZRLE: error while reading color in palette RLE subencoding: %v", err)
+			log.Errorf("renderZRLE: error while reading color in palette RLE subencoding: %v", err)
 			return err
 		}
 	}
@@ -182,7 +182,7 @@ func (enc *ZRLEEncoding) handlePaletteRLETile(tileOffsetX, tileOffsetY, tileWidt
 				// Read length and index
 				index, err = ReadUint8(enc.unzipper)
 				if err != nil {
-					logger.Errorf("renderZRLE: error while reading length and index in palette RLE subencoding: %v", err)
+					log.Errorf("renderZRLE: error while reading length and index in palette RLE subencoding: %v", err)
 					//return err
 				}
 				runLen = 1
@@ -195,12 +195,12 @@ func (enc *ZRLEEncoding) handlePaletteRLETile(tileOffsetX, tileOffsetY, tileWidt

 					runLen, err = readRunLength(enc.unzipper)
 					if err != nil {
-						logger.Errorf("handlePlainRLETile: error while reading runlength in plain RLE subencoding: %v", err)
+						log.Errorf("handlePlainRLETile: error while reading runlength in plain RLE subencoding: %v", err)
 						return err
 					}

 				}
-				//logger.Tracef("renderZRLE: writing pixel: col=%v times=%d", palette[index], runLen)
+				//log.Debugf("renderZRLE: writing pixel: col=%v times=%d", palette[index], runLen)
 			}

 			// Write pixel to image
@@ -220,7 +220,7 @@ func (enc *ZRLEEncoding) handlePaletteTile(tileOffsetX, tileOffsetY, tileWidth,
 	for j := 0; j < int(paletteSize); j++ {
 		palette[j], err = readCPixel(enc.unzipper, pf)
 		if err != nil {
-			logger.Errorf("renderZRLE: error while reading CPixel for palette tile: %v", err)
+			log.Errorf("renderZRLE: error while reading CPixel for palette tile: %v", err)
 			return err
 		}
 	}
@@ -248,7 +248,7 @@ func (enc *ZRLEEncoding) handlePaletteTile(tileOffsetX, tileOffsetY, tileWidth,
 			if bitsAvailable == 0 {
 				bits, err := ReadUint8(enc.unzipper)
 				if err != nil {
-					logger.Errorf("renderZRLE: error while reading first uint8 into buffer: %v", err)
+					log.Errorf("renderZRLE: error while reading first uint8 into buffer: %v", err)
 					return err
 				}
 				buffer = uint32(bits)
@@ -279,12 +279,12 @@ func (enc *ZRLEEncoding) handlePlainRLETile(tileOffsetX int, tileOffsetY int, ti
 				// Read length and color
 				col, err = readCPixel(enc.unzipper, pf)
 				if err != nil {
-					logger.Errorf("handlePlainRLETile: error while reading CPixel in plain RLE subencoding: %v", err)
+					log.Errorf("handlePlainRLETile: error while reading CPixel in plain RLE subencoding: %v", err)
 					return err
 				}
 				runLen, err = readRunLength(enc.unzipper)
 				if err != nil {
-					logger.Errorf("handlePlainRLETile: error while reading runlength in plain RLE subencoding: %v", err)
+					log.Errorf("handlePlainRLETile: error while reading runlength in plain RLE subencoding: %v", err)
 					return err
 				}

@@ -303,7 +303,7 @@ func readRunLength(r io.Reader) (int, error) {

 	addition, err := ReadUint8(r)
 	if err != nil {
-		logger.Errorf("renderZRLE: error while reading addition to runLen in plain RLE subencoding: %v", err)
+		log.Errorf("renderZRLE: error while reading addition to runLen in plain RLE subencoding: %v", err)
 		return 0, err
 	}
 	runLen += int(addition)
@@ -311,7 +311,7 @@ func readRunLength(r io.Reader) (int, error) {
 	for addition == 255 {
 		addition, err = ReadUint8(r)
 		if err != nil {
-			logger.Errorf("renderZRLE: error while reading addition to runLen in-loop plain RLE subencoding: %v", err)
+			log.Errorf("renderZRLE: error while reading addition to runLen in-loop plain RLE subencoding: %v", err)
 			return 0, err
 		}
 		runLen += int(addition)
@@ -353,7 +353,7 @@ func readCPixel(c io.Reader, pf *PixelFormat) (*color.RGBA, error) {

 	col, err := ReadColor(c, pf)
 	if err != nil {
-		logger.Errorf("readCPixel: Error while reading zrle: %v", err)
+		log.Errorf("readCPixel: Error while reading zrle: %v", err)
 	}

 	return col, nil
--- a/example/client/main.go
+++ b/example/client/main.go
@@ -2,7 +2,6 @@ package main

 import (
 	"context"
-	"log"
 	"net"
 	"os"
 	"os/signal"
@@ -12,7 +11,7 @@ import (
 	"time"
 	vnc "vnc2video"
 	"vnc2video/encoders"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 func main() {
@@ -23,10 +22,10 @@ func main() {
 	// Establish TCP connection to VNC server.
 	nc, err := net.DialTimeout("tcp", os.Args[1], 5*time.Second)
 	if err != nil {
-		logger.Fatalf("Error connecting to VNC host. %v", err)
+		log.Fatalf("Error connecting to VNC host. %v", err)
 	}

-	logger.Tracef("starting up the client, connecting to: %s", os.Args[1])
+	log.Debugf("starting up the client, connecting to: %s", os.Args[1])
 	// Negotiate connection with the server.
 	cchServer := make(chan vnc.ServerMessage)
 	cchClient := make(chan vnc.ClientMessage)
@@ -60,7 +59,7 @@ func main() {
 	cc, err := vnc.Connect(context.Background(), nc, ccfg)
 	screenImage := cc.Canvas
 	if err != nil {
-		logger.Fatalf("Error negotiating connection to VNC host. %v", err)
+		log.Fatalf("Error negotiating connection to VNC host. %v", err)
 	}
 	// out, err := os.Create("./output" + strconv.Itoa(counter) + ".jpg")
 	// if err != nil {
@@ -95,7 +94,7 @@ func main() {
 	}
 	// var out *os.File

-	logger.Tracef("connected to: %s", os.Args[1])
+	log.Debugf("connected to: %s", os.Args[1])
 	defer cc.Close()

 	cc.SetEncodings([]vnc.EncodingType{
@@ -150,7 +149,7 @@ func main() {
 		case err := <-errorCh:
 			panic(err)
 		case msg := <-cchClient:
-			logger.Tracef("Received client message type:%v msg:%v\n", msg.Type(), msg)
+			log.Debugf("Received client message type:%v msg:%v\n", msg.Type(), msg)
 		case msg := <-cchServer:
 			//logger.Tracef("Received server message type:%v msg:%v\n", msg.Type(), msg)

@@ -167,7 +166,7 @@ func main() {
 				//counter++
 				//jpeg.Encode(out, screenImage, nil)
 				///vcodec.Encode(screenImage)
-				logger.Infof("reqs=%d, seconds=%f, Req Per second= %f", frameBufferReq, secsPassed, reqPerSec)
+				log.Infof("reqs=%d, seconds=%f, Req Per second= %f", frameBufferReq, secsPassed, reqPerSec)

 				reqMsg := vnc.FramebufferUpdateRequest{Inc: 1, X: 0, Y: 0, Width: cc.Width(), Height: cc.Height()}
 				//cc.ResetAllEncodings()
--- a/example/file-reader/main.go
+++ b/example/file-reader/main.go
@@ -6,7 +6,7 @@ import (
 	"time"
 	vnc "vnc2video"
 	"vnc2video/encoders"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 func main() {
@@ -15,11 +15,11 @@ func main() {
 	fastFramerate := int(float64(framerate) * speedupFactor)

 	if len(os.Args) <= 1 {
-		logger.Errorf("please provide a fbs file name")
+		log.Errorf("please provide a fbs file name")
 		return
 	}
 	if _, err := os.Stat(os.Args[1]); os.IsNotExist(err) {
-		logger.Errorf("File doesn't exist", err)
+		log.Errorf("File doesn't exist", err)
 		return
 	}
 	encs := []vnc.Encoding{
@@ -34,7 +34,7 @@ func main() {
 		encs,
 	)
 	if err != nil {
-		logger.Error("failed to open fbs reader:", err)
+		log.Error("failed to open fbs reader:", err)
 		//return nil, err
 	}

@@ -43,7 +43,7 @@ func main() {
 	//vcodec := &encoders.DV8ImageEncoder{}
 	//vcodec := &encoders.DV9ImageEncoder{}
 	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
-	logger.Tracef("current dir: %s", dir)
+	log.Debugf("current dir: %s", dir)
 	go vcodec.Run("./output.mp4")

 	//screenImage := image.NewRGBA(image.Rect(0, 0, int(fbs.Width()), int(fbs.Height())))
--- a/example/proxy/main.go
+++ b/example/proxy/main.go
@@ -14,7 +14,7 @@ import (
 	"sync"
 	"time"
 	vnc "vnc2video"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 type Auth struct {
@@ -189,7 +189,7 @@ func (auth *AuthVNCHTTP) Auth(c vnc.Conn) error {
 	if err != nil {
 		return fmt.Errorf("failed to get auth data: %s", err.Error())
 	}
-	logger.Debugf("http auth: %s\n", buf.Bytes())
+	log.Debugf("http auth: %s\n", buf.Bytes())
 	res.Body.Close()
 	data := strings.Split(buf.String(), " ")
 	if len(data) < 2 {
@@ -223,12 +223,12 @@ func (*AuthVNCHTTP) SubType() vnc.SecuritySubType {

 func main() {
 	go func() {
-		logger.Info(http.ListenAndServe(":6060", nil))
+		log.Info(http.ListenAndServe(":6060", nil))
 	}()

 	ln, err := net.Listen("tcp", ":6900")
 	if err != nil {
-		logger.Fatalf("Error listen. %v", err)
+		log.Fatalf("Error listen. %v", err)
 	}

 	schClient := make(chan vnc.ClientMessage)
--- a/example/server/main.go
+++ b/example/server/main.go
@@ -8,13 +8,13 @@ import (
 	"net"
 	"time"
 	vnc "vnc2video"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 func main() {
 	ln, err := net.Listen("tcp", ":5900")
 	if err != nil {
-		logger.Fatalf("Error listen. %v", err)
+		log.Fatalf("Error listen. %v", err)
 	}

 	chServer := make(chan vnc.ClientMessage)
@@ -50,12 +50,12 @@ func main() {
 		case msg := <-chClient:
 			switch msg.Type() {
 			default:
-				logger.Tracef("11 Received message type:%v msg:%v\n", msg.Type(), msg)
+				log.Debugf("11 Received message type:%v msg:%v\n", msg.Type(), msg)
 			}
 		case msg := <-chServer:
 			switch msg.Type() {
 			default:
-				logger.Tracef("22 Received message type:%v msg:%v\n", msg.Type(), msg)
+				log.Debugf("22 Received message type:%v msg:%v\n", msg.Type(), msg)
 			}
 		}
 	}
--- a/fbs-connection.go
+++ b/fbs-connection.go
@@ -2,8 +2,8 @@ package vnc2video

 import (
 	"encoding/binary"
+	log "github.com/sirupsen/logrus"
 	"net"
-	"vnc2video/logger"

 	"io"
 	"time"
@@ -112,14 +112,14 @@ func NewFbsConn(filename string, encs []Encoding) (*FbsConn, error) {

 	fbs, err := NewFbsReader(filename)
 	if err != nil {
-		logger.Error("failed to open fbs reader:", err)
+		log.Error("failed to open fbs reader:", err)
 		return nil, err
 	}

 	//NewFbsReader("/Users/amitbet/vncRec/recording.rbs")
 	initMsg, err := fbs.ReadStartSession()
 	if err != nil {
-		logger.Error("failed to open read fbs start session:", err)
+		log.Error("failed to open read fbs start session:", err)
 		return nil, err
 	}
 	fbsConn := &FbsConn{FbsReader: *fbs}
@@ -150,7 +150,7 @@ func NewFBSPlayHelper(r *FbsConn) *FBSPlayHelper {
 // 	switch seg.SegmentType {
 // 	case SegmentFullyParsedClientMessage:
 // 		clientMsg := seg.Message.(ClientMessage)
-// 		logger.Tracef("ClientUpdater.Consume:(vnc-server-bound) got ClientMessage type=%s", clientMsg.Type())
+// 		log.Debugf("ClientUpdater.Consume:(vnc-server-bound) got ClientMessage type=%s", clientMsg.Type())
 // 		switch clientMsg.Type() {

 // 		case FramebufferUpdateRequestMsgType:
@@ -172,7 +172,7 @@ func (h *FBSPlayHelper) ReadFbsMessage(SyncWithTimestamps bool, SpeedFactor floa
 	//conn := h.Conn
 	err := binary.Read(fbs, binary.BigEndian, &messageType)
 	if err != nil {
-		logger.Error("FBSConn.NewConnHandler: Error in reading FBS: ", err)
+		log.Error("FBSConn.NewConnHandler: Error in reading FBS: ", err)
 		return nil, err
 	}
 	startTimeMsgHandling := time.Now()
@@ -180,14 +180,14 @@ func (h *FBSPlayHelper) ReadFbsMessage(SyncWithTimestamps bool, SpeedFactor floa
 	//binary.Write(h.Conn, binary.BigEndian, messageType)
 	msg := h.serverMessageMap[messageType]
 	if msg == nil {
-		logger.Error("FBSConn.NewConnHandler: Error unknown message type: ", messageType)
+		log.Error("FBSConn.NewConnHandler: Error unknown message type: ", messageType)
 		return nil, err
 	}
 	//read the actual message data
 	//err = binary.Read(fbs, binary.BigEndian, &msg)
 	parsedMsg, err := msg.Read(fbs)
 	if err != nil {
-		logger.Error("FBSConn.NewConnHandler: Error in reading FBS message: ", err)
+		log.Error("FBSConn.NewConnHandler: Error in reading FBS message: ", err)
 		return nil, err
 	}

@@ -199,7 +199,7 @@ func (h *FBSPlayHelper) ReadFbsMessage(SyncWithTimestamps bool, SpeedFactor floa

 		time.Sleep(time.Duration(millisToSleep) * time.Millisecond)
 	} else if millisToSleep < -450 {
-		logger.Errorf("rendering time is noticeably off, change speedup factor: videoTimeLine: %f, currentTime:%d, offset: %f", adjestedTimeStamp, millisSinceStart, millisToSleep)
+		log.Errorf("rendering time is noticeably off, change speedup factor: videoTimeLine: %f, currentTime:%d, offset: %f", adjestedTimeStamp, millisSinceStart, millisToSleep)
 	}

 	return parsedMsg, nil
--- a/fbs-reader.go
+++ b/fbs-reader.go
@@ -7,7 +7,7 @@ import (
 	"os"
 	//"vncproxy/common"
 	//"vncproxy/encodings"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 	//"vncproxy/encodings"
 	//"vncproxy/encodings"
 )
@@ -33,7 +33,7 @@ func (fbs *FbsReader) Read(p []byte) (n int, err error) {
 		seg, err := fbs.ReadSegment()

 		if err != nil {
-			logger.Error("FBSReader.Read: error reading FBSsegment: ", err)
+			log.Error("FBSReader.Read: error reading FBSsegment: ", err)
 			return 0, err
 		}
 		fbs.buffer.Write(seg.bytes)
@@ -50,7 +50,7 @@ func NewFbsReader(fbsFile string) (*FbsReader, error) {

 	reader, err := os.OpenFile(fbsFile, os.O_RDONLY, 0644)
 	if err != nil {
-		logger.Error("NewFbsReader: can't open fbs file: ", fbsFile)
+		log.Error("NewFbsReader: can't open fbs file: ", fbsFile)
 		return nil, err
 	}
 	return &FbsReader{reader: reader}, //encodings: []IEncoding{
@@ -82,7 +82,7 @@ func (fbs *FbsReader) ReadStartSession() (*ServerInit, error) {
 	bytes := make([]byte, 12)
 	_, err := reader.Read(bytes)
 	if err != nil {
-		logger.Error("FbsReader.ReadStartSession: error reading rbs init message - FBS file Version:", err)
+		log.Error("FbsReader.ReadStartSession: error reading rbs init message - FBS file Version:", err)
 		return nil, err
 	}

@@ -91,27 +91,27 @@ func (fbs *FbsReader) ReadStartSession() (*ServerInit, error) {
 	bytes = make([]byte, 12)
 	_, err = fbs.Read(bytes)
 	if err != nil {
-		logger.Error("FbsReader.ReadStartSession: error reading rbs init - RFB Version: ", err)
+		log.Error("FbsReader.ReadStartSession: error reading rbs init - RFB Version: ", err)
 		return nil, err
 	}

 	//push sec type and fb dimensions
 	binary.Read(fbs, binary.BigEndian, &SecTypeNone)
 	if err != nil {
-		logger.Error("FbsReader.ReadStartSession: error reading rbs init - SecType: ", err)
+		log.Error("FbsReader.ReadStartSession: error reading rbs init - SecType: ", err)
 	}

 	//read frame buffer width, height
 	binary.Read(fbs, binary.BigEndian, &framebufferWidth)
 	if err != nil {
-		logger.Error("FbsReader.ReadStartSession: error reading rbs init - FBWidth: ", err)
+		log.Error("FbsReader.ReadStartSession: error reading rbs init - FBWidth: ", err)
 		return nil, err
 	}
 	initMsg.FBWidth = framebufferWidth

 	binary.Read(fbs, binary.BigEndian, &framebufferHeight)
 	if err != nil {
-		logger.Error("FbsReader.ReadStartSession: error reading rbs init - FBHeight: ", err)
+		log.Error("FbsReader.ReadStartSession: error reading rbs init - FBHeight: ", err)
 		return nil, err
 	}
 	initMsg.FBHeight = framebufferHeight
@@ -120,7 +120,7 @@ func (fbs *FbsReader) ReadStartSession() (*ServerInit, error) {
 	pixelFormat := &PixelFormat{}
 	binary.Read(fbs, binary.BigEndian, pixelFormat)
 	if err != nil {
-		logger.Error("FbsReader.ReadStartSession: error reading rbs init - Pixelformat: ", err)
+		log.Error("FbsReader.ReadStartSession: error reading rbs init - Pixelformat: ", err)
 		return nil, err
 	}

@@ -130,7 +130,7 @@ func (fbs *FbsReader) ReadStartSession() (*ServerInit, error) {
 	var desknameLen uint32
 	binary.Read(fbs, binary.BigEndian, &desknameLen)
 	if err != nil {
-		logger.Error("FbsReader.ReadStartSession: error reading rbs init - deskname Len: ", err)
+		log.Error("FbsReader.ReadStartSession: error reading rbs init - deskname Len: ", err)
 		return nil, err
 	}
 	initMsg.NameLength = desknameLen
@@ -138,7 +138,7 @@ func (fbs *FbsReader) ReadStartSession() (*ServerInit, error) {
 	bytes = make([]byte, desknameLen)
 	fbs.Read(bytes)
 	if err != nil {
-		logger.Error("FbsReader.ReadStartSession: error reading rbs init - desktopName: ", err)
+		log.Error("FbsReader.ReadStartSession: error reading rbs init - desktopName: ", err)
 		return nil, err
 	}

@@ -154,7 +154,7 @@ func (fbs *FbsReader) ReadSegment() (*FbsSegment, error) {
 	//read length
 	err := binary.Read(reader, binary.BigEndian, &bytesLen)
 	if err != nil {
-		logger.Error("FbsReader.ReadSegment: reading len, error reading rbs file: ", err)
+		log.Error("FbsReader.ReadSegment: reading len, error reading rbs file: ", err)
 		return nil, err
 	}

@@ -164,7 +164,7 @@ func (fbs *FbsReader) ReadSegment() (*FbsSegment, error) {
 	bytes := make([]byte, paddedSize)
 	_, err = reader.Read(bytes)
 	if err != nil {
-		logger.Error("FbsReader.ReadSegment: reading bytes, error reading rbs file: ", err)
+		log.Error("FbsReader.ReadSegment: reading bytes, error reading rbs file: ", err)
 		return nil, err
 	}

@@ -175,7 +175,7 @@ func (fbs *FbsReader) ReadSegment() (*FbsSegment, error) {
 	var timeSinceStart uint32
 	binary.Read(reader, binary.BigEndian, &timeSinceStart)
 	if err != nil {
-		logger.Error("FbsReader.ReadSegment: read timestamp, error reading rbs file: ", err)
+		log.Error("FbsReader.ReadSegment: read timestamp, error reading rbs file: ", err)
 		return nil, err
 	}

--- a/handlers.go
+++ b/handlers.go
@@ -3,7 +3,7 @@ package vnc2video
 import (
 	"encoding/binary"
 	"fmt"
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 // Handler represents handler of handshake
@@ -149,7 +149,7 @@ func (*DefaultClientSecurityHandler) Handle(c Conn) error {

 	err := secType.Auth(c)
 	if err != nil {
-		logger.Error("Authentication error: ", err)
+		log.Error("Authentication error: ", err)
 		return err
 	}

@@ -158,7 +158,7 @@ func (*DefaultClientSecurityHandler) Handle(c Conn) error {
 		return err
 	}

-	logger.Tracef("authenticating, secType: %d, auth code(0=success): %d", secType.Type(), authCode)
+	log.Debugf("authenticating, secType: %d, auth code(0=success): %d", secType.Type(), authCode)
 	if authCode == 1 {
 		var reasonLength uint32
 		if err := binary.Read(c, binary.BigEndian, &reasonLength); err != nil {
@@ -259,7 +259,7 @@ type DefaultClientServerInitHandler struct{}

 // Handle provide default server init handler
 func (*DefaultClientServerInitHandler) Handle(c Conn) error {
-	logger.Trace("starting DefaultClientServerInitHandler")
+	log.Debug("starting DefaultClientServerInitHandler")
 	var err error
 	srvInit := ServerInit{}

@@ -280,7 +280,7 @@ func (*DefaultClientServerInitHandler) Handle(c Conn) error {
 	if err = binary.Read(c, binary.BigEndian, &srvInit.NameText); err != nil {
 		return err
 	}
-	logger.Tracef("DefaultClientServerInitHandler got serverInit: %v", srvInit)
+	log.Debugf("DefaultClientServerInitHandler got serverInit: %v", srvInit)
 	c.SetDesktopName(srvInit.NameText)
 	if c.Protocol() == "aten1" {
 		c.SetWidth(800)
@@ -376,7 +376,7 @@ type DefaultClientClientInitHandler struct{}

 // Handle provide default client client init handler
 func (*DefaultClientClientInitHandler) Handle(c Conn) error {
-	logger.Trace("starting DefaultClientClientInitHandler")
+	log.Debugf("starting DefaultClientClientInitHandler")
 	cfg := c.Config().(*ClientConfig)
 	var shared uint8
 	if cfg.Exclusive {
@@ -387,7 +387,7 @@ func (*DefaultClientClientInitHandler) Handle(c Conn) error {
 	if err := binary.Write(c, binary.BigEndian, shared); err != nil {
 		return err
 	}
-	logger.Tracef("DefaultClientClientInitHandler sending: shared=%d", shared)
+	log.Debugf("DefaultClientClientInitHandler sending: shared=%d", shared)
 	return c.Flush()
 }

--- a/image.go
+++ b/image.go
@@ -3,8 +3,8 @@ package vnc2video
 import (
 	"encoding/binary"
 	"fmt"
+	log "github.com/sirupsen/logrus"
 	"image"
-	"vnc2video/logger"
 )

 //var _ draw.Drawer = (*ServerConn)(nil)
@@ -167,7 +167,7 @@ func (rect *Rectangle) Read(c Conn) error {
 	if err = binary.Read(c, binary.BigEndian, &rect.EncType); err != nil {
 		return err
 	}
-	logger.Debug(rect)
+	log.Debug(rect)
 	switch rect.EncType {
 	// case EncCopyRect:
 	// 	rect.Enc = &CopyRectEncoding{}
--- a/logger/logger.go
+++ b/logger/logger.go
@@ -1,173 +0,0 @@
-package logger
-
-import "fmt"
-
-var simpleLogger = SimpleLogger{LogLevelWarn}
-
-type Logger interface {
-	Trace(v ...interface{})
-	Tracef(format string, v ...interface{})
-	Debug(v ...interface{})
-	Debugf(format string, v ...interface{})
-	Info(v ...interface{})
-	Infof(format string, v ...interface{})
-	DebugfNoCR(format string, v ...interface{})
-	Warn(v ...interface{})
-	Warnf(format string, v ...interface{})
-	Error(v ...interface{})
-	Errorf(format string, v ...interface{})
-	Fatal(v ...interface{})
-	Fatalf(format string, v ...interface{})
-}
-type LogLevel int
-
-const (
-	LogLevelTrace LogLevel = iota
-	LogLevelDebug
-	LogLevelInfo
-	LogLevelWarn
-	LogLevelError
-	LogLevelFatal
-)
-
-type SimpleLogger struct {
-	level LogLevel
-}
-
-func (sl *SimpleLogger) Trace(v ...interface{}) {
-	if sl.level <= LogLevelTrace {
-		arr := []interface{}{"[Trace]"}
-		for _, item := range v {
-			arr = append(arr, item)
-		}
-
-		fmt.Println(arr...)
-	}
-}
-func (sl *SimpleLogger) Tracef(format string, v ...interface{}) {
-	if sl.level <= LogLevelTrace {
-		fmt.Printf("[Trace] "+format+"\n", v...)
-	}
-}
-
-func (sl *SimpleLogger) Debug(v ...interface{}) {
-	if sl.level <= LogLevelDebug {
-		arr := []interface{}{"[Debug]"}
-		for _, item := range v {
-			arr = append(arr, item)
-		}
-
-		fmt.Println(arr...)
-	}
-}
-func (sl *SimpleLogger) Debugf(format string, v ...interface{}) {
-	if sl.level <= LogLevelDebug {
-		fmt.Printf("[Debug] "+format+"\n", v...)
-	}
-}
-func (sl *SimpleLogger) Info(v ...interface{}) {
-	if sl.level <= LogLevelInfo {
-		arr := []interface{}{"[Info ]"}
-		for _, item := range v {
-			arr = append(arr, item)
-		}
-		fmt.Println(arr...)
-	}
-}
-func (sl *SimpleLogger) DebugfNoCR(format string, v ...interface{}) {
-	if sl.level <= LogLevelDebug {
-		fmt.Printf("[Info ] "+format, v...)
-	}
-}
-
-func (sl *SimpleLogger) Infof(format string, v ...interface{}) {
-	if sl.level <= LogLevelInfo {
-		fmt.Printf("[Info ] "+format+"\n", v...)
-	}
-}
-func (sl *SimpleLogger) Warn(v ...interface{}) {
-	if sl.level <= LogLevelWarn {
-		arr := []interface{}{"[Warn ]"}
-		for _, item := range v {
-			arr = append(arr, item)
-		}
-		fmt.Println(arr...)
-	}
-}
-func (sl *SimpleLogger) Warnf(format string, v ...interface{}) {
-	if sl.level <= LogLevelWarn {
-		fmt.Printf("[Warn ] "+format+"\n", v...)
-	}
-}
-func (sl *SimpleLogger) Error(v ...interface{}) {
-	if sl.level <= LogLevelError {
-		arr := []interface{}{"[Error]"}
-		for _, item := range v {
-			arr = append(arr, item)
-		}
-		fmt.Println(arr...)
-	}
-}
-func (sl *SimpleLogger) Errorf(format string, v ...interface{}) {
-	if sl.level <= LogLevelError {
-		fmt.Printf("[Error] "+format+"\n", v...)
-	}
-}
-func (sl *SimpleLogger) Fatal(v ...interface{}) {
-	if sl.level <= LogLevelFatal {
-		arr := []interface{}{"[Fatal]"}
-		for _, item := range v {
-			arr = append(arr, item)
-		}
-		fmt.Println(arr...)
-
-	}
-}
-func (sl *SimpleLogger) Fatalf(format string, v ...interface{}) {
-	if sl.level <= LogLevelFatal {
-		fmt.Printf("[Fatal] "+format+"\n", v)
-	}
-}
-func Trace(v ...interface{}) {
-	simpleLogger.Trace(v...)
-}
-func Tracef(format string, v ...interface{}) {
-	simpleLogger.Tracef(format, v...)
-}
-
-func Debug(v ...interface{}) {
-	simpleLogger.Debug(v...)
-}
-func Debugf(format string, v ...interface{}) {
-	simpleLogger.Tracef(format, v...)
-}
-
-func Info(v ...interface{}) {
-	simpleLogger.Info(v...)
-}
-func Infof(format string, v ...interface{}) {
-	simpleLogger.Infof(format, v...)
-}
-func DebugfNoCR(format string, v ...interface{}) {
-	simpleLogger.DebugfNoCR(format, v...)
-}
-func Warn(v ...interface{}) {
-	simpleLogger.Warn(v...)
-}
-func Warnf(format string, v ...interface{}) {
-	simpleLogger.Warnf(format, v...)
-}
-
-func Error(v ...interface{}) {
-	simpleLogger.Error(v...)
-}
-func Errorf(format string, v ...interface{}) {
-	simpleLogger.Errorf(format, v...)
-}
-
-func Fatal(v ...interface{}) {
-	simpleLogger.Fatal(v...)
-}
-func Fatalf(format string, v ...interface{}) {
-	simpleLogger.Fatalf(format, v...)
-}
--- a/messages.go
+++ b/messages.go
@@ -3,8 +3,7 @@ package vnc2video
 import (
 	"encoding/binary"
 	"fmt"
-
-	"vnc2video/logger"
+	log "github.com/sirupsen/logrus"
 )

 var (
@@ -115,11 +114,11 @@ func (*FramebufferUpdate) Read(c Conn) (ServerMessage, error) {
 	if err := binary.Read(c, binary.BigEndian, &msg.NumRect); err != nil {
 		return nil, err
 	}
-	logger.Debugf("-------Reading FrameBuffer update with %d rects-------", msg.NumRect)
+	log.Debugf("-------Reading FrameBuffer update with %d rects-------", msg.NumRect)

 	for i := uint16(0); i < msg.NumRect; i++ {
 		rect := NewRectangle()
-		logger.DebugfNoCR("----------RECT %d----------", i)
+		log.Debug("----------RECT %d----------", i)

 		if err := rect.Read(c); err != nil {
 			return nil, err
@@ -127,7 +126,7 @@ func (*FramebufferUpdate) Read(c Conn) (ServerMessage, error) {
 		if rect.EncType == EncDesktopSizePseudo {
 			c.(*ClientConn).ResetAllEncodings()
 		}
-		logger.Tracef("----End RECT #%d Info (%dx%d) encType:%s", i, rect.Width, rect.Height, rect.EncType)
+		log.Debugf("----End RECT #%d Info (%dx%d) encType:%s", i, rect.Width, rect.Height, rect.EncType)
 		msg.Rects = append(msg.Rects, rect)
 	}
 	return &msg, nil
@@ -271,7 +270,7 @@ func (*SetColorMapEntries) Type() ServerMessageType {

 // Read unmrashal message from conn
 func (*SetColorMapEntries) Read(c Conn) (ServerMessage, error) {
-	logger.Info("Reading SetColorMapEntries message")
+	log.Info("Reading SetColorMapEntries message")
 	msg := SetColorMapEntries{}
 	var pad [1]byte
 	if err := binary.Read(c, binary.BigEndian, &pad); err != nil {