common_audio/wav_header.cc - src.git - Git at Google

 /*
  *  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 "common_audio/wav_header.h"

 #include <algorithm>
 #include <cstring>
 #include <limits>
 #include <string>

 #include "common_audio/include/audio_util.h"
 #include "rtc_base/checks.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
	/*
	* 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 "common_audio/wav_header.h"

	#include <algorithm>
	#include <cstring>
	#include <limits>
	#include <string>

	#include "common_audio/include/audio_util.h"
	#include "rtc_base/checks.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