Zig读取WAV文件头获取无效参数问题求助

你的代码里有两个致命错误，直接导致读取的采样率、声道数等参数全是无效值：

1. 数据流向完全颠倒 #

你用了std.mem.writeInt，这是把未初始化的变量值写入到WAV字节数组里，而实际需求是从字节数组读取数据到变量。逻辑搞反了，自然读不到正确参数，应该用std.mem.readInt来从指定字节范围读取对应类型的值。

2. 变量声明错误 #

所有要接收读取结果的变量用了const声明且初始化为undefined，const变量无法被赋值，必须改成var。

修正后的完整代码 #

const std = @import("std");

pub const WavObject = struct {
    riff_identifier: *[4]u8, // Chunk identifier: "RIFF"
    riff_chunk_size: u32, // Chunk size (file size - 8 bytes)
    riff_format: *[4]u8, // Format identifier: "WAVE"
    fmt_identifier: *[4]u8, // Format subchunk identifier: "fmt "
    fmt_subchunk_size: u32, // Subchunk size (16 for PCM)
    fmt_audio_format: u16, // Audio format (1 for PCM)
    fmt_num_channels: u16, // Number of channels (1 for mono, 2 for stereo)
    fmt_sample_rate: u32, // Sample rate (samples per second)
    fmt_byte_rate: u32, // Byte rate (sample rate * block size)
    fmt_block_size: u16, // Block size (channels * bits per sample / 8)
    fmt_bits_per_sample: u16, //Bits per sample (8 or 16)
    data_identifier: *[4]u8, // Data subchunk identifier: "data"
    data_size: u32, // Data subchunk size (size of the raw audio data)

    pub fn deserializeHeader(wavBytes: []u8, allocator: std.mem.Allocator) !*WavObject {
        var wavObj = try allocator.create(WavObject);
        if (wavBytes.len < 44) return error.InvalidWav;

        // 改为var声明，允许后续赋值
        var riffChunku32: u32 = undefined;
        var subChunkSize: u32 = undefined;
        var audioFormat: u16 = undefined;
        var numChannels: u16 = undefined;
        var sampleRate: u32 = undefined;
        var byteRate: u32 = undefined;
        var blockSize: u16 = undefined;
        var bitsPerSample: u16 = undefined;
        var dataSize: u32 = undefined;

        // 用readInt从字节数组读取数据到变量，替代错误的writeInt
        riffChunku32 = std.mem.readInt(u32, wavBytes[4..8], .little);
        subChunkSize = std.mem.readInt(u32, wavBytes[16..20], .little);
        audioFormat = std.mem.readInt(u16, wavBytes[20..22], .little);
        numChannels = std.mem.readInt(u16, wavBytes[22..24], .little);
        sampleRate = std.mem.readInt(u32, wavBytes[24..28], .little);
        byteRate = std.mem.readInt(u32, wavBytes[28..32], .little);
        blockSize = std.mem.readInt(u16, wavBytes[32..34], .little);
        bitsPerSample = std.mem.readInt(u16, wavBytes[34..36], .little);
        dataSize = std.mem.readInt(u32, wavBytes[40..44], .little);

        // 用@ptrCast正确转换切片为固定大小数组指针
        wavObj.riff_identifier = @ptrCast(*[4]u8, wavBytes[0..4]);
        wavObj.riff_chunk_size = riffChunku32;
        wavObj.riff_format = @ptrCast(*[4]u8, wavBytes[8..12]);
        wavObj.fmt_identifier = @ptrCast(*[4]u8, wavBytes[12..16]);
        wavObj.fmt_subchunk_size = subChunkSize;
        wavObj.fmt_audio_format = audioFormat;
        wavObj.fmt_num_channels = numChannels;
        wavObj.fmt_sample_rate = sampleRate;
        wavObj.fmt_byte_rate = byteRate;
        wavObj.fmt_block_size = blockSize;
        wavObj.fmt_bits_per_sample = bitsPerSample;
        wavObj.data_identifier = @ptrCast(*[4]u8, wavBytes[36..40]);
        wavObj.data_size = dataSize;
        return wavObj;
    }

    // 补充原代码调用但未实现的PrintHeader方法
    pub fn PrintHeader(self: *const WavObject) void {
        std.debug.print("RIFF标识: {s}\n", .{self.riff_identifier});
        std.debug.print("RIFF块大小: {d}\n", .{self.riff_chunk_size});
        std.debug.print("格式: {s}\n", .{self.riff_format});
        std.debug.print("FMT标识: {s}\n", .{self.fmt_identifier});
        std.debug.print("FMT子块大小: {d}\n", .{self.fmt_subchunk_size});
        std.debug.print("音频格式: {d}\n", .{self.fmt_audio_format});
        std.debug.print("声道数: {d}\n", .{self.fmt_num_channels});
        std.debug.print("采样率: {d}\n", .{self.fmt_sample_rate});
        std.debug.print("字节率: {d}\n", .{self.fmt_byte_rate});
        std.debug.print("块大小: {d}\n", .{self.fmt_block_size});
        std.debug.print("采样位深: {d}\n", .{self.fmt_bits_per_sample});
        std.debug.print("数据标识: {s}\n", .{self.data_identifier});
        std.debug.print("数据大小: {d}\n", .{self.data_size});
    }

    test "basic play wav" {
        const start = std.time.microTimestamp();
        var gpa = std.heap.GeneralPurposeAllocator(.{}){};
        defer _ = gpa.deinit(); // 自动释放分配器资源
        const allocator = gpa.allocator();
        
        const buffer = try allocator.alloc(u8, 44); // 仅分配文件头所需的44字节
        defer allocator.free(buffer);
        
        const file = try std.fs.cwd().openFile("./samples/hip_hop_kick.wav", .{ .mode = .read_only });
        defer file.close(); // 自动关闭文件
        
        const reader = file.reader();
        _ = try reader.read(buffer);
        
        const wavObj = try WavObject.deserializeHeader(buffer, allocator);
        defer allocator.destroy(wavObj); // 自动释放WavObject内存
        
        wavObj.PrintHeader();
        std.debug.print("文件头字节: {d}\n", .{buffer});
        
        const end = std.time.microTimestamp();
        std.debug.print("耗时: {d} 微秒\n", .{end - start});
    }
};

额外优化说明 #

• 测试代码添加defer语句，自动释放内存、关闭文件，避免资源泄漏
• 仅分配44字节缓冲区存储文件头，无需申请超大内存
• 补充了原代码调用但未定义的PrintHeader方法

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