2 Copyright (C) 2012 Carl Hetherington <cth@carlh.net>
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 /** @file src/sound_asset.cc
21 * @brief An asset made up of WAV files
26 #include <boost/filesystem.hpp>
27 #include <boost/lexical_cast.hpp>
28 #include "KM_fileio.h"
30 #include "sound_asset.h"
32 #include "exceptions.h"
33 #include "sound_frame.h"
36 using namespace boost;
37 using namespace libdcp;
39 SoundAsset::SoundAsset (
40 vector<string> const & files, string directory, string mxf_name, sigc::signal1<void, float>* progress, int fps, int length
42 : MXFAsset (directory, mxf_name, progress, fps, 0, length)
43 , _channels (files.size ())
46 construct (sigc::bind (sigc::mem_fun (*this, &SoundAsset::path_from_channel), files));
49 SoundAsset::SoundAsset (
50 sigc::slot<string, Channel> get_path, string directory, string mxf_name, sigc::signal1<void, float>* progress, int fps, int length, int channels
52 : MXFAsset (directory, mxf_name, progress, fps, 0, length)
53 , _channels (channels)
59 SoundAsset::SoundAsset (string directory, string mxf_name, int fps, int entry_point, int length)
60 : MXFAsset (directory, mxf_name, 0, fps, entry_point, length)
63 ASDCP::PCM::MXFReader reader;
64 if (ASDCP_FAILURE (reader.OpenRead (path().string().c_str()))) {
65 throw MXFFileError ("could not open MXF file for reading", path().string());
69 ASDCP::PCM::AudioDescriptor desc;
70 if (ASDCP_FAILURE (reader.FillAudioDescriptor (desc))) {
71 throw DCPReadError ("could not read audio MXF information");
74 _sampling_rate = desc.AudioSamplingRate.Numerator / desc.AudioSamplingRate.Denominator;
75 _channels = desc.ChannelCount;
79 SoundAsset::path_from_channel (Channel channel, vector<string> const & files)
81 unsigned int const c = int (channel);
82 assert (c < files.size ());
87 SoundAsset::construct (sigc::slot<string, Channel> get_path)
89 ASDCP::Rational asdcp_fps (_fps, 1);
91 ASDCP::PCM::WAVParser pcm_parser_channel[_channels];
92 if (pcm_parser_channel[0].OpenRead (get_path(LEFT).c_str(), asdcp_fps)) {
93 throw FileError ("could not open WAV file for reading", get_path(LEFT));
96 ASDCP::PCM::AudioDescriptor audio_desc;
97 pcm_parser_channel[0].FillAudioDescriptor (audio_desc);
98 audio_desc.ChannelCount = 0;
99 audio_desc.BlockAlign = 0;
100 audio_desc.EditRate = asdcp_fps;
101 audio_desc.AvgBps = audio_desc.AvgBps * _channels;
103 Channel channels[] = {
112 ASDCP::PCM::FrameBuffer frame_buffer_channel[_channels];
113 ASDCP::PCM::AudioDescriptor audio_desc_channel[_channels];
115 for (int i = 0; i < _channels; ++i) {
117 string const path = get_path (channels[i]);
119 if (ASDCP_FAILURE (pcm_parser_channel[i].OpenRead (path.c_str(), asdcp_fps))) {
120 throw FileError ("could not open WAV file for reading", path);
123 pcm_parser_channel[i].FillAudioDescriptor (audio_desc_channel[i]);
124 frame_buffer_channel[i].Capacity (ASDCP::PCM::CalcFrameBufferSize (audio_desc_channel[i]));
126 audio_desc.ChannelCount += audio_desc_channel[i].ChannelCount;
127 audio_desc.BlockAlign += audio_desc_channel[i].BlockAlign;
130 ASDCP::PCM::FrameBuffer frame_buffer;
131 frame_buffer.Capacity (ASDCP::PCM::CalcFrameBufferSize (audio_desc));
132 frame_buffer.Size (ASDCP::PCM::CalcFrameBufferSize (audio_desc));
134 ASDCP::WriterInfo writer_info;
135 fill_writer_info (&writer_info);
137 ASDCP::PCM::MXFWriter mxf_writer;
138 if (ASDCP_FAILURE (mxf_writer.OpenWrite (path().string().c_str(), writer_info, audio_desc))) {
139 throw FileError ("could not open audio MXF for writing", path().string());
142 for (int i = 0; i < _length; ++i) {
144 byte_t *data_s = frame_buffer.Data();
145 byte_t *data_e = data_s + frame_buffer.Capacity();
146 byte_t sample_size = ASDCP::PCM::CalcSampleSize (audio_desc_channel[0]);
149 for (int j = 0; j < _channels; ++j) {
150 memset (frame_buffer_channel[j].Data(), 0, frame_buffer_channel[j].Capacity());
151 if (ASDCP_FAILURE (pcm_parser_channel[j].ReadFrame (frame_buffer_channel[j]))) {
152 throw MiscError ("could not read audio frame");
155 if (frame_buffer_channel[j].Size() != frame_buffer_channel[j].Capacity()) {
157 s << "short audio frame; " << _channels << " channels, "
158 << frame_buffer_channel[j].Size() << " vs " << frame_buffer_channel[j].Capacity();
159 throw MiscError (s.str ());
163 while (data_s < data_e) {
164 for (int j = 0; j < _channels; ++j) {
165 byte_t* frame = frame_buffer_channel[j].Data() + offset;
166 memcpy (data_s, frame, sample_size);
167 data_s += sample_size;
169 offset += sample_size;
172 if (ASDCP_FAILURE (mxf_writer.WriteFrame (frame_buffer, 0, 0))) {
173 throw MiscError ("could not write audio MXF frame");
177 (*_progress) (0.5 * float (i) / _length);
181 if (ASDCP_FAILURE (mxf_writer.Finalize())) {
182 throw MiscError ("could not finalise audio MXF");
187 SoundAsset::write_to_cpl (ostream& s) const
189 s << " <MainSound>\n"
190 << " <Id>urn:uuid:" << _uuid << "</Id>\n"
191 << " <AnnotationText>" << _file_name << "</AnnotationText>\n"
192 << " <EditRate>" << _fps << " 1</EditRate>\n"
193 << " <IntrinsicDuration>" << _length << "</IntrinsicDuration>\n"
194 << " <EntryPoint>0</EntryPoint>\n"
195 << " <Duration>" << _length << "</Duration>\n"
196 << " </MainSound>\n";
200 SoundAsset::equals (shared_ptr<const Asset> other, EqualityOptions opt, list<string>& notes) const
202 if (!MXFAsset::equals (other, opt, notes)) {
206 ASDCP::PCM::MXFReader reader_A;
207 if (ASDCP_FAILURE (reader_A.OpenRead (path().string().c_str()))) {
208 throw MXFFileError ("could not open MXF file for reading", path().string());
211 ASDCP::PCM::MXFReader reader_B;
212 if (ASDCP_FAILURE (reader_B.OpenRead (other->path().string().c_str()))) {
213 throw MXFFileError ("could not open MXF file for reading", path().string());
216 ASDCP::PCM::AudioDescriptor desc_A;
217 if (ASDCP_FAILURE (reader_A.FillAudioDescriptor (desc_A))) {
218 throw DCPReadError ("could not read audio MXF information");
220 ASDCP::PCM::AudioDescriptor desc_B;
221 if (ASDCP_FAILURE (reader_B.FillAudioDescriptor (desc_B))) {
222 throw DCPReadError ("could not read audio MXF information");
226 desc_A.EditRate != desc_B.EditRate ||
227 desc_A.AudioSamplingRate != desc_B.AudioSamplingRate ||
228 desc_A.Locked != desc_B.Locked ||
229 desc_A.ChannelCount != desc_B.ChannelCount ||
230 desc_A.QuantizationBits != desc_B.QuantizationBits ||
231 desc_A.BlockAlign != desc_B.BlockAlign ||
232 desc_A.AvgBps != desc_B.AvgBps ||
233 desc_A.LinkedTrackID != desc_B.LinkedTrackID ||
234 desc_A.ContainerDuration != desc_B.ContainerDuration
235 // desc_A.ChannelFormat != desc_B.ChannelFormat ||
238 notes.push_back ("audio MXF picture descriptors differ");
242 ASDCP::PCM::FrameBuffer buffer_A (1 * Kumu::Megabyte);
243 ASDCP::PCM::FrameBuffer buffer_B (1 * Kumu::Megabyte);
245 for (int i = 0; i < _length; ++i) {
246 if (ASDCP_FAILURE (reader_A.ReadFrame (i, buffer_A))) {
247 throw DCPReadError ("could not read audio frame");
250 if (ASDCP_FAILURE (reader_B.ReadFrame (i, buffer_B))) {
251 throw DCPReadError ("could not read audio frame");
254 if (buffer_A.Size() != buffer_B.Size()) {
255 notes.push_back ("sizes of audio data for frame " + lexical_cast<string>(i) + " differ");
259 if (memcmp (buffer_A.RoData(), buffer_B.RoData(), buffer_A.Size()) != 0) {
260 for (uint32_t i = 0; i < buffer_A.Size(); ++i) {
261 int const d = abs (buffer_A.RoData()[i] - buffer_B.RoData()[i]);
262 if (d > opt.max_audio_sample_error) {
263 notes.push_back ("PCM data difference of " + lexical_cast<string> (d));
273 shared_ptr<const SoundFrame>
274 SoundAsset::get_frame (int n) const
276 return shared_ptr<const SoundFrame> (new SoundFrame (path().string(), n + _entry_point));