244 lines
8.3 KiB
C++
244 lines
8.3 KiB
C++
/*
|
|
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
// Based on the WAV file format documentation at
|
|
// https://ccrma.stanford.edu/courses/422/projects/WaveFormat/ and
|
|
// http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
|
|
|
|
#include "webrtc/common_audio/wav_header.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstring>
|
|
#include <limits>
|
|
#include <string>
|
|
|
|
#include "webrtc/base/checks.h"
|
|
#include "webrtc/common_audio/include/audio_util.h"
|
|
|
|
namespace webrtc {
|
|
namespace {
|
|
|
|
struct ChunkHeader {
|
|
uint32_t ID;
|
|
uint32_t Size;
|
|
};
|
|
static_assert(sizeof(ChunkHeader) == 8, "ChunkHeader size");
|
|
|
|
// We can't nest this definition in WavHeader, because VS2013 gives an error
|
|
// on sizeof(WavHeader::fmt): "error C2070: 'unknown': illegal sizeof operand".
|
|
struct FmtSubchunk {
|
|
ChunkHeader header;
|
|
uint16_t AudioFormat;
|
|
uint16_t NumChannels;
|
|
uint32_t SampleRate;
|
|
uint32_t ByteRate;
|
|
uint16_t BlockAlign;
|
|
uint16_t BitsPerSample;
|
|
};
|
|
static_assert(sizeof(FmtSubchunk) == 24, "FmtSubchunk size");
|
|
const uint32_t kFmtSubchunkSize = sizeof(FmtSubchunk) - sizeof(ChunkHeader);
|
|
|
|
struct WavHeader {
|
|
struct {
|
|
ChunkHeader header;
|
|
uint32_t Format;
|
|
} riff;
|
|
FmtSubchunk fmt;
|
|
struct {
|
|
ChunkHeader header;
|
|
} data;
|
|
};
|
|
static_assert(sizeof(WavHeader) == kWavHeaderSize, "no padding in header");
|
|
|
|
} // namespace
|
|
|
|
bool CheckWavParameters(size_t num_channels,
|
|
int sample_rate,
|
|
WavFormat format,
|
|
size_t bytes_per_sample,
|
|
size_t num_samples) {
|
|
// num_channels, sample_rate, and bytes_per_sample must be positive, must fit
|
|
// in their respective fields, and their product must fit in the 32-bit
|
|
// ByteRate field.
|
|
if (num_channels == 0 || sample_rate <= 0 || bytes_per_sample == 0)
|
|
return false;
|
|
if (static_cast<uint64_t>(sample_rate) > std::numeric_limits<uint32_t>::max())
|
|
return false;
|
|
if (num_channels > std::numeric_limits<uint16_t>::max())
|
|
return false;
|
|
if (static_cast<uint64_t>(bytes_per_sample) * 8 >
|
|
std::numeric_limits<uint16_t>::max())
|
|
return false;
|
|
if (static_cast<uint64_t>(sample_rate) * num_channels * bytes_per_sample >
|
|
std::numeric_limits<uint32_t>::max())
|
|
return false;
|
|
|
|
// format and bytes_per_sample must agree.
|
|
switch (format) {
|
|
case kWavFormatPcm:
|
|
// Other values may be OK, but for now we're conservative:
|
|
if (bytes_per_sample != 1 && bytes_per_sample != 2)
|
|
return false;
|
|
break;
|
|
case kWavFormatALaw:
|
|
case kWavFormatMuLaw:
|
|
if (bytes_per_sample != 1)
|
|
return false;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
// The number of bytes in the file, not counting the first ChunkHeader, must
|
|
// be less than 2^32; otherwise, the ChunkSize field overflows.
|
|
const size_t header_size = kWavHeaderSize - sizeof(ChunkHeader);
|
|
const size_t max_samples =
|
|
(std::numeric_limits<uint32_t>::max() - header_size) / bytes_per_sample;
|
|
if (num_samples > max_samples)
|
|
return false;
|
|
|
|
// Each channel must have the same number of samples.
|
|
if (num_samples % num_channels != 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
#ifdef WEBRTC_ARCH_LITTLE_ENDIAN
|
|
static inline void WriteLE16(uint16_t* f, uint16_t x) { *f = x; }
|
|
static inline void WriteLE32(uint32_t* f, uint32_t x) { *f = x; }
|
|
static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
|
|
*f = static_cast<uint32_t>(a)
|
|
| static_cast<uint32_t>(b) << 8
|
|
| static_cast<uint32_t>(c) << 16
|
|
| static_cast<uint32_t>(d) << 24;
|
|
}
|
|
|
|
static inline uint16_t ReadLE16(uint16_t x) { return x; }
|
|
static inline uint32_t ReadLE32(uint32_t x) { return x; }
|
|
static inline std::string ReadFourCC(uint32_t x) {
|
|
return std::string(reinterpret_cast<char*>(&x), 4);
|
|
}
|
|
#else
|
|
#error "Write be-to-le conversion functions"
|
|
#endif
|
|
|
|
static inline uint32_t RiffChunkSize(size_t bytes_in_payload) {
|
|
return static_cast<uint32_t>(
|
|
bytes_in_payload + kWavHeaderSize - sizeof(ChunkHeader));
|
|
}
|
|
|
|
static inline uint32_t ByteRate(size_t num_channels, int sample_rate,
|
|
size_t bytes_per_sample) {
|
|
return static_cast<uint32_t>(num_channels * sample_rate * bytes_per_sample);
|
|
}
|
|
|
|
static inline uint16_t BlockAlign(size_t num_channels,
|
|
size_t bytes_per_sample) {
|
|
return static_cast<uint16_t>(num_channels * bytes_per_sample);
|
|
}
|
|
|
|
void WriteWavHeader(uint8_t* buf,
|
|
size_t num_channels,
|
|
int sample_rate,
|
|
WavFormat format,
|
|
size_t bytes_per_sample,
|
|
size_t num_samples) {
|
|
RTC_CHECK(CheckWavParameters(num_channels, sample_rate, format,
|
|
bytes_per_sample, num_samples));
|
|
|
|
WavHeader header;
|
|
const size_t bytes_in_payload = bytes_per_sample * num_samples;
|
|
|
|
WriteFourCC(&header.riff.header.ID, 'R', 'I', 'F', 'F');
|
|
WriteLE32(&header.riff.header.Size, RiffChunkSize(bytes_in_payload));
|
|
WriteFourCC(&header.riff.Format, 'W', 'A', 'V', 'E');
|
|
|
|
WriteFourCC(&header.fmt.header.ID, 'f', 'm', 't', ' ');
|
|
WriteLE32(&header.fmt.header.Size, kFmtSubchunkSize);
|
|
WriteLE16(&header.fmt.AudioFormat, format);
|
|
WriteLE16(&header.fmt.NumChannels, static_cast<uint16_t>(num_channels));
|
|
WriteLE32(&header.fmt.SampleRate, sample_rate);
|
|
WriteLE32(&header.fmt.ByteRate, ByteRate(num_channels, sample_rate,
|
|
bytes_per_sample));
|
|
WriteLE16(&header.fmt.BlockAlign, BlockAlign(num_channels, bytes_per_sample));
|
|
WriteLE16(&header.fmt.BitsPerSample,
|
|
static_cast<uint16_t>(8 * bytes_per_sample));
|
|
|
|
WriteFourCC(&header.data.header.ID, 'd', 'a', 't', 'a');
|
|
WriteLE32(&header.data.header.Size, static_cast<uint32_t>(bytes_in_payload));
|
|
|
|
// Do an extra copy rather than writing everything to buf directly, since buf
|
|
// might not be correctly aligned.
|
|
memcpy(buf, &header, kWavHeaderSize);
|
|
}
|
|
|
|
bool ReadWavHeader(ReadableWav* readable,
|
|
size_t* num_channels,
|
|
int* sample_rate,
|
|
WavFormat* format,
|
|
size_t* bytes_per_sample,
|
|
size_t* num_samples) {
|
|
WavHeader header;
|
|
if (readable->Read(&header, kWavHeaderSize - sizeof(header.data)) !=
|
|
kWavHeaderSize - sizeof(header.data))
|
|
return false;
|
|
|
|
const uint32_t fmt_size = ReadLE32(header.fmt.header.Size);
|
|
if (fmt_size != kFmtSubchunkSize) {
|
|
// There is an optional two-byte extension field permitted to be present
|
|
// with PCM, but which must be zero.
|
|
int16_t ext_size;
|
|
if (kFmtSubchunkSize + sizeof(ext_size) != fmt_size)
|
|
return false;
|
|
if (readable->Read(&ext_size, sizeof(ext_size)) != sizeof(ext_size))
|
|
return false;
|
|
if (ext_size != 0)
|
|
return false;
|
|
}
|
|
if (readable->Read(&header.data, sizeof(header.data)) != sizeof(header.data))
|
|
return false;
|
|
|
|
// Parse needed fields.
|
|
*format = static_cast<WavFormat>(ReadLE16(header.fmt.AudioFormat));
|
|
*num_channels = ReadLE16(header.fmt.NumChannels);
|
|
*sample_rate = ReadLE32(header.fmt.SampleRate);
|
|
*bytes_per_sample = ReadLE16(header.fmt.BitsPerSample) / 8;
|
|
const size_t bytes_in_payload = ReadLE32(header.data.header.Size);
|
|
if (*bytes_per_sample == 0)
|
|
return false;
|
|
*num_samples = bytes_in_payload / *bytes_per_sample;
|
|
|
|
// Sanity check remaining fields.
|
|
if (ReadFourCC(header.riff.header.ID) != "RIFF")
|
|
return false;
|
|
if (ReadFourCC(header.riff.Format) != "WAVE")
|
|
return false;
|
|
if (ReadFourCC(header.fmt.header.ID) != "fmt ")
|
|
return false;
|
|
if (ReadFourCC(header.data.header.ID) != "data")
|
|
return false;
|
|
|
|
if (ReadLE32(header.riff.header.Size) < RiffChunkSize(bytes_in_payload))
|
|
return false;
|
|
if (ReadLE32(header.fmt.ByteRate) !=
|
|
ByteRate(*num_channels, *sample_rate, *bytes_per_sample))
|
|
return false;
|
|
if (ReadLE16(header.fmt.BlockAlign) !=
|
|
BlockAlign(*num_channels, *bytes_per_sample))
|
|
return false;
|
|
|
|
return CheckWavParameters(*num_channels, *sample_rate, *format,
|
|
*bytes_per_sample, *num_samples);
|
|
}
|
|
|
|
|
|
} // namespace webrtc
|