go - 为什么 Go 根据我声明缓冲区的位置设置不同的内容类型

Question

我尝试播放视频，但无法解释以下行为。我从 Go 的 net/http 服务器、两个不同的处理程序获得不同的响应 header ，唯一的区别是我声明缓冲区的位置。

在下面的代码中有两个处理程序，唯一的区别是一个处理程序在本地声明缓冲区。在那个版本中，流媒体工作正常，Chrome 流媒体视频，我看到它得到了传输编码的响应:分块和内容类型:video/mp4。

在缓冲区是输入参数的第二个版本中，Chrome 不会流式传输视频并且 header 不同。

package main

import (
    "bytes"
    "io"
    "log"
    "net/http"
    "os"
)

func main() {
    file := "/Users/someUser/Documents/Zoom/Ronen/zoom_0.mp4"

    f, err := os.Open(file)
    defer f.Close()

    if err != nil {
        log.Fatalln(err)
    }
    http.ListenAndServe(":9008", GetVidHandler(f))
}

//This implementation works, buff is declared locally.
//I get header of content-type video/mp4
func GetVidHandler(f *os.File) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        offset := int64(0)
        var buff [4096]byte
        for {
            n, _ := f.ReadAt(buff[:], offset)
            offset += int64(n)
            re := bytes.NewReader(buff[:])
            io.Copy(w, re)
        }
    }
}

//This implementation doesn't stream, buff is input param
//I get header of content-type octet-stream
func GetVidHandler(f *os.File, buff [4096]byte) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        offset := int64(0)
        for {
            n, _ := f.ReadAt(buff[:], offset)
            offset += int64(n)
            re := bytes.NewReader(buff[:])
            io.Copy(w, re)
        }
    }
}

Answer 1

感谢您的评论，但修复它们仍然不会改变行为。敌人示例以下代码获取
write tcp 127.0.0.1:9008->127.0.0.1:60443: write: broken pipe

package main

import (
    "bytes"
    "io"
    "log"
    "net/http"
    "os"
)

type Viewer struct {
    ch   chan []byte
    buff [3][4096]byte
}

func main() {
    file := "/Users/someUSer/Documents/Zoom/Ronen/zoom_0.mp4"

    f, err := os.Open(file)
    defer f.Close()

    if err != nil {
        log.Fatalln(err)
    }

    m := make(map[int]*Viewer)
    start := make(chan struct{})

    go func() {

        offset := int64(0)
        <-start
        log.Println("Starting...")
        i := 0
        for {
            var b [4096]byte
            n, err := f.ReadAt(b[:], offset)
            if err != nil {
                log.Println(err)
                return
            }

            offset += int64(n)
            for _, v := range m {
                copy(v.buff[i%3][:], b[:n])
                v.ch <- v.buff[i%3][:n]
            }
            i++
        }

    }()

    http.ListenAndServe(":9008", GetVidHandler(m, start))

}

func GetVidHandler(m map[int]*Viewer, start chan struct{}) http.HandlerFunc {

    i := 0

    return func(w http.ResponseWriter, r *http.Request) {

        current := i
        v := &Viewer{ch: make(chan []byte)}
        m[current] = v
        i++
        select {
        case start <- struct{}{}:
        default:

        }
        cn, ok := w.(http.CloseNotifier)
        if !ok {
            http.NotFound(w, r)
            return
        }
        // flusher, ok := w.(http.Flusher)
        // if !ok {
        //  http.NotFound(w, r)
        //  return
        // }

        // Send the initial headers saying we're gonna stream the response.
        // w.Header().Set("Transfer-Encoding", "chunked")
        // w.Header().Set("Content-Type", "video/mp4")
        // w.WriteHeader(http.StatusOK)
        // // flusher.Flush()

        // b := <-v.ch
        // log.Println(current, "-Writing ", len(b), " Bytes")
        // log.Printf("%d - WRITE - First 100 bytes %v\n", current, b[:100])
        // w.Write(b[:len(b)])

        // flusher.Flush()
        for {
            select {
            case <-cn.CloseNotify():
                log.Println("Client stopped listening")
                return
            default:
                b := <-v.ch
                re := bytes.NewReader(b[:])
                _, err := io.Copy(w, re)
                if err != nil {
                    log.Println(err)

                }
            }
        }

    }

}

//Works
// func GetVidHandler(f *os.File) http.HandlerFunc {

//  return func(w http.ResponseWriter, r *http.Request) {
//      offset := int64(0)
//      var buff [4096]byte
//      for {
//          n, _ := f.ReadAt(buff[:], offset)
//          log.Printf("WRITE - First 100 bytes %v\n", buff[:100])

//          offset += int64(n)
//          re := bytes.NewReader(buff[:])
//          io.Copy(w, re)
//      }
//  }

// }