CLExportProcessor Class Reference

Inheritance diagram for CLExportProcessor:

Collaboration diagram for CLExportProcessor:

Public Member Functions
bool	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) 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

Static Private Member Functions
static std::vector< char >	GetMetaChunk (const Tags *metadata)

Private Attributes
struct {
TranslatableString   status
double   t0
double   t1
unsigned   channels
wxString   cmd
bool   showOutput
std::unique_ptr< Mixer >   mixer
wxString   output
std::unique_ptr< ExportCLProcess >   process
}	context

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

Detailed Description

Definition at line 418 of file ExportCL.cpp.

Member Function Documentation

GetMetaChunk()

std::vector< char > CLExportProcessor::GetMetaChunk ( const Tags *  metadata )

staticprivate

Definition at line 757 of file ExportCL.cpp.

{
   std::vector<char> buffer;
 
#ifdef USE_LIBID3TAG
   struct id3_tag_deleter {
      void operator () (id3_tag *p) const { if (p) id3_tag_delete(p); }
   };
 
   std::unique_ptr<id3_tag, id3_tag_deleter> tp { id3_tag_new() };
 
   for (const auto &pair : tags->GetRange()) {
      const auto &n = pair.first;
      const auto &v = pair.second;
      const char *name = "TXXX";
 
      if (n.CmpNoCase(TAG_TITLE) == 0) {
         name = ID3_FRAME_TITLE;
      }
      else if (n.CmpNoCase(TAG_ARTIST) == 0) {
         name = ID3_FRAME_ARTIST;
      }
      else if (n.CmpNoCase(TAG_ALBUM) == 0) {
         name = ID3_FRAME_ALBUM;
      }
      else if (n.CmpNoCase(TAG_YEAR) == 0) {
         name = ID3_FRAME_YEAR;
      }
      else if (n.CmpNoCase(TAG_GENRE) == 0) {
         name = ID3_FRAME_GENRE;
      }
      else if (n.CmpNoCase(TAG_COMMENTS) == 0) {
         name = ID3_FRAME_COMMENT;
      }
      else if (n.CmpNoCase(TAG_TRACK) == 0) {
         name = ID3_FRAME_TRACK;
      }
      else if (n.CmpNoCase(wxT("composer")) == 0) {
         name = "TCOM";
      }
 
      struct id3_frame *frame = id3_frame_new(name);
 
      if (!n.IsAscii() || !v.IsAscii()) {
         id3_field_settextencoding(id3_frame_field(frame, 0), ID3_FIELD_TEXTENCODING_UTF_16);
      }
      else {
         id3_field_settextencoding(id3_frame_field(frame, 0), ID3_FIELD_TEXTENCODING_ISO_8859_1);
      }
 
      MallocString<id3_ucs4_t> ucs4{
         id3_utf8_ucs4duplicate((id3_utf8_t *) (const char *) v.mb_str(wxConvUTF8)) };
 
      if (strcmp(name, ID3_FRAME_COMMENT) == 0) {
         // A hack to get around iTunes not recognizing the comment.  The
         // language defaults to XXX and, since it's not a valid language,
         // iTunes just ignores the tag.  So, either set it to a valid language
         // (which one???) or just clear it.  Unfortunately, there's no supported
         // way of clearing the field, so do it directly.
         id3_field *f = id3_frame_field(frame, 1);
         memset(f->immediate.value, 0, sizeof(f->immediate.value));
         id3_field_setfullstring(id3_frame_field(frame, 3), ucs4.get());
      }
      else if (strcmp(name, "TXXX") == 0) {
         id3_field_setstring(id3_frame_field(frame, 2), ucs4.get());
 
         ucs4.reset(id3_utf8_ucs4duplicate((id3_utf8_t *) (const char *) n.mb_str(wxConvUTF8)));
 
         id3_field_setstring(id3_frame_field(frame, 1), ucs4.get());
      }
      else {
         auto addr = ucs4.get();
         id3_field_setstrings(id3_frame_field(frame, 1), 1, &addr);
      }
 
      id3_tag_attachframe(tp.get(), frame);
   }
 
   tp->options &= (~ID3_TAG_OPTION_COMPRESSION); // No compression
 
   // If this version of libid3tag supports it, use v2.3 ID3
   // tags instead of the newer, but less well supported, v2.4
   // that libid3tag uses by default.
#ifdef ID3_TAG_HAS_TAG_OPTION_ID3V2_3
   tp->options |= ID3_TAG_OPTION_ID3V2_3;
#endif
 
   id3_length_t len;
 
   len = id3_tag_render(tp.get(), 0);
   if ((len % 2) != 0) {
      len++;   // Length must be even.
   }
 
   if (len > 0) {
      buffer.resize(len);
      id3_tag_render(tp.get(), (id3_byte_t *) buffer.data());
   }
#endif
 
   return buffer;
}

References Tags::GetRange(), name, TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_GENRE, TAG_TITLE, TAG_TRACK, TAG_YEAR, and wxT().

Referenced by Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

bool CLExportProcessor::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 491 of file ExportCL.cpp.

{
   context.t0 = t0;
   context.t1 = t1;
   context.channels = channels;
 
   ExtendPath ep;
   long rc;
 
   const auto path = fName.GetFullPath();
 
   context.cmd = wxString::FromUTF8(ExportPluginHelpers::GetParameterValue<std::string>(parameters, CLOptionIDCommand));
   context.showOutput = ExportPluginHelpers::GetParameterValue(parameters, CLOptionIDShowOutput, false);
 
   // Bug 2178 - users who don't know what they are doing will 
   // now get a file extension of .wav appended to their ffmpeg filename
   // and therefore ffmpeg will be able to choose a file type.
   if( context.cmd == wxT("ffmpeg -i - \"%f\"") && !fName.HasExt())
      context.cmd.Replace( "%f", "%f.wav" );
   context.cmd.Replace(wxT("%f"), path);
 
   // Kick off the command
   context.process = std::make_unique<ExportCLProcess>(&context.output);
   auto& process = *context.process;
 
   rc = wxExecute(context.cmd, wxEXEC_ASYNC, &process);
   if (!rc) {
      process.Detach();
      process.CloseOutput();
      throw ExportException(XO("Cannot export audio to %s")
         .Format( path )
         .Translation());
   }
 
   // Turn off logging to prevent broken pipe messages
   wxLogNull nolog;
 
   // establish parameters
   int rate = lrint(sampleRate);
   const size_t maxBlockLen = 44100 * 5;
   unsigned long totalSamples = lrint((t1 - t0) * rate);
   unsigned long sampleBytes = totalSamples * channels * SAMPLE_SIZE(floatSample);
 
   wxOutputStream *os = process.GetOutputStream();
 
   // RIFF header
   struct {
      char riffID[4];            // "RIFF"
      wxUint32 riffLen;          // basically the file len - 8
      char riffType[4];          // "WAVE"
   } riff;
 
   // format chunk */
   struct {
      char fmtID[4];             // "fmt " */
      wxUint32 formatChunkLen;   // (format chunk len - first two fields) 16 in our case
      wxUint16 formatTag;        // 1 for PCM
      wxUint16 channels;
      wxUint32 sampleRate;
      wxUint32 avgBytesPerSec;   // sampleRate * blockAlign
      wxUint16 blockAlign;       // bitsPerSample * channels (assume bps % 8 = 0)
      wxUint16 bitsPerSample;
   } fmt;
 
   // id3 chunk header
   struct {
      char id3ID[4];             // "id3 "
      wxUint32 id3Len;           // length of metadata in bytes
   } id3;
 
   // data chunk header
   struct {
      char dataID[4];            // "data"
      wxUint32 dataLen;          // length of all samples in bytes
   } data;
 
   riff.riffID[0] = 'R';
   riff.riffID[1] = 'I';
   riff.riffID[2] = 'F';
   riff.riffID[3] = 'F';
   riff.riffLen   = wxUINT32_SWAP_ON_BE(sizeof(riff) +
                                        sizeof(fmt) +
                                        sizeof(data) +
                                        sampleBytes -
                                        8);
   riff.riffType[0]  = 'W';
   riff.riffType[1]  = 'A';
   riff.riffType[2]  = 'V';
   riff.riffType[3]  = 'E';
 
   fmt.fmtID[0]        = 'f';
   fmt.fmtID[1]        = 'm';
   fmt.fmtID[2]        = 't';
   fmt.fmtID[3]        = ' ';
   fmt.formatChunkLen  = wxUINT32_SWAP_ON_BE(16);
   fmt.formatTag       = wxUINT16_SWAP_ON_BE(3);
   fmt.channels        = wxUINT16_SWAP_ON_BE(channels);
   fmt.sampleRate      = wxUINT32_SWAP_ON_BE(rate);
   fmt.bitsPerSample   = wxUINT16_SWAP_ON_BE(SAMPLE_SIZE(floatSample) * 8);
   fmt.blockAlign      = wxUINT16_SWAP_ON_BE(fmt.bitsPerSample * fmt.channels / 8);
   fmt.avgBytesPerSec  = wxUINT32_SWAP_ON_BE(fmt.sampleRate * fmt.blockAlign);
 
   // Retrieve tags if not given a set
   if (metadata == nullptr) {
      metadata = &Tags::Get(project);
   }
   const auto metachunk = GetMetaChunk(metadata);
 
   if (!metachunk.empty()) {
 
      id3.id3ID[0] = 'i';
      id3.id3ID[1] = 'd';
      id3.id3ID[2] = '3';
      id3.id3ID[3] = ' ';
      id3.id3Len   = wxUINT32_SWAP_ON_BE(metachunk.size());
      riff.riffLen += sizeof(id3) + metachunk.size();
   }
 
   data.dataID[0] = 'd';
   data.dataID[1] = 'a';
   data.dataID[2] = 't';
   data.dataID[3] = 'a';
   data.dataLen   = wxUINT32_SWAP_ON_BE(sampleBytes);
 
   // write the headers and metadata
   os->Write(&riff, sizeof(riff));
   os->Write(&fmt, sizeof(fmt));
   if (!metachunk.empty()) {
      os->Write(&id3, sizeof(id3));
      os->Write(metachunk.data(), metachunk.size());
   }
   os->Write(&data, sizeof(data));
 
   // Mix 'em up
   const auto &tracks = TrackList::Get( project );
   context.mixer = ExportPluginHelpers::CreateMixer(
                            tracks,
                            selectionOnly,
                            t0,
                            t1,
                            channels,
                            maxBlockLen,
                            true,
                            rate,
                            floatSample,
                            mixerSpec);
 
   context.status = selectionOnly
         ? XO("Exporting the selected audio using command-line encoder")
         : XO("Exporting the audio using command-line encoder");
 
   return true;
}

References channels, CLOptionIDCommand, CLOptionIDShowOutput, context, ExportPluginHelpers::CreateMixer(), floatSample, Tags::Get(), TrackList::Get(), GetMetaChunk(), ExportPluginHelpers::GetParameterValue(), lrint, process, project, SAMPLE_SIZE, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, t0, t1, tracks, wxT(), and XO().

Here is the call graph for this function:

Process()

ExportResult CLExportProcessor::Process ( ExportProcessorDelegate &  delegate )

overridevirtual

Implements ExportProcessor.

Definition at line 651 of file ExportCL.cpp.

{
   delegate.SetStatusString(context.status);
   auto& process = *context.process;
   auto exportResult = ExportResult::Success;
   {
      size_t numBytes = 0;
      constSamplePtr mixed = nullptr;
 
      wxOutputStream *os = process.GetOutputStream();
      auto closeIt = finally ( [&] {
         // Should make the process die, before propagating any exception
         process.CloseOutput();
      } );
 
      // Start piping the mixed data to the command
      while (exportResult == ExportResult::Success && process.IsActive() && os->IsOk()) {
         // Capture any stdout and stderr from the command
         Drain(process.GetInputStream(), &context.output);
         Drain(process.GetErrorStream(), &context.output);
 
         // Need to mix another block
         if (numBytes == 0) {
            auto numSamples = context.mixer->Process();
            if (numSamples == 0)
               break;
 
            mixed = context.mixer->GetBuffer();
            numBytes = numSamples * context.channels;
 
            // Byte-swapping is necessary on big-endian machines, since
            // WAV files are little-endian
#if wxBYTE_ORDER == wxBIG_ENDIAN
            auto buffer = (const float *) mixed;
            for (int i = 0; i < numBytes; i++) {
               buffer[i] = wxUINT32_SWAP_ON_BE(buffer[i]);
            }
#endif
            numBytes *= SAMPLE_SIZE(floatSample);
         }
 
         // Don't write too much at once...pipes may not be able to handle it
         size_t bytes = wxMin(numBytes, 4096);
         numBytes -= bytes;
 
         while (bytes > 0) {
            os->Write(mixed, bytes);
            if (!os->IsOk()) {
               exportResult = ExportResult::Error;
               break;
            }
            bytes -= os->LastWrite();
            mixed += os->LastWrite();
         }
 
         if(exportResult == ExportResult::Success)
            exportResult = ExportPluginHelpers::UpdateProgress(
               delegate, *context.mixer, context.t0, context.t1);
      }
      // Done with the progress display
   }
 
   // Wait for process to terminate
   while (process.IsActive()) {
      using namespace std::chrono;
      std::this_thread::sleep_for(10ms);
      BasicUI::Yield();
   }
 
   // Display output on error or if the user wants to see it
   if (process.GetStatus() != 0 || context.showOutput) {
      // TODO use ShowInfoDialog() instead.
      BasicUI::CallAfter([cmd = context.cmd, output = std::move(context.output)]
      {
         wxDialogWrapper dlg(nullptr,
                   wxID_ANY,
                   XO("Command Output"),
                   wxDefaultPosition,
                   wxSize(600, 400),
                   wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER);
         dlg.SetName();
 
         ShuttleGui S(&dlg, eIsCreating);
         S
            .Style( wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH )
            .AddTextWindow(cmd + wxT("\n\n") + output);
         S.StartHorizontalLay(wxALIGN_CENTER, false);
         {
            S.Id(wxID_OK).AddButton(XXO("&OK"), wxALIGN_CENTER, true);
         }
         dlg.GetSizer()->AddSpacer(5);
         dlg.Layout();
         dlg.SetMinSize(dlg.GetSize());
         dlg.Center();
 
         dlg.ShowModal();
      });
 
      if (process.GetStatus() != 0)
         exportResult = ExportResult::Error;
   }
 
   return exportResult;
}

References BasicUI::CallAfter(), cmd, context, anonymous_namespace{ExportCL.cpp}::Drain(), Error, floatSample, output, process, SAMPLE_SIZE, ExportProcessorDelegate::SetStatusString(), Success, ExportPluginHelpers::UpdateProgress(), and BasicUI::Yield().

Here is the call graph for this function:

Member Data Documentation

channels

unsigned CLExportProcessor::channels

Definition at line 425 of file ExportCL.cpp.

Referenced by Initialize().

cmd

wxString CLExportProcessor::cmd

Definition at line 426 of file ExportCL.cpp.

Referenced by Process().

struct { ... } CLExportProcessor::context

Referenced by Initialize(), and Process().

mixer

std::unique_ptr<Mixer> CLExportProcessor::mixer

Definition at line 428 of file ExportCL.cpp.

output

wxString CLExportProcessor::output

Definition at line 429 of file ExportCL.cpp.

Referenced by Process().

process

std::unique_ptr<ExportCLProcess> CLExportProcessor::process

Definition at line 430 of file ExportCL.cpp.

Referenced by Initialize(), and Process().

showOutput

bool CLExportProcessor::showOutput

Definition at line 427 of file ExportCL.cpp.

status

TranslatableString CLExportProcessor::status

Definition at line 422 of file ExportCL.cpp.

t0

double CLExportProcessor::t0

Definition at line 423 of file ExportCL.cpp.

Referenced by Initialize().

t1

double CLExportProcessor::t1

Definition at line 424 of file ExportCL.cpp.

Referenced by Initialize().

---

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

• ExportCL.cpp