gtsocial-umbx

value_encoder.go (6439B)

---

 package exifcommon
 
 import (
 	"bytes"
 	"math"
 	"reflect"
 	"time"
 
 	"encoding/binary"
 
 	"github.com/dsoprea/go-logging"
 )
 
 var (
 	typeEncodeLogger = log.NewLogger("exif.type_encode")
 )
 
 // EncodedData encapsulates the compound output of an encoding operation.
 type EncodedData struct {
 	Type    TagTypePrimitive
 	Encoded []byte
 
 	// TODO(dustin): Is this really necessary? We might have this just to correlate to the incoming stream format (raw bytes and a unit-count both for incoming and outgoing).
 	UnitCount uint32
 }
 
 // ValueEncoder knows how to encode values of every type to bytes.
 type ValueEncoder struct {
 	byteOrder binary.ByteOrder
 }
 
 // NewValueEncoder returns a new ValueEncoder.
 func NewValueEncoder(byteOrder binary.ByteOrder) *ValueEncoder {
 	return &ValueEncoder{
 		byteOrder: byteOrder,
 	}
 }
 
 func (ve *ValueEncoder) encodeBytes(value []uint8) (ed EncodedData, err error) {
 	ed.Type = TypeByte
 	ed.Encoded = []byte(value)
 	ed.UnitCount = uint32(len(value))
 
 	return ed, nil
 }
 
 func (ve *ValueEncoder) encodeAscii(value string) (ed EncodedData, err error) {
 	ed.Type = TypeAscii
 
 	ed.Encoded = []byte(value)
 	ed.Encoded = append(ed.Encoded, 0)
 
 	ed.UnitCount = uint32(len(ed.Encoded))
 
 	return ed, nil
 }
 
 // encodeAsciiNoNul returns a string encoded as a byte-string without a trailing
 // NUL byte.
 //
 // Note that:
 //
 // 1. This type can not be automatically encoded using `Encode()`. The default
 //    mode is to encode *with* a trailing NUL byte using `encodeAscii`. Only
 //    certain undefined-type tags using an unterminated ASCII string and these
 //    are exceptional in nature.
 //
 // 2. The presence of this method allows us to completely test the complimentary
 //    no-nul parser.
 //
 func (ve *ValueEncoder) encodeAsciiNoNul(value string) (ed EncodedData, err error) {
 	ed.Type = TypeAsciiNoNul
 	ed.Encoded = []byte(value)
 	ed.UnitCount = uint32(len(ed.Encoded))
 
 	return ed, nil
 }
 
 func (ve *ValueEncoder) encodeShorts(value []uint16) (ed EncodedData, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	ed.UnitCount = uint32(len(value))
 	ed.Encoded = make([]byte, ed.UnitCount*2)
 
 	for i := uint32(0); i < ed.UnitCount; i++ {
 		ve.byteOrder.PutUint16(ed.Encoded[i*2:(i+1)*2], value[i])
 	}
 
 	ed.Type = TypeShort
 
 	return ed, nil
 }
 
 func (ve *ValueEncoder) encodeLongs(value []uint32) (ed EncodedData, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	ed.UnitCount = uint32(len(value))
 	ed.Encoded = make([]byte, ed.UnitCount*4)
 
 	for i := uint32(0); i < ed.UnitCount; i++ {
 		ve.byteOrder.PutUint32(ed.Encoded[i*4:(i+1)*4], value[i])
 	}
 
 	ed.Type = TypeLong
 
 	return ed, nil
 }
 
 func (ve *ValueEncoder) encodeFloats(value []float32) (ed EncodedData, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	ed.UnitCount = uint32(len(value))
 	ed.Encoded = make([]byte, ed.UnitCount*4)
 
 	for i := uint32(0); i < ed.UnitCount; i++ {
 		ve.byteOrder.PutUint32(ed.Encoded[i*4:(i+1)*4], math.Float32bits(value[i]))
 	}
 
 	ed.Type = TypeFloat
 
 	return ed, nil
 }
 
 func (ve *ValueEncoder) encodeDoubles(value []float64) (ed EncodedData, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	ed.UnitCount = uint32(len(value))
 	ed.Encoded = make([]byte, ed.UnitCount*8)
 
 	for i := uint32(0); i < ed.UnitCount; i++ {
 		ve.byteOrder.PutUint64(ed.Encoded[i*8:(i+1)*8], math.Float64bits(value[i]))
 	}
 
 	ed.Type = TypeDouble
 
 	return ed, nil
 }
 
 func (ve *ValueEncoder) encodeRationals(value []Rational) (ed EncodedData, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	ed.UnitCount = uint32(len(value))
 	ed.Encoded = make([]byte, ed.UnitCount*8)
 
 	for i := uint32(0); i < ed.UnitCount; i++ {
 		ve.byteOrder.PutUint32(ed.Encoded[i*8+0:i*8+4], value[i].Numerator)
 		ve.byteOrder.PutUint32(ed.Encoded[i*8+4:i*8+8], value[i].Denominator)
 	}
 
 	ed.Type = TypeRational
 
 	return ed, nil
 }
 
 func (ve *ValueEncoder) encodeSignedLongs(value []int32) (ed EncodedData, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	ed.UnitCount = uint32(len(value))
 
 	b := bytes.NewBuffer(make([]byte, 0, 8*ed.UnitCount))
 
 	for i := uint32(0); i < ed.UnitCount; i++ {
 		err := binary.Write(b, ve.byteOrder, value[i])
 		log.PanicIf(err)
 	}
 
 	ed.Type = TypeSignedLong
 	ed.Encoded = b.Bytes()
 
 	return ed, nil
 }
 
 func (ve *ValueEncoder) encodeSignedRationals(value []SignedRational) (ed EncodedData, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	ed.UnitCount = uint32(len(value))
 
 	b := bytes.NewBuffer(make([]byte, 0, 8*ed.UnitCount))
 
 	for i := uint32(0); i < ed.UnitCount; i++ {
 		err := binary.Write(b, ve.byteOrder, value[i].Numerator)
 		log.PanicIf(err)
 
 		err = binary.Write(b, ve.byteOrder, value[i].Denominator)
 		log.PanicIf(err)
 	}
 
 	ed.Type = TypeSignedRational
 	ed.Encoded = b.Bytes()
 
 	return ed, nil
 }
 
 // Encode returns bytes for the given value, infering type from the actual
 // value. This does not support `TypeAsciiNoNull` (all strings are encoded as
 // `TypeAscii`).
 func (ve *ValueEncoder) Encode(value interface{}) (ed EncodedData, err error) {
 	defer func() {
 		if state := recover(); state != nil {
 			err = log.Wrap(state.(error))
 		}
 	}()
 
 	switch t := value.(type) {
 	case []byte:
 		ed, err = ve.encodeBytes(t)
 		log.PanicIf(err)
 	case string:
 		ed, err = ve.encodeAscii(t)
 		log.PanicIf(err)
 	case []uint16:
 		ed, err = ve.encodeShorts(t)
 		log.PanicIf(err)
 	case []uint32:
 		ed, err = ve.encodeLongs(t)
 		log.PanicIf(err)
 	case []float32:
 		ed, err = ve.encodeFloats(t)
 		log.PanicIf(err)
 	case []float64:
 		ed, err = ve.encodeDoubles(t)
 		log.PanicIf(err)
 	case []Rational:
 		ed, err = ve.encodeRationals(t)
 		log.PanicIf(err)
 	case []int32:
 		ed, err = ve.encodeSignedLongs(t)
 		log.PanicIf(err)
 	case []SignedRational:
 		ed, err = ve.encodeSignedRationals(t)
 		log.PanicIf(err)
 	case time.Time:
 		// For convenience, if the user doesn't want to deal with translation
 		// semantics with timestamps.
 
 		s := ExifFullTimestampString(t)
 
 		ed, err = ve.encodeAscii(s)
 		log.PanicIf(err)
 	default:
 		log.Panicf("value not encodable: [%s] [%v]", reflect.TypeOf(value), value)
 	}
 
 	return ed, nil
 }