Golang exif.Decode函數代碼示例

// FileTime returns the best guess of the file's creation time (or modtime).
// If the file doesn't have its own metadata indication the creation time (such as in EXIF),
// FileTime uses the modification time from the file system.
// It there was a valid EXIF but an error while trying to get a date from it,
// it logs the error and tries the other methods.
func FileTime(f io.ReaderAt) (time.Time, error) {
	var ct time.Time
	defaultTime := func() (time.Time, error) {
		if osf, ok := f.(*os.File); ok {
			fi, err := osf.Stat()
			if err != nil {
				return ct, fmt.Errorf("Failed to find a modtime: lstat: %v", err)
			}
			return fi.ModTime(), nil
		}
		return ct, errors.New("All methods failed to find a creation time or modtime.")
	}

	size, ok := findSize(f)
	if !ok {
		size = 256 << 10 // enough to get the EXIF
	}
	r := io.NewSectionReader(f, 0, size)
	ex, err := exif.Decode(r)
	if err != nil {
		return defaultTime()
	}
	ct, err = ex.DateTime()
	if err != nil {
		return defaultTime()
	}
	return ct, nil
}

func showEXIF(file string) {
	f, err := os.Open(file)
	if err != nil {
		panic(err.Error())
	}
	defer f.Close()
	ex, err := exif.Decode(f)
	if err != nil {
		log.Fatalf("exif.Decode: %v", err)
	}
	fmt.Printf("exif.Decode = %#v\n", ex)
	ct, err := ex.DateTime()
	fmt.Printf("exif.DateTime = %v, %v\n", ct, err)
}

func main() {
	flag.Parse()
	fname := flag.Arg(0)

	f, err := os.Open(fname)
	if err != nil {
		log.Fatal(err)
	}

	x, err := exif.Decode(f)
	if err != nil {
		log.Fatal(err)
	}

	x.Walk(Walker{})
}

func ExampleDecode() {
	fname := "sample1.jpg"

	f, err := os.Open(fname)
	if err != nil {
		log.Fatal(err)
	}

	x, err := exif.Decode(f)
	if err != nil {
		log.Fatal(err)
	}

	camModel, _ := x.Get("Model")
	date, _ := x.Get("DateTimeOriginal")
	fmt.Println(camModel.StringVal())
	fmt.Println(date.StringVal())

	focal, _ := x.Get("FocalLength")
	numer, denom := focal.Rat2(0) // retrieve first (only) rat. value
	fmt.Printf("%v/%v", numer, denom)
}

// TODO(mpl): move this test to the goexif lib if/when we contribute
// back the DateTime stuff to upstream.
func TestDateTime(t *testing.T) {
	f, err := os.Open(path.Join(datadir, "f1-exif.jpg"))
	if err != nil {
		t.Fatal(err)
	}
	defer f.Close()
	ex, err := exif.Decode(f)
	if err != nil {
		t.Fatal(err)
	}
	got, err := ex.DateTime()
	if err != nil {
		t.Fatal(err)
	}
	exifTimeLayout := "2006:01:02 15:04:05"
	want, err := time.Parse(exifTimeLayout, "2012:11:04 05:42:02")
	if err != nil {
		t.Fatal(err)
	}
	if got != want {
		t.Fatalf("Creation times differ; got %v, want: %v\n", got, want)
	}
}

// DecodeConfig returns the image Config similarly to
// the standard library's image.DecodeConfig with the
// addition that it also checks for an EXIF orientation,
// and sets the Width and Height as they would visibly
// be after correcting for that orientation.
func DecodeConfig(r io.Reader) (Config, error) {
	var c Config
	var buf bytes.Buffer
	tr := io.TeeReader(io.LimitReader(r, 2<<20), &buf)
	swapDimensions := false

	ex, err := exif.Decode(tr)
	if err != nil {
		imageDebug("No valid EXIF.")
	} else {
		tag, err := ex.Get(exif.Orientation)
		if err != nil {
			imageDebug("No \"Orientation\" tag in EXIF.")
		} else {
			orient := tag.Int(0)
			switch orient {
			// those are the orientations that require
			// a rotation of ±90
			case leftSideTop, rightSideTop, rightSideBottom, leftSideBottom:
				swapDimensions = true
			}
		}
	}
	conf, format, err := image.DecodeConfig(io.MultiReader(&buf, r))
	if err != nil {
		imageDebug(fmt.Sprintf("Image Decoding failed: %v", err))
		return c, err
	}
	c.Format = format
	if swapDimensions {
		c.Width, c.Height = conf.Height, conf.Width
	} else {
		c.Width, c.Height = conf.Width, conf.Height
	}
	return c, err
}

func indexEXIF(wholeRef blob.Ref, header []byte, mm *mutationMap) {
	ex, err := exif.Decode(bytes.NewReader(header))
	if err != nil {
		return
	}
	defer func() {
		// The EXIF library panics if you access a field past
		// what the file contains.  Be paranoid and just
		// recover here, instead of crashing on an invalid
		// EXIF file.
		if e := recover(); e != nil {
			log.Printf("Ignoring invalid EXIF file. Caught panic: %v", e)
		}
	}()

	ex.Walk(exifWalkFunc(func(name exif.FieldName, tag *tiff.Tag) error {
		tagFmt := tagFormatString(tag)
		if tagFmt == "" {
			return nil
		}
		key := keyEXIFTag.Key(wholeRef, fmt.Sprintf("%04x", tag.Id))
		numComp := int(tag.Ncomp)
		if tag.Format() == tiff.StringVal {
			numComp = 1
		}
		var val bytes.Buffer
		val.WriteString(keyEXIFTag.Val(tagFmt, numComp, ""))
		if tag.Format() == tiff.StringVal {
			str := tag.StringVal()
			if containsUnsafeRawStrByte(str) {
				val.WriteString(urle(str))
			} else {
				val.WriteString(str)
			}
		} else {
			for i := 0; i < int(tag.Ncomp); i++ {
				if i > 0 {
					val.WriteByte('|')
				}
				switch tagFmt {
				case "int":
					fmt.Fprintf(&val, "%d", tag.Int(i))
				case "rat":
					n, d := tag.Rat2(i)
					fmt.Fprintf(&val, "%d/%d", n, d)
				case "float":
					fmt.Fprintf(&val, "%v", tag.Float(i))
				default:
					panic("shouldn't get here")
				}
			}
		}
		valStr := val.String()
		mm.Set(key, valStr)
		return nil
	}))

	longTag, err := ex.Get(exif.FieldName("GPSLongitude"))
	if err != nil {
		return
	}
	ewTag, err := ex.Get(exif.FieldName("GPSLongitudeRef"))
	if err != nil {
		return
	}
	latTag, err := ex.Get(exif.FieldName("GPSLatitude"))
	if err != nil {
		return
	}
	nsTag, err := ex.Get(exif.FieldName("GPSLatitudeRef"))
	if err != nil {
		return
	}
	long := tagDegrees(longTag)
	lat := tagDegrees(latTag)
	if ewTag.StringVal() == "W" {
		long *= -1.0
	}
	if nsTag.StringVal() == "S" {
		lat *= -1.0
	}
	mm.Set(keyEXIFGPS.Key(wholeRef), keyEXIFGPS.Val(fmt.Sprint(lat), fmt.Sprint(long)))
}

// Decode decodes an image from r using the provided decoding options.
// The string returned is the format name returned by image.Decode.
// If opts is nil, the defaults are used.
func Decode(r io.Reader, opts *DecodeOpts) (image.Image, string, error) {
	var buf bytes.Buffer
	tr := io.TeeReader(io.LimitReader(r, 2<<20), &buf)
	angle := 0
	flipMode := FlipDirection(0)
	if opts.useEXIF() {
		ex, err := exif.Decode(tr)
		if err != nil {
			imageDebug("No valid EXIF; will not rotate or flip.")
			return image.Decode(io.MultiReader(&buf, r))
		}
		tag, err := ex.Get(exif.Orientation)
		if err != nil {
			imageDebug("No \"Orientation\" tag in EXIF; will not rotate or flip.")
			return image.Decode(io.MultiReader(&buf, r))
		}
		orient := tag.Val[1]
		switch orient {
		case 1:
			// do nothing
		case 2:
			flipMode = 2
		case 3:
			angle = 180
		case 4:
			angle = 180
			flipMode = 2
		case 5:
			angle = -90
			flipMode = 2
		case 6:
			angle = -90
		case 7:
			angle = 90
			flipMode = 2
		case 8:
			angle = 90
		}
	} else {
		if opts.forcedRotate() {
			var ok bool
			angle, ok = opts.Rotate.(int)
			if !ok {
				return nil, "", fmt.Errorf("Rotate should be an int, not a %T", opts.Rotate)
			}
		}
		if opts.forcedFlip() {
			var ok bool
			flipMode, ok = opts.Flip.(FlipDirection)
			if !ok {
				return nil, "", fmt.Errorf("Flip should be a FlipDirection, not a %T", opts.Flip)
			}
		}
	}

	im, err := jpeg.Decode(io.MultiReader(&buf, r))
	if err != nil {
		return nil, "", err
	}
	return flip(rotate(im, angle), flipMode), "jpeg", nil
}

// Decode decodes an image from r using the provided decoding options.
// The Config returned is similar to the one from the image package,
// with the addition of the Modified field which indicates if the
// image was actually flipped or rotated.
// If opts is nil, the defaults are used.
func Decode(r io.Reader, opts *DecodeOpts) (image.Image, Config, error) {
	var c Config
	var buf bytes.Buffer
	tr := io.TeeReader(io.LimitReader(r, 2<<20), &buf)
	angle := 0
	flipMode := FlipDirection(0)
	if opts.useEXIF() {
		ex, err := exif.Decode(tr)
		maybeRescale := func() (image.Image, Config, error) {
			im, format, err := image.Decode(io.MultiReader(&buf, r))
			if err == nil && opts.wantRescale(im.Bounds()) {
				im = rescale(im, opts)
				c.Modified = true
			}
			c.Format = format
			c.setBounds(im)
			return im, c, err
		}
		if err != nil {
			imageDebug("No valid EXIF; will not rotate or flip.")
			return maybeRescale()
		}
		tag, err := ex.Get(exif.Orientation)
		if err != nil {
			imageDebug("No \"Orientation\" tag in EXIF; will not rotate or flip.")
			return maybeRescale()
		}
		orient := tag.Int(0)
		switch orient {
		case topLeftSide:
			// do nothing
		case topRightSide:
			flipMode = 2
		case bottomRightSide:
			angle = 180
		case bottomLeftSide:
			angle = 180
			flipMode = 2
		case leftSideTop:
			angle = -90
			flipMode = 2
		case rightSideTop:
			angle = -90
		case rightSideBottom:
			angle = 90
			flipMode = 2
		case leftSideBottom:
			angle = 90
		}
	} else {
		if opts.forcedRotate() {
			var ok bool
			angle, ok = opts.Rotate.(int)
			if !ok {
				return nil, c, fmt.Errorf("Rotate should be an int, not a %T", opts.Rotate)
			}
		}
		if opts.forcedFlip() {
			var ok bool
			flipMode, ok = opts.Flip.(FlipDirection)
			if !ok {
				return nil, c, fmt.Errorf("Flip should be a FlipDirection, not a %T", opts.Flip)
			}
		}
	}

	im, format, err := image.Decode(io.MultiReader(&buf, r))
	if err != nil {
		return nil, c, err
	}
	rescaled := false
	if opts.wantRescale(im.Bounds()) {
		im = rescale(im, opts)
		rescaled = true
	}
	im = flip(rotate(im, angle), flipMode)
	modified := true
	if angle == 0 && flipMode == 0 && !rescaled {
		modified = false
	}

	c.Format = format
	c.Modified = modified
	c.setBounds(im)
	return im, c, nil
}

// Decode decodes an image from r using the provided decoding options.
// The Config returned is similar to the one from the image package,
// with the addition of the Modified field which indicates if the
// image was actually flipped or rotated.
// If opts is nil, the defaults are used.
func Decode(r io.Reader, opts *DecodeOpts) (image.Image, Config, error) {
	var c Config
	var buf bytes.Buffer
	tr := io.TeeReader(io.LimitReader(r, 2<<20), &buf)
	angle := 0
	flipMode := FlipDirection(0)
	if opts.useEXIF() {
		ex, err := exif.Decode(tr)
		if err != nil {
			imageDebug("No valid EXIF; will not rotate or flip.")
			im, format, err := image.Decode(io.MultiReader(&buf, r))
			c.Format = format
			c.setBounds(im)
			return im, c, err
		}
		tag, err := ex.Get(exif.Orientation)
		if err != nil {
			imageDebug("No \"Orientation\" tag in EXIF; will not rotate or flip.")
			im, format, err := image.Decode(io.MultiReader(&buf, r))
			c.Format = format
			c.setBounds(im)
			return im, c, err
		}
		orient := tag.Int(0)
		switch orient {
		case 1:
			// do nothing
		case 2:
			flipMode = 2
		case 3:
			angle = 180
		case 4:
			angle = 180
			flipMode = 2
		case 5:
			angle = -90
			flipMode = 2
		case 6:
			angle = -90
		case 7:
			angle = 90
			flipMode = 2
		case 8:
			angle = 90
		}
	} else {
		if opts.forcedRotate() {
			var ok bool
			angle, ok = opts.Rotate.(int)
			if !ok {
				return nil, c, fmt.Errorf("Rotate should be an int, not a %T", opts.Rotate)
			}
		}
		if opts.forcedFlip() {
			var ok bool
			flipMode, ok = opts.Flip.(FlipDirection)
			if !ok {
				return nil, c, fmt.Errorf("Flip should be a FlipDirection, not a %T", opts.Flip)
			}
		}
	}

	im, err := jpeg.Decode(io.MultiReader(&buf, r))
	if err != nil {
		return nil, c, err
	}
	im = flip(rotate(im, angle), flipMode)
	modified := true
	if angle == 0 && flipMode == 0 {
		modified = false
	}
	c.Format = "jpeg"
	c.Modified = modified
	c.setBounds(im)
	return im, c, nil
}