调整GIF所有帧色相与饱和度后帧失真问题排查

我尝试使用bild库为GIF的所有帧应用色相和饱和度效果。由于adjust.Hue()和adjust.Saturation()函数仅接受*image.RGBA类型，我将GIF的*image.Paletted帧转换为*image.RGBA，应用滤镜后再转换回*image.Paletted。滤镜功能似乎生效，但帧出现失真情况。

输入GIF：

输出GIF：

以下是我的代码：

package main

import (
    "image"
    "image/color"
    "image/draw"
    "image/gif"
    "log"
    "os"

    "github.com/anthonynsimon/bild/adjust"
)

type ImageData struct {
    Hue        int
    Saturation float64
}

func ProcessGif(inputPath string, outputPath string, imageData ImageData) error {
    file, err := os.Open(inputPath)
    if err != nil {
        return err
    }
    defer file.Close()

    gifImage, err := gif.DecodeAll(file)
    if err != nil {
        return err
    }

    // Process each frame
    for i, img := range gifImage.Image {
        // Convert *image.Paletted to *image.RGBA
        rgba := PalettedToRGBA(img)

        // Apply adjustments
        rgba = adjust.Hue(rgba, imageData.Hue)
        rgba = adjust.Saturation(rgba, imageData.Saturation)

        // Convert *image.RGBA to *image.Paletted
        gifImage.Image[i] = RGBAToPaletted(rgba)

    }

    outputFile, err := os.Create(outputPath)
    if err != nil {
        return err
    }
    defer outputFile.Close()

    return gif.EncodeAll(outputFile, gifImage)
}

func PalettedToRGBA(paletted *image.Paletted) *image.RGBA {
    bounds := paletted.Bounds()
    rgba := image.NewRGBA(bounds)
    draw.Draw(rgba, bounds, paletted, image.Point{}, draw.Over)
    return rgba
}

func RGBAToPaletted(rgba *image.RGBA) *image.Paletted {
    bounds := rgba.Bounds()
    // Extract the unique colors from the RGBA image
    palette := color.Palette{}
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            c := rgba.At(x, y)
            if !sliceIncludes(palette, c) {
                palette = append(palette, c)
            }
        }
    }
    // Create the Paletted image with the constructed palette
    paletted := image.NewPaletted(bounds, palette)
    draw.Draw(paletted, bounds, rgba, image.Point{}, draw.Over)
    return paletted
}

func sliceIncludes[T comparable](slice []T, t T) bool {
    for _, c := range slice {
        if c == t {
            return true
        }
    }
    return false
}

func main() {
    imgData := ImageData{
        Hue:        80,
        Saturation: 0.4,
    }
    log.Fatal(ProcessGif("image.gif", "output.gif", imgData))
}

问题原因 #

1. 调色板数量超限：GIF格式强制要求调色板最多包含256种颜色，但你的RGBAToPaletted函数会提取处理后RGBA图像的所有唯一颜色，一旦颜色数超过256，image.NewPaletted会自动截断调色板，导致颜色映射错误，出现失真。
2. 颜色匹配逻辑粗糙：draw.Draw将RGBA绘制到Paletted图像时，会选用调色板中最接近的颜色，但你当前的调色板只保留精确匹配的颜色，大量颜色会被错误映射，加剧失真。
3. 帧调色板不一致：每帧单独生成调色板会导致帧与帧之间调色板不统一，播放时出现颜色跳跃或闪烁的失真。

修复方案 #

方案1：生成全局统一调色板 #

为所有处理后的帧生成一个最多256色的全局调色板，将所有帧映射到该调色板上，保证颜色一致性：

func ProcessGif(inputPath string, outputPath string, imageData ImageData) error {
    file, err := os.Open(inputPath)
    if err != nil {
        return err
    }
    defer file.Close()

    gifImage, err := gif.DecodeAll(file)
    if err != nil {
        return err
    }

    // 先处理所有帧为RGBA并保存
    processedRGBA := make([]*image.RGBA, len(gifImage.Image))
    for i, img := range gifImage.Image {
        rgba := PalettedToRGBA(img)
        rgba = adjust.Hue(rgba, imageData.Hue)
        rgba = adjust.Saturation(rgba, imageData.Saturation)
        processedRGBA[i] = rgba
    }

    // 生成全局调色板（最多256色）
    globalPalette := generateGlobalPalette(processedRGBA, 256)

    // 将所有RGBA帧转换为使用全局调色板的Paletted图像
    for i, rgba := range processedRGBA {
        paletted := image.NewPaletted(rgba.Bounds(), globalPalette)
        draw.Draw(paletted, paletted.Bounds(), rgba, image.Point{}, draw.Over)
        gifImage.Image[i] = paletted
    }

    outputFile, err := os.Create(outputPath)
    if err != nil {
        return err
    }
    defer outputFile.Close()

    return gif.EncodeAll(outputFile, gifImage)
}

// 生成全局调色板，收集所有颜色后去重截断（简化实现）
func generateGlobalPalette(images []*image.RGBA, maxColors int) color.Palette {
    seen := make(map[color.RGBA]bool)
    palette := make(color.Palette, 0, maxColors)

    for _, img := range images {
        bounds := img.Bounds()
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            for x := bounds.Min.X; x < bounds.Max.X; x++ {
                rgba := color.RGBAModel.Convert(img.At(x, y)).(color.RGBA)
                if !seen[rgba] && len(palette) < maxColors {
                    seen[rgba] = true
                    palette = append(palette, rgba)
                }
                if len(palette) >= maxColors {
                    goto endLoop
                }
            }
        }
    }
endLoop:
    return palette
}

方案2：用专业库做颜色量化 #

手动实现的调色板生成效果有限，推荐使用github.com/lucasb-eyer/go-colorful库进行颜色量化，能更精准地将颜色压缩到256种以内：

1. 安装库：

go get github.com/lucasb-eyer/go-colorful

2. 修改调色板生成函数：

import "github.com/lucasb-eyer/go-colorful"

func generateGlobalPalette(images []*image.RGBA, maxColors int) color.Palette {
    // 转换所有颜色为colorful.Color格式
    var colors []colorful.Color
    for _, img := range images {
        bounds := img.Bounds()
        for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
            for x := bounds.Min.X; x < bounds.Max.X; x++ {
                r, g, b, _ := img.At(x, y).RGBA()
                col := colorful.Color{
                    R: float64(r) / 65535,
                    G: float64(g) / 65535,
                    B: float64(b) / 65535,
                }
                colors = append(colors, col)
            }
        }
    }

    // 使用中值切割法量化颜色
    paletteColors, _ := colorful.Quantize(maxColors, colors)

    // 转换为color.Palette格式
    palette := make(color.Palette, len(paletteColors))
    for i, c := range paletteColors {
        r, g, b := c.RGB255()
        palette[i] = color.RGBA{R: r, G: g, B: b, A: 255}
    }
    return palette
}

额外优化点 #

• 保留原GIF的延迟时间、循环次数等元数据，保证播放效果一致；
• 处理透明通道：如果原GIF包含透明色，需确保转换过程中透明信息不丢失。

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