status-im/status-go

package images

import (
    "bytes"
    "errors"
    "image"
    "image/gif"
    "image/jpeg"
    "image/png"
    "io"
    "io/ioutil"
    "net/http"
    "os"
    "regexp"
    "time"
    "unicode/utf8"

    "golang.org/x/image/webp"

    "github.com/ethereum/go-ethereum/log"
)

var (
    htmlCommentRegex = regexp.MustCompile(`(?i)<!--([\\s\\S]*?)-->`)
    svgRegex         = regexp.MustCompile(`(?i)^\s*(?:<\?xml[^>]*>\s*)?(?:<!doctype svg[^>]*>\s*)?<svg[^>]*>[^*]*<\/svg>\s*$`)
)

// IsSVG returns true if the given buffer is a valid SVG image.
func IsSVG(buf []byte) bool {
    var isBinary bool
    if len(buf) < 24 {
        isBinary = false
    }
    for i := 0; i < 14; i++ {
        charCode, _ := utf8.DecodeRuneInString(string(buf[i]))
        if charCode == 65533 || charCode <= 8 {
            isBinary = true
        }
    }
    return !isBinary && svgRegex.Match(htmlCommentRegex.ReplaceAll(buf, []byte{}))
}

func Decode(fileName string) (image.Image, error) {
    file, err := os.Open(fileName)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    fb, err := prepareFileForDecode(file)
    if err != nil {
        return nil, err
    }

    return DecodeImageData(fb, file)
}

func DecodeFromURL(path string) (image.Image, error) {
    client := http.Client{
        Timeout: 5 * time.Second,
    }
    res, err := client.Get(path)
    if err != nil {
        return nil, err
    }

    defer func() {
        if err := res.Body.Close(); err != nil {
            log.Error("failed to close profile pic http request body", "err", err)
        }
    }()

    if res.StatusCode >= 400 {
        return nil, errors.New(http.StatusText(res.StatusCode))
    }

    bodyBytes, err := ioutil.ReadAll(res.Body)
    if err != nil {
        return nil, err
    }

    return DecodeImageData(bodyBytes, bytes.NewReader(bodyBytes))
}

func prepareFileForDecode(file *os.File) ([]byte, error) {
    // Read the first 14 bytes, used for performing image type checks before parsing the image data
    fb := make([]byte, 14)
    _, err := file.Read(fb)
    if err != nil {
        return nil, err
    }

    // Reset the read cursor
    _, err = file.Seek(0, 0)
    if err != nil {
        return nil, err
    }

    return fb, nil
}

func DecodeImageData(buf []byte, r io.Reader) (img image.Image, err error) {
    switch GetType(buf) {
    case JPEG:
        img, err = jpeg.Decode(r)
    case PNG:
        img, err = png.Decode(r)
    case GIF:
        img, err = gif.Decode(r)
    case WEBP:
        img, err = webp.Decode(r)
    case UNKNOWN:
        fallthrough
    default:
        return nil, errors.New("unsupported file type")
    }
    if err != nil {
        return nil, err
    }

    return img, nil
}

func GetType(buf []byte) ImageType {
    switch {
    case IsJpeg(buf):
        return JPEG
    case IsPng(buf):
        return PNG
    case IsGif(buf):
        return GIF
    case IsWebp(buf):
        return WEBP
    case IsIco(buf):
        return ICO
    default:
        return UNKNOWN
    }
}

func GetMimeType(buf []byte) (string, error) {
    switch {
    case IsJpeg(buf):
        return "jpeg", nil
    case IsPng(buf):
        return "png", nil
    case IsGif(buf):
        return "gif", nil
    case IsWebp(buf):
        return "webp", nil
    case IsIco(buf):
        return "ico", nil
    case IsSVG(buf):
        return "svg", nil
    default:
        return "", errors.New("image format not supported")
    }
}

func IsJpeg(buf []byte) bool {
    return len(buf) > 2 &&
        buf[0] == 0xFF &&
        buf[1] == 0xD8 &&
        buf[2] == 0xFF
}

func IsPng(buf []byte) bool {
    return len(buf) > 3 &&
        buf[0] == 0x89 && buf[1] == 0x50 &&
        buf[2] == 0x4E && buf[3] == 0x47
}

func IsGif(buf []byte) bool {
    return len(buf) > 2 &&
        buf[0] == 0x47 && buf[1] == 0x49 && buf[2] == 0x46
}

func IsWebp(buf []byte) bool {
    return len(buf) > 11 &&
        buf[8] == 0x57 && buf[9] == 0x45 &&
        buf[10] == 0x42 && buf[11] == 0x50
}

func IsIco(buf []byte) bool {
    return len(buf) > 4 &&
        buf[0] == 0 && buf[1] == 0 && buf[2] == 1 || buf[2] == 2 &&
        buf[4] > 0
}

func GetImageDimensions(imgBytes []byte) (int, int, error) {
    // Decode image bytes
    img, _, err := image.Decode(bytes.NewReader(imgBytes))
    if err != nil {
        return 0, 0, err
    }
    // Get the image dimensions
    bounds := img.Bounds()
    width := bounds.Max.X - bounds.Min.X
    height := bounds.Max.Y - bounds.Min.Y
    return width, height, nil
}