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
21#include "webrtc/common_audio/include/audio_util.h"
22
23namespace webrtc {
24
25struct ChunkHeader {
26  uint32_t ID;
27  uint32_t Size;
28};
29COMPILE_ASSERT(sizeof(ChunkHeader) == 8, chunk_header_size);
30
31bool CheckWavParameters(int num_channels,
32                        int sample_rate,
33                        WavFormat format,
34                        int bytes_per_sample,
35                        uint32_t num_samples) {
36  // num_channels, sample_rate, and bytes_per_sample must be positive, must fit
37  // in their respective fields, and their product must fit in the 32-bit
38  // ByteRate field.
39  if (num_channels <= 0 || sample_rate <= 0 || bytes_per_sample <= 0)
40    return false;
41  if (static_cast<uint64_t>(sample_rate) > std::numeric_limits<uint32_t>::max())
42    return false;
43  if (static_cast<uint64_t>(num_channels) >
44      std::numeric_limits<uint16_t>::max())
45    return false;
46  if (static_cast<uint64_t>(bytes_per_sample) * 8 >
47      std::numeric_limits<uint16_t>::max())
48    return false;
49  if (static_cast<uint64_t>(sample_rate) * num_channels * bytes_per_sample >
50      std::numeric_limits<uint32_t>::max())
51    return false;
52
53  // format and bytes_per_sample must agree.
54  switch (format) {
55    case kWavFormatPcm:
56      // Other values may be OK, but for now we're conservative:
57      if (bytes_per_sample != 1 && bytes_per_sample != 2)
58        return false;
59      break;
60    case kWavFormatALaw:
61    case kWavFormatMuLaw:
62      if (bytes_per_sample != 1)
63        return false;
64      break;
65    default:
66      return false;
67  }
68
69  // The number of bytes in the file, not counting the first ChunkHeader, must
70  // be less than 2^32; otherwise, the ChunkSize field overflows.
71  const uint32_t max_samples =
72      (std::numeric_limits<uint32_t>::max()
73       - (kWavHeaderSize - sizeof(ChunkHeader))) /
74      bytes_per_sample;
75  if (num_samples > max_samples)
76    return false;
77
78  // Each channel must have the same number of samples.
79  if (num_samples % num_channels != 0)
80    return false;
81
82  return true;
83}
84
85#ifdef WEBRTC_ARCH_LITTLE_ENDIAN
86static inline void WriteLE16(uint16_t* f, uint16_t x) { *f = x; }
87static inline void WriteLE32(uint32_t* f, uint32_t x) { *f = x; }
88static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
89  *f = static_cast<uint32_t>(a)
90      | static_cast<uint32_t>(b) << 8
91      | static_cast<uint32_t>(c) << 16
92      | static_cast<uint32_t>(d) << 24;
93}
94#else
95#error "Write be-to-le conversion functions"
96#endif
97
98void WriteWavHeader(uint8_t* buf,
99                    int num_channels,
100                    int sample_rate,
101                    WavFormat format,
102                    int bytes_per_sample,
103                    uint32_t num_samples) {
104  assert(CheckWavParameters(num_channels, sample_rate, format,
105                            bytes_per_sample, num_samples));
106
107  struct {
108    struct {
109      ChunkHeader header;
110      uint32_t Format;
111    } riff;
112    struct {
113      ChunkHeader header;
114      uint16_t AudioFormat;
115      uint16_t NumChannels;
116      uint32_t SampleRate;
117      uint32_t ByteRate;
118      uint16_t BlockAlign;
119      uint16_t BitsPerSample;
120    } fmt;
121    struct {
122      ChunkHeader header;
123    } data;
124  } header;
125  COMPILE_ASSERT(sizeof(header) == kWavHeaderSize, no_padding_in_header);
126
127  const uint32_t bytes_in_payload = bytes_per_sample * num_samples;
128
129  WriteFourCC(&header.riff.header.ID, 'R', 'I', 'F', 'F');
130  WriteLE32(&header.riff.header.Size,
131            bytes_in_payload + kWavHeaderSize - sizeof(ChunkHeader));
132  WriteFourCC(&header.riff.Format, 'W', 'A', 'V', 'E');
133
134  WriteFourCC(&header.fmt.header.ID, 'f', 'm', 't', ' ');
135  WriteLE32(&header.fmt.header.Size, sizeof(header.fmt) - sizeof(ChunkHeader));
136  WriteLE16(&header.fmt.AudioFormat, format);
137  WriteLE16(&header.fmt.NumChannels, num_channels);
138  WriteLE32(&header.fmt.SampleRate, sample_rate);
139  WriteLE32(&header.fmt.ByteRate, (static_cast<uint32_t>(num_channels)
140                                   * sample_rate * bytes_per_sample));
141  WriteLE16(&header.fmt.BlockAlign, num_channels * bytes_per_sample);
142  WriteLE16(&header.fmt.BitsPerSample, 8 * bytes_per_sample);
143
144  WriteFourCC(&header.data.header.ID, 'd', 'a', 't', 'a');
145  WriteLE32(&header.data.header.Size, bytes_in_payload);
146
147  // Do an extra copy rather than writing everything to buf directly, since buf
148  // might not be correctly aligned.
149  memcpy(buf, &header, kWavHeaderSize);
150}
151
152}  // namespace webrtc
153