Home | History | Annotate | Download | only in common_audio 
      1 /*
      2  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 // Based on the WAV file format documentation at
     12 // https://ccrma.stanford.edu/courses/422/projects/WaveFormat/ and
     13 // http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
     14 
     15 #include "webrtc/common_audio/wav_header.h"
     16 
     17 #include <algorithm>
     18 #include <cstring>
     19 #include <limits>
     20 #include <string>
     21 
     22 #include "webrtc/base/checks.h"
     23 #include "webrtc/common_audio/include/audio_util.h"
     24 
     25 namespace webrtc {
     26 namespace {
     27 
     28 struct ChunkHeader {
     29   uint32_t ID;
     30   uint32_t Size;
     31 };
     32 static_assert(sizeof(ChunkHeader) == 8, "ChunkHeader size");
     33 
     34 // We can't nest this definition in WavHeader, because VS2013 gives an error
     35 // on sizeof(WavHeader::fmt): "error C2070: 'unknown': illegal sizeof operand".
     36 struct FmtSubchunk {
     37   ChunkHeader header;
     38   uint16_t AudioFormat;
     39   uint16_t NumChannels;
     40   uint32_t SampleRate;
     41   uint32_t ByteRate;
     42   uint16_t BlockAlign;
     43   uint16_t BitsPerSample;
     44 };
     45 static_assert(sizeof(FmtSubchunk) == 24, "FmtSubchunk size");
     46 const uint32_t kFmtSubchunkSize = sizeof(FmtSubchunk) - sizeof(ChunkHeader);
     47 
     48 struct WavHeader {
     49   struct {
     50     ChunkHeader header;
     51     uint32_t Format;
     52   } riff;
     53   FmtSubchunk fmt;
     54   struct {
     55     ChunkHeader header;
     56   } data;
     57 };
     58 static_assert(sizeof(WavHeader) == kWavHeaderSize, "no padding in header");
     59 
     60 }  // namespace
     61 
     62 bool CheckWavParameters(size_t num_channels,
     63                         int sample_rate,
     64                         WavFormat format,
     65                         size_t bytes_per_sample,
     66                         size_t num_samples) {
     67   // num_channels, sample_rate, and bytes_per_sample must be positive, must fit
     68   // in their respective fields, and their product must fit in the 32-bit
     69   // ByteRate field.
     70   if (num_channels == 0 || sample_rate <= 0 || bytes_per_sample == 0)
     71     return false;
     72   if (static_cast<uint64_t>(sample_rate) > std::numeric_limits<uint32_t>::max())
     73     return false;
     74   if (num_channels > std::numeric_limits<uint16_t>::max())
     75     return false;
     76   if (static_cast<uint64_t>(bytes_per_sample) * 8 >
     77       std::numeric_limits<uint16_t>::max())
     78     return false;
     79   if (static_cast<uint64_t>(sample_rate) * num_channels * bytes_per_sample >
     80       std::numeric_limits<uint32_t>::max())
     81     return false;
     82 
     83   // format and bytes_per_sample must agree.
     84   switch (format) {
     85     case kWavFormatPcm:
     86       // Other values may be OK, but for now we're conservative:
     87       if (bytes_per_sample != 1 && bytes_per_sample != 2)
     88         return false;
     89       break;
     90     case kWavFormatALaw:
     91     case kWavFormatMuLaw:
     92       if (bytes_per_sample != 1)
     93         return false;
     94       break;
     95     default:
     96       return false;
     97   }
     98 
     99   // The number of bytes in the file, not counting the first ChunkHeader, must
    100   // be less than 2^32; otherwise, the ChunkSize field overflows.
    101   const size_t header_size = kWavHeaderSize - sizeof(ChunkHeader);
    102   const size_t max_samples =
    103       (std::numeric_limits<uint32_t>::max() - header_size) / bytes_per_sample;
    104   if (num_samples > max_samples)
    105     return false;
    106 
    107   // Each channel must have the same number of samples.
    108   if (num_samples % num_channels != 0)
    109     return false;
    110 
    111   return true;
    112 }
    113 
    114 #ifdef WEBRTC_ARCH_LITTLE_ENDIAN
    115 static inline void WriteLE16(uint16_t* f, uint16_t x) { *f = x; }
    116 static inline void WriteLE32(uint32_t* f, uint32_t x) { *f = x; }
    117 static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
    118   *f = static_cast<uint32_t>(a)
    119       | static_cast<uint32_t>(b) << 8
    120       | static_cast<uint32_t>(c) << 16
    121       | static_cast<uint32_t>(d) << 24;
    122 }
    123 
    124 static inline uint16_t ReadLE16(uint16_t x) { return x; }
    125 static inline uint32_t ReadLE32(uint32_t x) { return x; }
    126 static inline std::string ReadFourCC(uint32_t x) {
    127   return std::string(reinterpret_cast<char*>(&x), 4);
    128 }
    129 #else
    130 #error "Write be-to-le conversion functions"
    131 #endif
    132 
    133 static inline uint32_t RiffChunkSize(size_t bytes_in_payload) {
    134   return static_cast<uint32_t>(
    135       bytes_in_payload + kWavHeaderSize - sizeof(ChunkHeader));
    136 }
    137 
    138 static inline uint32_t ByteRate(size_t num_channels, int sample_rate,
    139                                 size_t bytes_per_sample) {
    140   return static_cast<uint32_t>(num_channels * sample_rate * bytes_per_sample);
    141 }
    142 
    143 static inline uint16_t BlockAlign(size_t num_channels,
    144                                   size_t bytes_per_sample) {
    145   return static_cast<uint16_t>(num_channels * bytes_per_sample);
    146 }
    147 
    148 void WriteWavHeader(uint8_t* buf,
    149                     size_t num_channels,
    150                     int sample_rate,
    151                     WavFormat format,
    152                     size_t bytes_per_sample,
    153                     size_t num_samples) {
    154   RTC_CHECK(CheckWavParameters(num_channels, sample_rate, format,
    155                                bytes_per_sample, num_samples));
    156 
    157   WavHeader header;
    158   const size_t bytes_in_payload = bytes_per_sample * num_samples;
    159 
    160   WriteFourCC(&header.riff.header.ID, 'R', 'I', 'F', 'F');
    161   WriteLE32(&header.riff.header.Size, RiffChunkSize(bytes_in_payload));
    162   WriteFourCC(&header.riff.Format, 'W', 'A', 'V', 'E');
    163 
    164   WriteFourCC(&header.fmt.header.ID, 'f', 'm', 't', ' ');
    165   WriteLE32(&header.fmt.header.Size, kFmtSubchunkSize);
    166   WriteLE16(&header.fmt.AudioFormat, format);
    167   WriteLE16(&header.fmt.NumChannels, static_cast<uint16_t>(num_channels));
    168   WriteLE32(&header.fmt.SampleRate, sample_rate);
    169   WriteLE32(&header.fmt.ByteRate, ByteRate(num_channels, sample_rate,
    170                                            bytes_per_sample));
    171   WriteLE16(&header.fmt.BlockAlign, BlockAlign(num_channels, bytes_per_sample));
    172   WriteLE16(&header.fmt.BitsPerSample,
    173             static_cast<uint16_t>(8 * bytes_per_sample));
    174 
    175   WriteFourCC(&header.data.header.ID, 'd', 'a', 't', 'a');
    176   WriteLE32(&header.data.header.Size, static_cast<uint32_t>(bytes_in_payload));
    177 
    178   // Do an extra copy rather than writing everything to buf directly, since buf
    179   // might not be correctly aligned.
    180   memcpy(buf, &header, kWavHeaderSize);
    181 }
    182 
    183 bool ReadWavHeader(ReadableWav* readable,
    184                    size_t* num_channels,
    185                    int* sample_rate,
    186                    WavFormat* format,
    187                    size_t* bytes_per_sample,
    188                    size_t* num_samples) {
    189   WavHeader header;
    190   if (readable->Read(&header, kWavHeaderSize - sizeof(header.data)) !=
    191       kWavHeaderSize - sizeof(header.data))
    192     return false;
    193 
    194   const uint32_t fmt_size = ReadLE32(header.fmt.header.Size);
    195   if (fmt_size != kFmtSubchunkSize) {
    196     // There is an optional two-byte extension field permitted to be present
    197     // with PCM, but which must be zero.
    198     int16_t ext_size;
    199     if (kFmtSubchunkSize + sizeof(ext_size) != fmt_size)
    200       return false;
    201     if (readable->Read(&ext_size, sizeof(ext_size)) != sizeof(ext_size))
    202       return false;
    203     if (ext_size != 0)
    204       return false;
    205   }
    206   if (readable->Read(&header.data, sizeof(header.data)) != sizeof(header.data))
    207     return false;
    208 
    209   // Parse needed fields.
    210   *format = static_cast<WavFormat>(ReadLE16(header.fmt.AudioFormat));
    211   *num_channels = ReadLE16(header.fmt.NumChannels);
    212   *sample_rate = ReadLE32(header.fmt.SampleRate);
    213   *bytes_per_sample = ReadLE16(header.fmt.BitsPerSample) / 8;
    214   const size_t bytes_in_payload = ReadLE32(header.data.header.Size);
    215   if (*bytes_per_sample == 0)
    216     return false;
    217   *num_samples = bytes_in_payload / *bytes_per_sample;
    218 
    219   // Sanity check remaining fields.
    220   if (ReadFourCC(header.riff.header.ID) != "RIFF")
    221     return false;
    222   if (ReadFourCC(header.riff.Format) != "WAVE")
    223     return false;
    224   if (ReadFourCC(header.fmt.header.ID) != "fmt ")
    225     return false;
    226   if (ReadFourCC(header.data.header.ID) != "data")
    227     return false;
    228 
    229   if (ReadLE32(header.riff.header.Size) < RiffChunkSize(bytes_in_payload))
    230     return false;
    231   if (ReadLE32(header.fmt.ByteRate) !=
    232       ByteRate(*num_channels, *sample_rate, *bytes_per_sample))
    233     return false;
    234   if (ReadLE16(header.fmt.BlockAlign) !=
    235       BlockAlign(*num_channels, *bytes_per_sample))
    236     return false;
    237 
    238   return CheckWavParameters(*num_channels, *sample_rate, *format,
    239                             *bytes_per_sample, *num_samples);
    240 }
    241 
    242 
    243 }  // namespace webrtc
    244