OpusExportProcessor Class Reference

Inheritance diagram for OpusExportProcessor:

Collaboration diagram for OpusExportProcessor:

Classes
struct	OggPacket

Public Member Functions
	~OpusExportProcessor ()
bool	Initialize (AudacityProject &project, const Parameters &parameters, const wxFileNameWrapper &filename, double t0, double t1, bool selectedOnly, double sampleRate, unsigned channels, MixerOptions::Downmix *mixerSpec, const Tags *tags) override
	Called before start processing. More...
ExportResult	Process (ExportProcessorDelegate &delegate) override
Public Member Functions inherited from ExportProcessor
	ExportProcessor (const ExportProcessor &)=delete
ExportProcessor &	operator= (const ExportProcessor &)=delete
	ExportProcessor ()=default
virtual	~ExportProcessor ()
virtual bool	Initialize (AudacityProject &project, const Parameters &parameters, const wxFileNameWrapper &filename, double t0, double t1, bool selectedOnly, double rate, unsigned channels, MixerOptions::Downmix *mixerSpec=nullptr, const Tags *tags=nullptr)=0
	Called before start processing. More...
virtual ExportResult	Process (ExportProcessorDelegate &delegate)=0

Private Member Functions
void	WriteOpusHeader ()
void	WriteTags ()
int32_t	GetBestFrameSize (int32_t samplesCount) const noexcept

Private Attributes
struct {
TranslatableString   status
int32_t   sampleRate {}
double   t0 {}
double   t1 {}
unsigned   numChannels {}
wxFileNameWrapper   fName
wxFile   outFile
std::unique_ptr< Mixer >   mixer
std::unique_ptr< Tags >   metadata
struct OpusState {
OpusMSEncoder *   encoder {}
int32_t   frameSize {}
int32_t   sampleRateFactor {}
uint16_t   preskip {}
uint8_t   channelMapping {}
uint8_t   nbStreams {}
uint8_t   nbCoupled {}
uint8_t   streamMap [255] {}
}   opus
struct OggState {
ogg_stream_state   stream
OggPacket   audioStreamPacket
}   ogg
std::vector< float >   encodeBuffer
}	context

Additional Inherited Members
Public Types inherited from ExportProcessor
using	Parameters = std::vector< std::tuple< ExportOptionID, ExportValue > >

Detailed Description

Definition at line 234 of file ExportOpus.cpp.

Constructor & Destructor Documentation

~OpusExportProcessor()

OpusExportProcessor::~OpusExportProcessor

(

)

Definition at line 606 of file ExportOpus.cpp.

{
 
}

Member Function Documentation

GetBestFrameSize()

int32_t OpusExportProcessor::GetBestFrameSize ( int32_t  samplesCount ) const

inlineprivatenoexcept

Definition at line 434 of file ExportOpus.cpp.

   {
      static const int32_t multipliers[] = {
         25, 50, 100, 200, 400, 600,
      };
 
      const auto sampleRate = context.sampleRate;
 
      for (auto multiplier : multipliers)
      {
         const auto frameSize = multiplier * sampleRate / 10000;
 
         if (samplesCount <= frameSize)
            return frameSize;
      }
 
      return 60 * sampleRate / 1000;
   }

References context, frameSize, and sampleRate.

Referenced by Process().

Here is the caller graph for this function:

Initialize()

bool OpusExportProcessor::Initialize ( AudacityProject &  project, const Parameters &  parameters, const wxFileNameWrapper &  filename, double  t0, double  t1, bool  selectedOnly, double  rate, unsigned  channels, MixerOptions::Downmix *  mixerSpec, const Tags *  tags  )

overridevirtual

Called before start processing.

Parameters

project	Processor may access project data, take care to exclude any data race
parameters	A format-dependent set of parameters used in exporting
selectedOnly	Set to true if all tracks should be mixed, to false if only the selected tracks should be mixed and exported.
tags	A Tags object that will over-ride the one in *project and be used to tag the file that is exported. @retern Implementations may simply return false without any error reporting. This is to temporarily preserve old behavior, which is to be removed in the nearest future.

Implements ExportProcessor.

Definition at line 611 of file ExportOpus.cpp.

{
   context.sampleRate = int32_t(sampleRate);
 
   if (!IsValidSampleRate(context.sampleRate))
      throw ExportException(XO("Unsupported sample rate").Translation());
 
   context.t0 = t0;
   context.t1 = t1;
   context.numChannels = numChannels;
   context.fName = fName;
 
   // Internally the Opus is always in 48k, find out the multiplier for
   // values, that expect 48k sample rate
   context.opus.sampleRateFactor = 48000 / context.sampleRate;
 
   const auto bitRate = ExportPluginHelpers::GetParameterValue<int>(
      parameters, OPUSOptionIDBitRate, OPUS_AUTO);
   const auto vbrMode = ExportPluginHelpers::GetParameterValue<int>(
      parameters, OPUSOptionIDVBRMode, VBRMode::VBR);
   const int complexity = ExportPluginHelpers::GetParameterValue<int>(
      parameters, OPUSOptionIDQuality, 10);
   const int frameMultiplier = ExportPluginHelpers::GetParameterValue<int>(
      parameters, OPUSOptionIDFrameDuration, 200);
   const int application = ExportPluginHelpers::GetParameterValue<int>(
      parameters, OPUSOptionIDApplication, OPUS_APPLICATION_AUDIO);
   const int cutoff = ExportPluginHelpers::GetParameterValue<int>(
      parameters, OPUSOptionIDCutoff, OPUS_AUTO);
 
   // Number of samples per frame per channel
   context.opus.frameSize = frameMultiplier * context.sampleRate / 10000;
 
   context.status = selectionOnly ? XO("Exporting selected audio as Opus") :
                                    XO("Exporting the audio as Opus");
 
   // Create opus encoder
   int error;
 
   if (numChannels <= 2)
   {
      context.opus.channelMapping = 0;
      context.opus.nbStreams = 1;
      context.opus.nbCoupled = numChannels - 1;
      context.opus.streamMap[0] = 0;
      context.opus.streamMap[1] = 1;
 
      context.opus.encoder = opus_multistream_encoder_create(
         sampleRate, numChannels, context.opus.nbStreams,
         context.opus.nbCoupled, context.opus.streamMap, application, &error);
   }
   else
   {
      context.opus.channelMapping = numChannels <= 8 ? 1 : 255;
 
      int nbStreams {}, nbCoupled {};
 
      context.opus.encoder = opus_multistream_surround_encoder_create(
         sampleRate, numChannels, context.opus.channelMapping,
         &nbStreams, &nbCoupled,
         context.opus.streamMap, application, &error);
 
      // opus_multistream_surround_encoder_create is expected to fill
      // stream count with values in [0, 255]
      context.opus.nbStreams = uint8_t(nbStreams);
      context.opus.nbCoupled = uint8_t(nbCoupled);
   }
 
   if (error != OPUS_OK)
      FailExport(XO("Unable to create Opus encoder"), error);
 
   error = opus_multistream_encoder_ctl(
      context.opus.encoder, OPUS_SET_BITRATE(bitRate));
 
   if (error != OPUS_OK)
      FailExport(XO("Unable to set bitrate"), error);
 
   error = opus_multistream_encoder_ctl(
      context.opus.encoder, OPUS_SET_COMPLEXITY(complexity));
 
   if (error != OPUS_OK)
      FailExport(XO("Unable to set complexity"), error);
 
   error = opus_multistream_encoder_ctl(
      context.opus.encoder, OPUS_SET_BANDWIDTH(cutoff));
 
   if (error != OPUS_OK)
      FailExport(XO("Unable to set bandwidth"), error);
 
   error = opus_multistream_encoder_ctl(
      context.opus.encoder, OPUS_SET_VBR(vbrMode == VBRMode::CBR ? 0 : 1));
 
   if (error != OPUS_OK)
      FailExport(XO("Unable to set VBR mode"), error);
 
   if (vbrMode == VBRMode::CVBR)
   {
      error = opus_multistream_encoder_ctl(
         context.opus.encoder, OPUS_SET_VBR_CONSTRAINT(1));
 
      if (error != OPUS_OK)
         FailExport(XO("Unable to set CVBR mode"), error);
   }
 
   // Calculate the encoder latency. This value is needed in header
   // and to flush the encoder
   int lookahead {};
   error = opus_multistream_encoder_ctl(
      context.opus.encoder, OPUS_GET_LOOKAHEAD(&lookahead));
 
   if (error != OPUS_OK)
      FailExport(XO("Unable to get lookahead"), error);
 
   // Latency is always in 48k encoded samples
   const auto calculatedPreskip = lookahead * context.opus.sampleRateFactor;
   if (
      calculatedPreskip < 0 ||
      calculatedPreskip >= std::numeric_limits<uint16_t>::max())
      FailExport(XO("Failed to calculate correct preskip"), OPUS_BAD_ARG);
   // It is safe to cast to uint16_t here
   context.opus.preskip = uint16_t(calculatedPreskip);
 
   // Resize the audio packet so it can contain all the raw data.
   // This is overkill, but should be enough to hold all the data from
   // the encode float
   context.ogg.audioStreamPacket.Resize(
      context.opus.frameSize * sizeof(float) * numChannels);
 
 
   // Try to open the file for writing
   if (
      !context.outFile.Create(fName.GetFullPath(), true) ||
      !context.outFile.IsOpened())
   {
      throw ExportException(_("Unable to open target file for writing"));
   }
 
   WriteOpusHeader();
 
   context.metadata = std::make_unique<Tags>(
      metadata == nullptr ? Tags::Get(project) : *metadata);
 
   WriteTags();
 
   const auto& tracks = TrackList::Get(project);
 
   context.mixer = ExportPluginHelpers::CreateMixer(
      tracks, selectionOnly, t0, t1, numChannels, context.opus.frameSize, true,
      sampleRate, floatSample, mixerSpec);
 
   return true;
}

References _, anonymous_namespace{ExportOpus.cpp}::VBRMode::CBR, context, ExportPluginHelpers::CreateMixer(), anonymous_namespace{ExportOpus.cpp}::VBRMode::CVBR, anonymous_namespace{ExportOpus.cpp}::FailExport(), floatSample, fName, Tags::Get(), TrackList::Get(), anonymous_namespace{ExportOpus.cpp}::IsValidSampleRate(), metadata, nbCoupled, nbStreams, numChannels, anonymous_namespace{ExportOpus.cpp}::OPUSOptionIDApplication, anonymous_namespace{ExportOpus.cpp}::OPUSOptionIDBitRate, anonymous_namespace{ExportOpus.cpp}::OPUSOptionIDCutoff, anonymous_namespace{ExportOpus.cpp}::OPUSOptionIDFrameDuration, anonymous_namespace{ExportOpus.cpp}::OPUSOptionIDQuality, anonymous_namespace{ExportOpus.cpp}::OPUSOptionIDVBRMode, project, sampleRate, t0, t1, tracks, anonymous_namespace{ExportOpus.cpp}::VBRMode::VBR, WriteOpusHeader(), WriteTags(), and XO().

Here is the call graph for this function:

Process()

ExportResult OpusExportProcessor::Process ( ExportProcessorDelegate &  delegate )

overridevirtual

Implements ExportProcessor.

Definition at line 767 of file ExportOpus.cpp.

{
   delegate.SetStatusString(context.status);
 
   auto exportResult = ExportResult::Success;
 
   int64_t granulePos = 0;
 
   int32_t latencyLeft = context.opus.preskip;
 
   while (exportResult == ExportResult::Success)
   {
      auto samplesThisRun = context.mixer->Process();
 
      if (samplesThisRun == 0)
         break;
 
      auto mixedAudioBuffer =
         reinterpret_cast<const float*>(context.mixer->GetBuffer());
 
      // bestFrameSize <= context.opus.frameSize by design
      auto bestFrameSize = GetBestFrameSize(samplesThisRun);
 
      if (samplesThisRun < bestFrameSize)
      {
         // Opus expects that the full frame is passed to the encoder, fill missing data with zeroes
         context.encodeBuffer.resize(bestFrameSize * context.numChannels);
 
         std::copy(
            mixedAudioBuffer, mixedAudioBuffer + samplesThisRun * context.numChannels,
            context.encodeBuffer.begin());
 
         std::fill(
            context.encodeBuffer.begin() + samplesThisRun * context.numChannels,
            context.encodeBuffer.begin() + bestFrameSize * context.numChannels,
            0);
 
         mixedAudioBuffer = context.encodeBuffer.data();
 
         auto zeroesCount = bestFrameSize - int32_t(samplesThisRun);
 
         if (zeroesCount < latencyLeft)
            samplesThisRun += zeroesCount;
         else
            samplesThisRun += latencyLeft;
 
         // Reduce the latency by the number of zeroes pushed (potentially
         // removing the need to flush the encoder)
         latencyLeft = std::max(0, latencyLeft - zeroesCount);
      }
 
      auto result = opus_multistream_encode_float(
         context.opus.encoder, mixedAudioBuffer, bestFrameSize,
         context.ogg.audioStreamPacket.GetBuffer(),
         context.ogg.audioStreamPacket.GetBufferSize());
 
      if (result < 0)
         FailExport(XO("Failed to encode input buffer"), result);
 
      // granulePos is the index of the last real sample in the packet at 48k rate
      granulePos += samplesThisRun * context.opus.sampleRateFactor;
 
      context.ogg.audioStreamPacket.packet.bytes = result;
      context.ogg.audioStreamPacket.packet.granulepos = granulePos;
 
      if (latencyLeft == 0)
         context.ogg.audioStreamPacket.MarkEOS();
 
      context.ogg.PacketIn(context.ogg.audioStreamPacket);
      context.ogg.WriteOut(context.outFile);
 
      context.ogg.audioStreamPacket.packet.packetno++;
      
      exportResult = ExportPluginHelpers::UpdateProgress(
         delegate, *context.mixer, context.t0, context.t1);
   }
 
   // Flush the encoder
 
   while (latencyLeft > 0)
   {
      auto frameSize = GetBestFrameSize(latencyLeft);
 
      context.encodeBuffer.resize(frameSize * context.numChannels);
 
      std::fill(
         context.encodeBuffer.begin(),
         context.encodeBuffer.begin() + frameSize * context.numChannels, 0);
 
      auto samplesOut = std::min(latencyLeft, frameSize);
 
      auto result = opus_multistream_encode_float(
         context.opus.encoder, context.encodeBuffer.data(),
         frameSize, context.ogg.audioStreamPacket.GetBuffer(),
         context.ogg.audioStreamPacket.GetBufferSize());
 
      if (result < 0)
         FailExport(XO("Failed to encode input buffer"), result);
 
      granulePos += samplesOut * context.opus.sampleRateFactor;
 
      context.ogg.audioStreamPacket.packet.bytes = result;
      context.ogg.audioStreamPacket.packet.granulepos = granulePos;
 
      if (latencyLeft == samplesOut)
         context.ogg.audioStreamPacket.MarkEOS();
 
      context.ogg.PacketIn(context.ogg.audioStreamPacket);
      context.ogg.WriteOut(context.outFile);
 
      context.ogg.audioStreamPacket.packet.packetno++;
 
      latencyLeft -= samplesOut;
   }
 
   context.ogg.Flush(context.outFile);
 
   if (!context.outFile.Close())
      return ExportResult::Error;
 
   return exportResult;
}

References context, staffpad::vo::copy(), Error, anonymous_namespace{ExportOpus.cpp}::FailExport(), frameSize, GetBestFrameSize(), min(), ExportProcessorDelegate::SetStatusString(), Success, ExportPluginHelpers::UpdateProgress(), and XO().

Here is the call graph for this function:

WriteOpusHeader()

void OpusExportProcessor::WriteOpusHeader ( )

private

Definition at line 520 of file ExportOpus.cpp.

{
   const auto headerSize =
      // "OpusHead"
      8 +
      // Version number (always 1)
      1 +
      // Channels count
      1 +
      // Preskip
      2 +
      // Input sample rate
      4 +
      // Output gain (always 0)
      2 +
      // Channel mapping
      1 +
      (context.opus.channelMapping == 0 ? 0 :
         (
            // Stream count
            1 +
            // Two channel stream count
            1 +
            // Channel mapping
            context.numChannels));
 
   OggPacket headerPacket(0, headerSize, false);
   // Header must have beginning-of-stream marker
   headerPacket.MarkBOS();
 
   headerPacket.Write("OpusHead", 8);
   headerPacket.Write<uint8_t>(1);
   headerPacket.Write<uint8_t>(context.numChannels);
   headerPacket.Write(context.opus.preskip);
   // Should we put the project sample rate here?
   headerPacket.Write(context.sampleRate);
   // Opus docs recommend encoders to use 0 as a gain
   headerPacket.Write<uint16_t>(0);
   headerPacket.Write(context.opus.channelMapping);
 
   if (context.opus.channelMapping > 0)
   {
      headerPacket.Write(context.opus.nbStreams);
      headerPacket.Write(context.opus.nbCoupled);
 
      for (int i = 0; i < context.numChannels; ++i)
         headerPacket.Write<uint8_t>(context.opus.streamMap[i]);
   }
 
   // This is guaranteed by the way we calculate the header size
   assert(headerPacket.packet.bytes == headerSize);
 
   context.ogg.PacketIn(headerPacket);
   context.ogg.Flush(context.outFile);
}

References context, OpusExportProcessor::OggPacket::MarkBOS(), OpusExportProcessor::OggPacket::packet, and OpusExportProcessor::OggPacket::Write().

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteTags()

void OpusExportProcessor::WriteTags ( )

private

Definition at line 576 of file ExportOpus.cpp.

{
   OggPacket commentsPacket { 1, true };
 
   commentsPacket.Write("OpusTags", 8);
 
   const std::string_view vendor { opus_get_version_string() };
 
   commentsPacket.Write<uint32_t>(vendor.size());
   commentsPacket.Write(vendor.data(), vendor.size());
 
   commentsPacket.Write<uint32_t>(context.metadata->Count());
 
   for (const auto& pair : context.metadata->GetRange())
   {
      const auto key = pair.first == TAG_YEAR ? std::string("DATE") :
                                                audacity::ToUTF8(pair.first);
 
      const auto value = audacity::ToUTF8(pair.second);
 
      commentsPacket.Write<uint32_t>(key.size() + value.size() + 1);
      commentsPacket.Write(key.data(), key.size());
      commentsPacket.Write("=", 1);
      commentsPacket.Write(value.data(), value.size());
   }
 
   context.ogg.PacketIn(commentsPacket);
   context.ogg.Flush(context.outFile);
}

References context, key, TAG_YEAR, audacity::ToUTF8(), and OpusExportProcessor::OggPacket::Write().

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

audioStreamPacket

OggPacket OpusExportProcessor::audioStreamPacket

Definition at line 413 of file ExportOpus.cpp.

channelMapping

uint8_t OpusExportProcessor::channelMapping {}

Definition at line 366 of file ExportOpus.cpp.

struct { ... } OpusExportProcessor::context

Referenced by GetBestFrameSize(), Initialize(), Process(), WriteOpusHeader(), and WriteTags().

encodeBuffer

std::vector<float> OpusExportProcessor::encodeBuffer

Definition at line 428 of file ExportOpus.cpp.

encoder

OpusMSEncoder* OpusExportProcessor::encoder {}

Definition at line 361 of file ExportOpus.cpp.

fName

wxFileNameWrapper OpusExportProcessor::fName

Definition at line 347 of file ExportOpus.cpp.

Referenced by Initialize().

frameSize

int32_t OpusExportProcessor::frameSize {}

Definition at line 363 of file ExportOpus.cpp.

Referenced by GetBestFrameSize(), and Process().

metadata

std::unique_ptr<Tags> OpusExportProcessor::metadata

Definition at line 350 of file ExportOpus.cpp.

Referenced by Initialize().

mixer

std::unique_ptr<Mixer> OpusExportProcessor::mixer

Definition at line 349 of file ExportOpus.cpp.

nbCoupled

uint8_t OpusExportProcessor::nbCoupled {}

Definition at line 368 of file ExportOpus.cpp.

Referenced by Initialize().

nbStreams

uint8_t OpusExportProcessor::nbStreams {}

Definition at line 367 of file ExportOpus.cpp.

Referenced by Initialize().

numChannels

unsigned OpusExportProcessor::numChannels {}

Definition at line 346 of file ExportOpus.cpp.

Referenced by Initialize().

struct { ... } ::OggState OpusExportProcessor::ogg

struct { ... } ::OpusState OpusExportProcessor::opus

outFile

wxFile OpusExportProcessor::outFile

Definition at line 348 of file ExportOpus.cpp.

preskip

uint16_t OpusExportProcessor::preskip {}

Definition at line 365 of file ExportOpus.cpp.

sampleRate

int32_t OpusExportProcessor::sampleRate {}

Definition at line 342 of file ExportOpus.cpp.

Referenced by GetBestFrameSize(), and Initialize().

sampleRateFactor

int32_t OpusExportProcessor::sampleRateFactor {}

Definition at line 364 of file ExportOpus.cpp.

status

TranslatableString OpusExportProcessor::status

Definition at line 341 of file ExportOpus.cpp.

stream

ogg_stream_state OpusExportProcessor::stream

Definition at line 411 of file ExportOpus.cpp.

streamMap

uint8_t OpusExportProcessor::streamMap[255] {}

Definition at line 369 of file ExportOpus.cpp.

t0

double OpusExportProcessor::t0 {}

Definition at line 344 of file ExportOpus.cpp.

Referenced by Initialize().

t1

double OpusExportProcessor::t1 {}

Definition at line 345 of file ExportOpus.cpp.

Referenced by Initialize().

---

The documentation for this class was generated from the following file:

• ExportOpus.cpp