如何实现io.Reader包装器以逐图解码串联JPEG流？

要解决连续JPEG字节流的拆分解码问题，我们可以实现一个自定义的io.Reader包装器，利用bufio包的缓冲能力，精确控制每次读取的边界——读到EOI（0xff 0xd9）时返回io.EOF，让jpeg.Decode停止，后续读取自动定位到下一个SOI（0xff 0xd8）起始位置。

核心实现思路 #

1. 用bufio.Reader做底层缓冲，方便字节回退操作，避免丢失EOI之后的字节。
2. 维护一个状态标记，跟踪是否已定位到下一个JPEG的SOI起始点。
3. 在Read方法中：
   • 未定位SOI时，循环扫描直到找到0xff 0xd8序列。
   • 已定位SOI后，读取数据并检查是否出现EOI序列，一旦找到就截断读取并返回EOF，同时将EOI之后的字节回退到缓冲中。
   • 处理EOI跨两次读取的边界情况（比如单次读取末尾是0xff，下一个字节是0xd9）。

完整代码实现 #

package main

import (
    "bufio"
    "image/jpeg"
    "io"
    "log"
)

// JPEGStreamSplitter 是拆分连续JPEG流的自定义Reader
type JPEGStreamSplitter struct {
    br        *bufio.Reader
    foundSOI bool // 标记是否已定位到下一个JPEG的SOI起始位置
}

// NewJPEGStreamSplitter 创建一个新的JPEG流拆分器
func NewJPEGStreamSplitter(r io.Reader) *JPEGStreamSplitter {
    return &JPEGStreamSplitter{
        br: bufio.NewReader(r),
    }
}

// Read 实现io.Reader接口，控制读取到EOI时返回EOF
func (s *JPEGStreamSplitter) Read(p []byte) (n int, err error) {
    // 第一步：定位到下一个JPEG的SOI起始位置
    if !s.foundSOI {
        for {
            // 寻找SOI的第一个字节0xff
            b, err := s.br.ReadByte()
            if err != nil {
                return 0, err
            }
            if b == 0xff {
                // 检查下一个字节是否是0xd8
                nextByte, err := s.br.ReadByte()
                if err != nil {
                    return 0, err
                }
                if nextByte == 0xd8 {
                    // 找到SOI，将两个字节回退到缓冲中，供后续读取
                    if err := s.br.UnreadByte(); err != nil {
                        return 0, err
                    }
                    if err := s.br.UnreadByte(); err != nil {
                        return 0, err
                    }
                    s.foundSOI = true
                    break
                }
                // 不是SOI的第二字节，继续寻找下一个0xff
            }
        }
    }

    // 第二步：读取数据，直到找到EOI
    n, err = s.br.Read(p)
    if n == 0 {
        return n, err
    }

    // 检查当前读取的字节中是否包含EOI序列
    for i := 0; i < n-1; i++ {
        if p[i] == 0xff && p[i+1] == 0xd9 {
            // 找到EOI，将EOI之后的字节回退到缓冲
            for j := n - 1; j >= i+2; j-- {
                if err := s.br.UnreadByte(); err != nil {
                    return 0, err
                }
            }
            // 返回EOI之前（含EOI）的字节，并标记需要重新定位SOI
            s.foundSOI = false
            return i + 2, io.EOF
        }
    }

    // 处理EOI跨缓冲区的情况：当前读取的最后一个字节是0xff，检查下一个字节是否是0xd9
    if p[n-1] == 0xff {
        nextByte, err := s.br.ReadByte()
        if err != nil {
            return n, err
        }
        if nextByte == 0xd9 {
            // 是EOI，尝试将这个字节加入输出（如果p还有空间）
            if n < len(p) {
                p[n] = nextByte
                n++
            } else {
                // p已满，将字节回退，下次读取时处理
                if err := s.br.UnreadByte(); err != nil {
                    return n, err
                }
                return n, nil
            }
            s.foundSOI = false
            return n, io.EOF
        }
        // 不是EOI，回退字节并返回当前读取的内容
        if err := s.br.UnreadByte(); err != nil {
            return n, err
        }
    }

    // 未找到EOI，返回当前读取的字节和原错误
    return n, err
}

// 使用示例
func main() {
    // 替换为你的命令stdout流，比如cmd.Stdout
    var inputStream io.Reader = ... 

    splitter := NewJPEGStreamSplitter(inputStream)

    for {
        img, err := jpeg.Decode(splitter)
        if err == io.EOF {
            // 所有JPEG解码完成
            break
        }
        if err != nil {
            log.Fatalf("解码失败: %v", err)
        }
        // 处理解码后的图片，比如保存、显示等
        // processImage(img)
    }
}

关键细节说明 #

• 字节回退：使用bufio.Reader的UnreadByte方法，将EOI之后的字节放回缓冲，确保下次读取可以直接从下一个SOI开始。
• 状态标记：foundSOI标记避免重复扫描SOI，提升效率，同时确保每次解码都从合法的JPEG起始点开始。
• 边界处理：针对EOI跨两次读取的情况做了特殊处理，避免遗漏或错误截断JPEG数据。

内容的提问来源于stack exchange，提问作者Yann Coleu