Golang: Read buffered input as signed 16bit ints

I am trying to read a buffered stream of signed 16 bit integers (wav format), but the bufio.Read method only accepts an array of bytes. My question is a 2-parter:

1. Can I preformat the byte stream into a buffered int16 array?

2. If I can't, whats the best way of post-processing the byte array into int16 array? My initial thought is to use tmp arrays and keep pushing/processing them, but I was curious if there was a more idiomatic way of doing this?

    package main
   
    import (
         "bufio"
         "io"
         "log"
         "os/exec"
    )
   
    func main() {
   
        app := "someapp"
   
        cmd := exec.Command(app)
        stdout, err := cmd.StdoutPipe()
        r := bufio.NewReader(stdout)
        if err != nil {
    	    log.Fatal(err)
        }
        if err := cmd.Start(); err != nil {
    	    log.Fatal(err)
        }
   
        //"someapp" outputs signed 16bit integers (little endian))
        buf := make([]byte, 0, 4*1024)
   
        for {
            n, err := r.Read(buf[:cap(buf)])	//r.Read only accepts type []byte
    	    buf = buf[:n]
    	    if n == 0 {
        	    if err == nil {
    	    	    continue
    	        }
    		    if err == io.EOF {
    			    break
        	    }
    	        log.Fatal(err)
    	    }
   
    	    log.Printf("%x\n", buf)
            //process buf here
   
            if err != nil && err != io.EOF {
    	        log.Fatal(err)
    	    }
        }
    }
   

When working with IO, you always work with []bytes, there's no way to substitute that with []int16, or pre-format that as int16s, it's always a stream of bytes.

You can look at the encoding/binary package to decode this stream.

// to get the first uint16 as i
i := binary.LittleEndian.Uint16(buf[:2])

You can then iterate through the buf as needed.

You can also use binary.Read to read directly from the io.Reader.

var i uint16
for {
	err := binary.Read(r, binary.LittleEndian, &i)
	if err != nil {
		log.Println(err)
		break
	}
	fmt.Println(i)
}

It may worth noting the simplicity of what needs to be done. Each uint16 is created via:

func (littleEndian) Uint16(b []byte) uint16 {
    return uint16(b[0]) | uint16(b[1])<<8
}

You can use encoding/binary.Read to fill an []int16 directly from your reader, although technically the answer to your first question is still no (check the source of binary.Read, it reads the data to a []byte first).