src/sound_asset_writer.cc

   1 /*
   2     Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34
  35 /** @file  src/sound_asset_writer.cc
  36  *  @brief SoundAssetWriter class
  37  */
  38
  39
  40 #include "bitstream.h"
  41 #include "compose.hpp"
  42 #include "crypto_context.h"
  43 #include "dcp_assert.h"
  44 #include "exceptions.h"
  45 #include "filesystem.h"
  46 #include "sound_asset.h"
  47 #include "sound_asset_writer.h"
  48 #include "warnings.h"
  49 LIBDCP_DISABLE_WARNINGS
  50 #include <asdcp/AS_DCP.h>
  51 #include <asdcp/Metadata.h>
  52 LIBDCP_ENABLE_WARNINGS
  53 #include <iostream>
  54
  55
  56 using std::min;
  57 using std::max;
  58 using std::cout;
  59 using std::string;
  60 using std::vector;
  61 using namespace dcp;
  62
  63
  64 struct SoundAssetWriter::ASDCPState
  65 {
  66         ASDCP::PCM::MXFWriter mxf_writer;
  67         ASDCP::PCM::FrameBuffer frame_buffer;
  68         ASDCP::WriterInfo writer_info;
  69         ASDCP::PCM::AudioDescriptor desc;
  70 };
  71
  72
  73 SoundAssetWriter::SoundAssetWriter(SoundAsset* asset, boost::filesystem::path file, vector<dcp::Channel> extra_active_channels, bool sync, bool include_mca_subdescriptors)
  74         : AssetWriter (asset, file)
  75         , _state (new SoundAssetWriter::ASDCPState)
  76         , _asset (asset)
  77         , _extra_active_channels(extra_active_channels)
  78         , _sync (sync)
  79         , _include_mca_subdescriptors(include_mca_subdescriptors)
  80 {
  81         DCP_ASSERT (!_sync || _asset->channels() >= 14);
  82         DCP_ASSERT (!_sync || _asset->standard() == Standard::SMPTE);
  83
  84         /* None of these are allowed in extra_active_channels; some are implicit, and (it seems) should never have a descriptor
  85          * written for them.
  86          */
  87         vector<Channel> disallowed_extra = {
  88                 Channel::LEFT,
  89                 Channel::RIGHT,
  90                 Channel::CENTRE,
  91                 Channel::LFE,
  92                 Channel::LS,
  93                 Channel::RS,
  94                 Channel::MOTION_DATA,
  95                 Channel::SYNC_SIGNAL,
  96                 Channel::SIGN_LANGUAGE,
  97                 Channel::CHANNEL_COUNT
  98         };
  99         for (auto disallowed: disallowed_extra) {
 100                 DCP_ASSERT(std::find(extra_active_channels.begin(), extra_active_channels.end(), disallowed) == extra_active_channels.end());
 101         }
 102
 103         /* Derived from ASDCP::Wav::SimpleWaveHeader::FillADesc */
 104         _state->desc.EditRate = ASDCP::Rational (_asset->edit_rate().numerator, _asset->edit_rate().denominator);
 105         _state->desc.AudioSamplingRate = ASDCP::Rational (_asset->sampling_rate(), 1);
 106         _state->desc.Locked = 0;
 107         _state->desc.ChannelCount = _asset->channels();
 108         _state->desc.QuantizationBits = 24;
 109         _state->desc.BlockAlign = 3 * _asset->channels();
 110         _state->desc.AvgBps = _asset->sampling_rate() * _state->desc.BlockAlign;
 111         _state->desc.LinkedTrackID = 0;
 112         if (asset->standard() == Standard::INTEROP) {
 113                 _state->desc.ChannelFormat = ASDCP::PCM::CF_NONE;
 114         } else {
 115                 /* As required by Bv2.1 */
 116                 _state->desc.ChannelFormat = ASDCP::PCM::CF_CFG_4;
 117         }
 118
 119         /* I'm fairly sure this is not necessary, as ContainerDuration is written
 120            in ASDCP's WriteMXFFooter, but it stops a valgrind warning.
 121         */
 122         _state->desc.ContainerDuration = 0;
 123
 124         _state->frame_buffer.Capacity (ASDCP::PCM::CalcFrameBufferSize (_state->desc));
 125         _state->frame_buffer.Size (ASDCP::PCM::CalcFrameBufferSize (_state->desc));
 126         memset (_state->frame_buffer.Data(), 0, _state->frame_buffer.Capacity());
 127
 128         _asset->fill_writer_info (&_state->writer_info, _asset->id());
 129
 130         if (_sync) {
 131                 _fsk.set_data (create_sync_packets());
 132         }
 133 }
 134
 135
 136 SoundAssetWriter::~SoundAssetWriter()
 137 {
 138         try {
 139                 /* Last-resort finalization to close the file, at least */
 140                 if (!_finalized) {
 141                         _state->mxf_writer.Finalize();
 142                 }
 143         } catch (...) {}
 144 }
 145
 146
 147 void
 148 SoundAssetWriter::start ()
 149 {
 150         auto r = _state->mxf_writer.OpenWrite(dcp::filesystem::fix_long_path(_file).string().c_str(), _state->writer_info, _state->desc);
 151         if (ASDCP_FAILURE(r)) {
 152                 boost::throw_exception (FileError("could not open audio MXF for writing", _file.string(), r));
 153         }
 154
 155         if (_asset->standard() == Standard::SMPTE && _include_mca_subdescriptors) {
 156
 157                 ASDCP::MXF::WaveAudioDescriptor* essence_descriptor = nullptr;
 158                 _state->mxf_writer.OP1aHeader().GetMDObjectByType(
 159                         asdcp_smpte_dict->ul(ASDCP::MDD_WaveAudioDescriptor), reinterpret_cast<ASDCP::MXF::InterchangeObject**>(&essence_descriptor)
 160                         );
 161                 DCP_ASSERT (essence_descriptor);
 162                 essence_descriptor->ChannelAssignment = asdcp_smpte_dict->ul(ASDCP::MDD_DCAudioChannelCfg_4_WTF);
 163
 164                 auto soundfield = new ASDCP::MXF::SoundfieldGroupLabelSubDescriptor(asdcp_smpte_dict);
 165                 GenRandomValue (soundfield->MCALinkID);
 166                 if (auto lang = _asset->language()) {
 167                         soundfield->RFC5646SpokenLanguage = *lang;
 168                 }
 169
 170                 MCASoundField const field =
 171                         (
 172                                 find(_extra_active_channels.begin(), _extra_active_channels.end(), dcp::Channel::BSL) != _extra_active_channels.end() ||
 173                                 find(_extra_active_channels.begin(), _extra_active_channels.end(), dcp::Channel::BSR) != _extra_active_channels.end()
 174                         ) ? MCASoundField::SEVEN_POINT_ONE : MCASoundField::FIVE_POINT_ONE;
 175
 176                 if (field == MCASoundField::SEVEN_POINT_ONE) {
 177                         soundfield->MCATagSymbol = "sg71";
 178                         soundfield->MCATagName = "7.1DS";
 179 LIBDCP_DISABLE_WARNINGS
 180                         soundfield->MCALabelDictionaryID = asdcp_smpte_dict->ul(ASDCP::MDD_DCAudioSoundfield_71);
 181 LIBDCP_ENABLE_WARNINGS
 182                 } else {
 183                         soundfield->MCATagSymbol = "sg51";
 184                         soundfield->MCATagName = "5.1";
 185 LIBDCP_DISABLE_WARNINGS
 186                         soundfield->MCALabelDictionaryID = asdcp_smpte_dict->ul(ASDCP::MDD_DCAudioSoundfield_51);
 187 LIBDCP_ENABLE_WARNINGS
 188                 }
 189
 190                 _state->mxf_writer.OP1aHeader().AddChildObject(soundfield);
 191                 essence_descriptor->SubDescriptors.push_back(soundfield->InstanceUID);
 192
 193                 /* We always make a descriptor for these channels if they are present in the asset;
 194                  * there's no way for the caller to tell us whether they are active or not.
 195                  */
 196                 std::vector<dcp::Channel> dcp_channels = {
 197                         Channel::LEFT,
 198                         Channel::RIGHT,
 199                         Channel::CENTRE,
 200                         Channel::LFE,
 201                         Channel::LS,
 202                         Channel::RS
 203                 };
 204
 205                 /* We add descriptors for some extra channels that the caller gave us (we made sure earlier
 206                  * that nothing "bad" is in this list).
 207                  */
 208                 std::copy(_extra_active_channels.begin(), _extra_active_channels.end(), back_inserter(dcp_channels));
 209
 210                 /* Remove duplicates */
 211                 std::sort(dcp_channels.begin(), dcp_channels.end());
 212                 dcp_channels.erase(std::unique(dcp_channels.begin(), dcp_channels.end()), dcp_channels.end());
 213
 214                 for (auto dcp_channel: dcp_channels) {
 215                         auto channel = new ASDCP::MXF::AudioChannelLabelSubDescriptor(asdcp_smpte_dict);
 216                         GenRandomValue (channel->MCALinkID);
 217                         channel->SoundfieldGroupLinkID = soundfield->MCALinkID;
 218                         channel->MCAChannelID = static_cast<int>(dcp_channel) + 1;
 219                         channel->MCATagSymbol = "ch" + channel_to_mca_id(dcp_channel, field);
 220                         channel->MCATagName = channel_to_mca_name(dcp_channel, field);
 221                         if (auto lang = _asset->language()) {
 222                                 channel->RFC5646SpokenLanguage = *lang;
 223                         }
 224 LIBDCP_DISABLE_WARNINGS
 225                         channel->MCALabelDictionaryID = channel_to_mca_universal_label(dcp_channel, field, asdcp_smpte_dict);
 226 LIBDCP_ENABLE_WARNINGS
 227                         _state->mxf_writer.OP1aHeader().AddChildObject(channel);
 228                         essence_descriptor->SubDescriptors.push_back(channel->InstanceUID);
 229                 }
 230         }
 231
 232         _asset->set_file (_file);
 233         _started = true;
 234 }
 235
 236
 237 void
 238 SoundAssetWriter::write(float const * const * data, int data_channels, int frames)
 239 {
 240         do_write(data, data_channels, frames);
 241 }
 242
 243
 244 void
 245 SoundAssetWriter::write(int32_t const * const * data, int data_channels, int frames)
 246 {
 247         do_write(data, data_channels, frames);
 248 }
 249
 250
 251 void
 252 SoundAssetWriter::write_current_frame ()
 253 {
 254         auto const r = _state->mxf_writer.WriteFrame (_state->frame_buffer, _crypto_context->context(), _crypto_context->hmac());
 255         if (ASDCP_FAILURE(r)) {
 256                 boost::throw_exception (MiscError(String::compose("could not write audio MXF frame (%1)", static_cast<int>(r))));
 257         }
 258
 259         ++_frames_written;
 260
 261         if (_sync) {
 262                 /* We need a new set of sync packets for this frame */
 263                 _fsk.set_data (create_sync_packets());
 264         }
 265 }
 266
 267 bool
 268 SoundAssetWriter::finalize ()
 269 {
 270         if (_frame_buffer_offset > 0) {
 271                 write_current_frame ();
 272         }
 273
 274         if (_started) {
 275                 auto const r = _state->mxf_writer.Finalize();
 276                 if (ASDCP_FAILURE(r)) {
 277                         boost::throw_exception (MiscError(String::compose ("could not finalise audio MXF (%1)", static_cast<int>(r))));
 278                 }
 279         }
 280
 281         _asset->_intrinsic_duration = _frames_written;
 282         return AssetWriter::finalize ();
 283 }
 284
 285
 286 /** Calculate and return the sync packets required for this edit unit (aka "frame") */
 287 vector<bool>
 288 SoundAssetWriter::create_sync_packets ()
 289 {
 290         /* Parts of this code assumes 48kHz */
 291         DCP_ASSERT (_asset->sampling_rate() == 48000);
 292
 293         /* Encoding of edit rate */
 294         int edit_rate_code = 0;
 295         /* How many 0 bits are used to pad the end of the packet */
 296         int remaining_bits = 0;
 297         /* How many packets in this edit unit (i.e. "frame") */
 298         int packets = 0;
 299         auto const edit_rate = _asset->edit_rate ();
 300         if (edit_rate == Fraction(24, 1)) {
 301                 edit_rate_code = 0;
 302                 remaining_bits = 25;
 303                 packets = 4;
 304         } else if (edit_rate == Fraction(25, 1)) {
 305                 edit_rate_code = 1;
 306                 remaining_bits = 20;
 307                 packets = 4;
 308         } else if (edit_rate == Fraction(30, 1)) {
 309                 edit_rate_code = 2;
 310                 remaining_bits = 0;
 311                 packets = 4;
 312         } else if (edit_rate == Fraction(48, 1)) {
 313                 edit_rate_code = 3;
 314                 remaining_bits = 25;
 315                 packets = 2;
 316         } else if (edit_rate == Fraction(50, 1)) {
 317                 edit_rate_code = 4;
 318                 remaining_bits = 20;
 319                 packets = 2;
 320         } else if (edit_rate == Fraction(60, 1)) {
 321                 edit_rate_code = 5;
 322                 remaining_bits = 0;
 323                 packets = 2;
 324         } else if (edit_rate == Fraction(96, 1)) {
 325                 edit_rate_code = 6;
 326                 remaining_bits = 25;
 327                 packets = 1;
 328         } else if (edit_rate == Fraction(100, 1)) {
 329                 edit_rate_code = 7;
 330                 remaining_bits = 20;
 331                 packets = 1;
 332         } else if (edit_rate == Fraction(120, 1)) {
 333                 edit_rate_code = 8;
 334                 remaining_bits = 0;
 335                 packets = 1;
 336         }
 337
 338         Bitstream bs;
 339
 340         Kumu::UUID id;
 341         DCP_ASSERT (id.DecodeHex(_asset->id().c_str()));
 342
 343         for (int i = 0; i < packets; ++i) {
 344                 bs.write_from_byte (0x4d);
 345                 bs.write_from_byte (0x56);
 346                 bs.start_crc (0x1021);
 347                 bs.write_from_byte (edit_rate_code, 4);
 348                 bs.write_from_byte (0, 2);
 349                 bs.write_from_byte (_sync_packet, 2);
 350                 bs.write_from_byte (id.Value()[i * 4 + 0]);
 351                 bs.write_from_byte (id.Value()[i * 4 + 1]);
 352                 bs.write_from_byte (id.Value()[i * 4 + 2]);
 353                 bs.write_from_byte (id.Value()[i * 4 + 3]);
 354                 bs.write_from_word (_frames_written, 24);
 355                 bs.write_crc ();
 356                 bs.write_from_byte (0, 4);
 357                 bs.write_from_word (0, remaining_bits);
 358
 359                 ++_sync_packet;
 360                 if (_sync_packet == 4) {
 361                         _sync_packet = 0;
 362                 }
 363         }
 364
 365         return bs.get();
 366 }
 367
 368
 369 byte_t*
 370 SoundAssetWriter::frame_buffer_data() const
 371 {
 372         return _state->frame_buffer.Data();
 373 }
 374
 375
 376 int
 377 SoundAssetWriter::frame_buffer_capacity() const
 378 {
 379         return _state->frame_buffer.Capacity();
 380 }
 381