func main() {
	var buf bytes.Buffer
	var width, height int
	var data []byte
	var err error

	// Load file data
	if data, err = ioutil.ReadFile("./testdata/1_webp_ll.webp"); err != nil {
		log.Fatal(err)
	}

	// GetInfo
	if width, height, _, err = webp.GetInfo(data); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("width = %d, height = %d\n", width, height)

	// Decode webp
	m, err := webp.Decode(bytes.NewReader(data))
	if err != nil {
		log.Fatal(err)
	}

	// Encode lossless webp
	if err = webp.Encode(&buf, m, &webp.Options{Lossless: true}); err != nil {
		log.Fatal(err)
	}
	if err = ioutil.WriteFile("output.webp", buf.Bytes(), 0666); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Save output.webp ok\n")
}

func BenchmarkDecode_yellow_rose_lossy_with_alpha_chai2010_webp(b *testing.B) {
	data := tbLoadData(b, "yellow_rose.lossy-with-alpha.webp")
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		m, err := chai2010_webp.Decode(bytes.NewReader(data))
		if err != nil {
			b.Fatal(err)
		}
		_ = m
	}
}

func BenchmarkDecode_video_001_chai2010_webp(b *testing.B) {
	data := tbLoadData(b, "video-001.webp")
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		m, err := chai2010_webp.Decode(bytes.NewReader(data))
		if err != nil {
			b.Fatal(err)
		}
		_ = m
	}
}

func BenchmarkDecode_tux_lossless_chai2010_webp(b *testing.B) {
	data := tbLoadData(b, "tux.lossless.webp")
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		m, err := chai2010_webp.Decode(bytes.NewReader(data))
		if err != nil {
			b.Fatal(err)
		}
		_ = m
	}
}

func BenchmarkDecode_blue_purple_pink_lossy_chai2010_webp(b *testing.B) {
	data := tbLoadData(b, "blue-purple-pink.lossy.webp")
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		m, err := chai2010_webp.Decode(bytes.NewReader(data))
		if err != nil {
			b.Fatal(err)
		}
		_ = m
	}
}

func Post(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		w.Write(json.Message("ERROR", "Not supported Method"))
		return
	}
	f, _, err := r.FormFile("image")
	if err != nil {
		w.Write(json.Message("ERROR", "Can't Find Image"))
		return
	}
	defer f.Close()
	buf := bufio.NewReader(f)
	h := sha1.New()
	var result json.Result
	var ic iconf
	ic.machine = conf.Image.Machine
	if conf.InputType == "jpeg" {
		ic.image, _, err = image.Decode(io.TeeReader(buf, h))
	} else {
		ic.image, err = webp.Decode(io.TeeReader(buf, h))
	}
	ic.hash = fmt.Sprintf("%x", h.Sum(nil))
	if err != nil {
		w.Write(json.Message("ERROR", "Unable to decode your image! Type="+conf.InputType+" error:"+err.Error()))
		return
	}
	setColor(&ic)
	for _, format := range conf.Image.Format { // jpeg, webp, ...
		for _, screen := range conf.Image.Screen {
			ic.format = format
			ic.ui = screen.Ui
			ic.density = screen.Density
			ic.width = screen.Width
			if ic.fid, err = imgToFile(&ic); err != nil {
				w.Write(json.Message("ERROR", "Unable to create a file"))
				return
			}
			fid := json.Fid{fmt.Sprintf("%s_%s", screen.Density, screen.Ui), ic.fid}
			result.Image = append(result.Image, fid)
		}
	}
	w.Write(json.Message("OK", &result))
}

func loadImgSpecFormat(file string, ft string) (image.Image, error) {
	file_origin, err := os.Open(file)
	if err != nil {
		return nil, Newcuserr(10000)
	}
	defer file_origin.Close()
	var img0 image.Image
	switch ft {
	case "gif":
		img0, err = gif.Decode(file_origin)
	case "png":
		img0, err = png.Decode(file_origin)
	case "webp":
		img0, err = webp.Decode(file_origin)
	default:
		img0, err = jpeg.Decode(file_origin)
	}
	if err != nil {
		return nil, Newcuserr(10001)
	}
	return img0, nil
}