// PutUint32 serializes the provided uint32 using the given byte order into a // buffer from the free list and writes the resulting four bytes to the given // writer. func (l binaryFreeList) PutUint32(w io.Writer, byteOrder binary.ByteOrder, val uint32) error { buf := l.Borrow()[:4] byteOrder.PutUint32(buf, val) _, err := w.Write(buf) l.Return(buf) return err }
func packParamString(bin binary.ByteOrder, s string) []byte { b := make([]byte, (4+len(s)+1+3) & ^0x3) // must be 32-bit aligned bin.PutUint32(b[0:], uint32(len(s)+1)) copy(b[4:], []byte(s)) b[4+len(s)] = 0 return b }
func durationToBytes(d time.Duration, order binary.ByteOrder) []byte { buf := make([]byte, 8) nsec := d.Nanoseconds() order.PutUint32(buf, uint32(nsec/nanosPerSec)) order.PutUint32(buf[4:], uint32(nsec%nanosPerSec)) return buf }
func timeToBytes(t time.Time, order binary.ByteOrder) []byte { sec := uint32(t.Unix()) frac := uint32((nanosPerSec - 1 + (int64(t.Nanosecond()) << 32)) / nanosPerSec) b := make([]byte, 8) order.PutUint32(b[0:], sec) order.PutUint32(b[4:], frac) return b }
func writeIFD(w io.Writer, ifdOffset int, d []IfdEntry, enc binary.ByteOrder) error { var buf [ifdLen]byte // Make space for "pointer area" containing IFD entry data // longer than 4 bytes. parea := make([]byte, 1024) pstart := ifdOffset + ifdLen*len(d) + 6 var o int // Current offset in parea. // The IFD has to be written with the tags in ascending order. sort.Sort(ifdSortedByCode(d)) // Write the number of entries in this IFD. if err := binary.Write(w, enc, uint16(len(d))); err != nil { return err } for _, ent := range d { enc.PutUint16(buf[0:2], uint16(ent.tag.Code)) enc.PutUint16(buf[2:4], uint16(ent.dataType)) count := uint32(ent.count) enc.PutUint32(buf[4:8], count) datalen := int(count * lengths[ent.dataType]) if datalen <= 4 { for i, b := range ent.rawData { buf[8+i] = b } } else { if (o + datalen) > len(parea) { newlen := len(parea) + 1024 for (o + datalen) > newlen { newlen += 1024 } newarea := make([]byte, newlen) copy(newarea, parea) parea = newarea } for i, b := range ent.rawData { parea[o+i] = b } enc.PutUint32(buf[8:12], uint32(pstart+o)) o += datalen } if _, err := w.Write(buf[:]); err != nil { return err } } // The IFD ends with the offset of the next IFD in the file, // or zero if it is the last one (page 14). if err := binary.Write(w, enc, uint32(0)); err != nil { return err } _, err := w.Write(parea[:o]) return err }
func packUint(order binary.ByteOrder, v interface{}) (data []byte) { switch val := v.(type) { case uint64: data = make([]byte, 8) order.PutUint64(data, val) case uint32: data = make([]byte, 4) order.PutUint32(data, val) case uint16: data = make([]byte, 2) order.PutUint16(data, val) case uint8: data = []byte{byte(val)} default: panic("unsupported type") } return data }
func newSimpleProtocol(n int, byteOrder binary.ByteOrder) *simpleProtocol { protocol := &simpleProtocol{ n: n, bo: byteOrder, } switch n { case 1: protocol.encodeHead = func(buffer []byte) { buffer[0] = byte(len(buffer) - n) } protocol.decodeHead = func(buffer []byte) int { return int(buffer[0]) } case 2: protocol.encodeHead = func(buffer []byte) { byteOrder.PutUint16(buffer, uint16(len(buffer)-n)) } protocol.decodeHead = func(buffer []byte) int { return int(byteOrder.Uint16(buffer)) } case 4: protocol.encodeHead = func(buffer []byte) { byteOrder.PutUint32(buffer, uint32(len(buffer)-n)) } protocol.decodeHead = func(buffer []byte) int { return int(byteOrder.Uint32(buffer)) } case 8: protocol.encodeHead = func(buffer []byte) { byteOrder.PutUint64(buffer, uint64(len(buffer)-n)) } protocol.decodeHead = func(buffer []byte) int { return int(byteOrder.Uint64(buffer)) } default: panic("unsupported packet head size") } return protocol }
func WriteFloat32(buf []byte, sample float32, format byte, endianness binary.ByteOrder) { encoding := format & EncodingMask if encoding == EncodingFloatingPoint { endianness.PutUint32(buf, math.Float32bits(sample)) } else { mult := math.Pow(2, float64(len(buf)*8-1)) var offset float64 = -0.5 // Round instead of floor if encoding == EncodingUnsignedInt { offset = mult - 1.5 } bits := uint32(float64(sample)*mult + offset) tmp := make([]byte, 4) endianness.PutUint32(tmp, bits) if endianness == binary.BigEndian { copy(buf, tmp[4-len(buf):4]) } else { copy(buf, tmp) } } }
func (s Custom) Pack(buf []byte, order binary.ByteOrder) ([]byte, error) { order.PutUint32(buf[0:4], uint32(*s.A)) return buf[4:], nil }
func (b *Buffer) WriteUint32(u uint32, order binary.ByteOrder) error { i := b.Grows(4) order.PutUint32(b.Buf[i:], u) return nil }
// WriteUInt32 writes a uint32 to w. func WriteUInt32(w io.Writer, byteOrder binary.ByteOrder, value uint32) error { var buf [4]byte byteOrder.PutUint32(buf[:], value) _, err := w.Write(buf[:]) return err }