go - 使用 go lang 获取 caf 音频文件的持续时间

Question

我想使用 go 获取 .caf 音频文件的持续时间。我发现了一些解码器，但他们的 Duration() 方法只返回 0 并带有可能建议计算持续时间的方法的评论，有没有人知道这些评论是否合法，如果是，我如何计算持续时间？如果没有简单的解决方案，我会接受“不可能”作为答案。

func (d *Decoder) Duration() time.Duration {
    //duration := time.Duration((float64(p.Size) / float64(p.AvgBytesPerSec)) * float64(time.Second))
    //duration := time.Duration(float64(p.NumSampleFrames) / float64(p.SampleRate) * float64(time.Second))

    return 0
}

一个实现示例，尽管我很乐意使用任何易于安装的实现：https ://github.com/mattetti/audio/blob/master/caf/decoder.go

标签： goaudiocaf

Answer 1

您链接的该文件中的文档注释直接取自 Apple 的规范。在这些文档中，您会发现这两件重要的事情：

“文件中音频的持续时间是 [有效帧数] 除以文件的音频描述块中指定的采样率。”

好的，很酷，但是有多少有效帧？有两种可能的了解方式：

• 如果 CAF 有一个数据包表，它必须包括有效帧的数量。完美的。
• 唯一允许没有数据包表的 CAF 是那些具有恒定数据包大小的 CAF：

“请注意，只要格式具有每个数据包的恒定帧数，您可以通过将 mSampleRate [每秒帧数] 值除以 mFramesPerPacket 值来计算每个数据包的持续时间。”

这告诉您每个数据包的持续时间，但是由于数据包的大小是恒定的，因此数据包的数量只是audioDataSize / bytesPerPacket. 后一个值包含在音频描述中。前者通常直接嵌入到文件中，但允许将-1音频数据作为最后一个块，在这种情况下，它的大小为totalFileSize - startOfAudioData

它像这样分解：

• 如果有数据包表块，请使用它和音频描述：seconds = validFrames / sampleRate
• 否则，数据包必须具有恒定大小：
  • framesPerByte = framesPerPacket / bytesPerPacket
  • seconds = framesPerByte * audioDataSize

您拥有的库读取音频描述块，但我认为它不会读取数据包表。另外，如果块为-1，我不确定它会计算音频数据大小。也许两者兼有，在这种情况下，您可以使用上面的信息。

如果没有，您可以自己解析文件，特别是如果您只关心持续时间。该文件以一个短标题开始，然后被分成“块”（又名 TLV）。这是一个示例实现，您可以将其用作起点或修改您链接的库：

---

func readCAF() { 
    buf := []byte{
        // file header
        'c', 'a', 'f', 'f', // file type
        0x0, 0x1, 0x0, 0x0, // file version, flags

        // audio description
        'd', 'e', 's', 'c', // chunk type
        0x0, 0x0, 0x0, 0x0,
        0x0, 0x0, 0x0, 0x20, // CAFAudioFormat size

        0x40, 0xe5, 0x88, 0x80,
        0x00, 0x00, 0x00, 0x00, // sample rate
        'l', 'p', 'c', 'm', // fmt id
        0x0, 0x0, 0x0, 0x0, // fmt flags
        0x0, 0x0, 0x0, 0x1, // bytes per packet
        0x0, 0x0, 0x0, 0x1, // frames per packet
        0x0, 0x0, 0x0, 0x2, // channels per frame
        0x0, 0x0, 0x0, 0x3, // bits per channel

        // audio data
        'd', 'a', 't', 'a', // chunk type
        0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff, // size of data section (-1 = til EOF)

        // actual audio packets (in theory, anyway)
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
        0x0,
    }

    fileSize := len(buf)
    br := bufio.NewReader(bytes.NewBuffer(buf))

    type cafHdr struct {
        Typ     [4]byte
        Version uint16
        _       uint16
    }

    type chunkHdr struct {
        Typ [4]byte
        Sz  int64
    }

    type audioDescription struct {
        FramesPerSec     float64
        FmtId            uint32
        FmtFlags         uint32
        BytesPerPacket   uint32
        FramesPerPacket  uint32
        ChannelsPerFrame uint32
        BitsPerChannel   uint32
    }

    type packetTable struct {
        NPackets, NValidFrames, NPrimingFr, NRemainingFr int64
    }

    const FileHeaderSz = 8
    const ChunkHeaderSz = 12
    const AudioDescSz = 32
    const PacketHdrSz = 24

    fileHdr := cafHdr{}
    if err := binary.Read(br, binary.BigEndian, &fileHdr); err != nil {
        panic(err)
    }
    if fileHdr.Typ != [4]byte{'c', 'a', 'f', 'f'} || fileHdr.Version != 1 {
        panic("unknown file format")
    }
    remaining := int64(fileSize) - FileHeaderSz

    audioDesc := audioDescription{}
    packetTab := packetTable{}
    var audioDataSz int64

readChunks:
    for {
        hdr := chunkHdr{}
        if err := binary.Read(br, binary.BigEndian, &hdr); err != nil {
            panic(err)
        }
        remaining -= ChunkHeaderSz

        switch hdr.Typ {
        case [4]byte{'d', 'e', 's', 'c'}: // audio description
            if err := binary.Read(br, binary.BigEndian, &audioDesc); err != nil {
                panic(err)
            }
            hdr.Sz -= AudioDescSz
            remaining -= AudioDescSz

        case [4]byte{'p', 'a', 'k', 't'}: // packet table
            if err := binary.Read(br, binary.BigEndian, &packetTab); err != nil {
                panic(err)
            }
            hdr.Sz -= PacketHdrSz
            remaining -= PacketHdrSz

        case [4]byte{'d', 'a', 't', 'a'}: // audio data
            if hdr.Sz > 0 {
                audioDataSz = hdr.Sz
            } else if hdr.Sz == -1 {
                // if needed, read to EOF to determine byte size
                audioDataSz = remaining
                break readChunks
            }
        }

        if hdr.Sz < 0 {
            panic("invalid header size")
        }
        remaining -= hdr.Sz

        // Skip to the next chunk. On 32 bit machines, Sz can overflow,
        // so you should check for that (or use Seek if you're reading a file).
        if n, err := br.Discard(int(hdr.Sz)); err != nil {
            if err == io.EOF && int64(n) == hdr.Sz {
                break
            }
            panic(err)
        }
    }

    var seconds float64

    // If the data included a packet table, the frames determines duration.
    if packetTab.NValidFrames > 0 {
        seconds = float64(packetTab.NValidFrames) / audioDesc.FramesPerSec
    } else {
        // If there no packet table, it must have a constant packet size.
        if audioDesc.BytesPerPacket == 0 || audioDesc.FramesPerPacket == 0 {
            panic("bad data")
        }
        framesPerByte := float64(audioDesc.FramesPerPacket) / float64(audioDesc.BytesPerPacket)
        seconds = framesPerByte * float64(audioDataSz)
    }

    fmt.Printf("seconds: %f\n", seconds)
}