Inheritance diagram for PCMExportProcessor:

Collaboration diagram for PCMExportProcessor:

Public Member Functions
	PCMExportProcessor (int subformat)

	~PCMExportProcessor () override

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

Static Private Member Functions
static ArrayOf< char >	AdjustString (const wxString &wxStr, int sf_format)

static void	AddStrings (SNDFILE sf, const Tags tags, int sf_format)

static bool	AddID3Chunk (const wxFileNameWrapper &fName, const Tags *tags, int sf_format)

Private Attributes
struct {
int subformat

double t0

double t1

std::unique_ptr< Mixer > mixer

TranslatableString status

SF_INFO info

sampleFormat format

wxFile f

SNDFILE * sf

int sf_format

wxFileNameWrapper fName

int fileFormat

std::unique_ptr< Tags > metadata

}	context

Static Private Attributes
static constexpr size_t	maxBlockLen = 44100 * 5

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

Detailed Description

Definition at line 378 of file ExportPCM.cpp.

Constructor & Destructor Documentation

◆ PCMExportProcessor()

PCMExportProcessor::PCMExportProcessor ( int subformat )

inline

Definition at line 401 of file ExportPCM.cpp.

   {
      context.sf = nullptr;
      context.subformat = subformat;
   }

References context, and subformat.

◆ ~PCMExportProcessor()

PCMExportProcessor::~PCMExportProcessor ( )

inlineoverride

Definition at line 407 of file ExportPCM.cpp.

   {
      if(context.f.IsOpened())
      {
         if(context.sf != nullptr)
            sf_close(context.sf);
         context.f.Close();
      }
   }

References context.

Member Function Documentation

◆ AddID3Chunk()

bool PCMExportProcessor::AddID3Chunk	(	const wxFileNameWrapper &	fName,
		const Tags *	tags,
		int	sf_format
	)

staticprivate

Definition at line 953 of file ExportPCM.cpp.

{
#ifdef USE_LIBID3TAG
   id3_tag_holder 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 == 0)
      return true;
 
   if ((len % 2) != 0) len++;   // Length must be even.
   ArrayOf<id3_byte_t> buffer { len, true };
   if (buffer == NULL)
      return false;
 
   // Zero all locations, for ending odd UTF16 content
   // correctly, i.e., two '\0's at the end.
 
   id3_tag_render(tp.get(), buffer.get());
 
   wxFFile f(fName.GetFullPath(), wxT("r+b"));
   if (f.IsOpened()) {
      wxUint32 sz;
 
      sz = (wxUint32) len;
      if (!f.SeekEnd(0))
         return false;
      if ((sf_format & SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV)
         {
            if (4 != f.Write("id3 ", 4))// Must be lower case for foobar2000.
               return false ;
         }
      else {
         if (4 != f.Write("ID3 ", 4))
            return false;
         sz = wxUINT32_SWAP_ON_LE(sz);
      }
      if (4 != f.Write(&sz, 4))
         return false;
 
      if (len != f.Write(buffer.get(), len))
         return false;
 
      sz = (wxUint32) f.Tell() - 8;
      if ((sf_format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AIFF)
         sz = wxUINT32_SWAP_ON_LE(sz);
 
      if (!f.Seek(4))
         return false;
      if (4 != f.Write(&sz, 4))
         return false;
 
      if (!f.Flush())
         return false;
 
      if (!f.Close())
         return false;
   }
   else
      return false;
#endif
   return true;
}

References f, fName, Tags::GetRange(), anonymous_namespace{ExportPCM.cpp}::name, sf_format, TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_GENRE, TAG_TITLE, TAG_TRACK, TAG_YEAR, and wxT().

Referenced by Process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddStrings()

void PCMExportProcessor::AddStrings	(	SNDFILE *	sf,
		const Tags *	tags,
		int	sf_format
	)

staticprivate

Definition at line 880 of file ExportPCM.cpp.

{
   if (tags->HasTag(TAG_TITLE)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_TITLE), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_TITLE, ascii7Str.get());
      }
   }
 
   if (tags->HasTag(TAG_ALBUM)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_ALBUM), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_ALBUM, ascii7Str.get());
      }
   }
 
   if (tags->HasTag(TAG_ARTIST)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_ARTIST), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_ARTIST, ascii7Str.get());
      }
   }
 
   if (tags->HasTag(TAG_COMMENTS)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_COMMENTS), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_COMMENT, ascii7Str.get());
      }
   }
 
   if (tags->HasTag(TAG_YEAR)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_YEAR), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_DATE, ascii7Str.get());
      }
   }
 
   if (tags->HasTag(TAG_GENRE)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_GENRE), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_GENRE, ascii7Str.get());
      }
   }
 
   if (tags->HasTag(TAG_COPYRIGHT)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_COPYRIGHT), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_COPYRIGHT, ascii7Str.get());
      }
   }
 
   if (tags->HasTag(TAG_SOFTWARE)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_SOFTWARE), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_SOFTWARE, ascii7Str.get());
      }
   }
 
   if (tags->HasTag(TAG_TRACK)) {
      auto ascii7Str = AdjustString(tags->GetTag(TAG_TRACK), sf_format);
      if (ascii7Str) {
         sf_set_string(sf, SF_STR_TRACKNUMBER, ascii7Str.get());
      }
   }
}

References AdjustString(), Tags::GetTag(), Tags::HasTag(), sf, sf_format, TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_COPYRIGHT, TAG_GENRE, TAG_SOFTWARE, TAG_TITLE, TAG_TRACK, and TAG_YEAR.

Referenced by Initialize(), and Process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AdjustString()

ArrayOf< char > PCMExportProcessor::AdjustString	(	const wxString &	wxStr,
		int	sf_format
	)

staticprivate

Definition at line 793 of file ExportPCM.cpp.

{
   bool b_aiff = false;
   if ((sf_format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AIFF)
         b_aiff = true;    // Apple AIFF file
 
   // We must convert the string to 7 bit ASCII
   size_t  sz = wxStr.length();
   if(sz == 0)
      return {};
   // Size for secure allocation in case of local wide char usage
   size_t  sr = (sz+4) * 2;
 
   ArrayOf<char> pDest{ sr, true };
   if (!pDest)
      return {};
   ArrayOf<char> pSrc{ sr, true };
   if (!pSrc)
      return {};
 
   if(wxStr.mb_str(wxConvISO8859_1))
      strncpy(pSrc.get(), wxStr.mb_str(wxConvISO8859_1), sz);
   else if(wxStr.mb_str())
      strncpy(pSrc.get(), wxStr.mb_str(), sz);
   else
      return {};
 
   char *pD = pDest.get();
   char *pS = pSrc.get();
   unsigned char c;
 
   // ISO Latin to 7 bit ascii conversion table (best approximation)
   static char aASCII7Table[256] = {
      0x00, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f,
      0x5f, 0x09, 0x0a, 0x5f, 0x0d, 0x5f, 0x5f, 0x5f,
      0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f,
      0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f,
      0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
      0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
      0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
      0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
      0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
      0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
      0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
      0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
      0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
      0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
      0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
      0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
      0x45, 0x20, 0x2c, 0x53, 0x22, 0x2e, 0x2b, 0x2b,
      0x5e, 0x25, 0x53, 0x28, 0x4f, 0x20, 0x5a, 0x20,
      0x20, 0x27, 0x27, 0x22, 0x22, 0x2e, 0x2d, 0x5f,
      0x22, 0x54, 0x73, 0x29, 0x6f, 0x20, 0x7a, 0x59,
      0x20, 0x21, 0x63, 0x4c, 0x6f, 0x59, 0x7c, 0x53,
      0x22, 0x43, 0x61, 0x22, 0x5f, 0x2d, 0x43, 0x2d,
      0x6f, 0x7e, 0x32, 0x33, 0x27, 0x75, 0x50, 0x27,
      0x2c, 0x31, 0x6f, 0x22, 0x5f, 0x5f, 0x5f, 0x3f,
      0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x43,
      0x45, 0x45, 0x45, 0x45, 0x49, 0x49, 0x49, 0x49,
      0x44, 0x4e, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x78,
      0x4f, 0x55, 0x55, 0x55, 0x55, 0x59, 0x70, 0x53,
      0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x63,
      0x65, 0x65, 0x65, 0x65, 0x69, 0x69, 0x69, 0x69,
      0x64, 0x6e, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x2f,
      0x6f, 0x75, 0x75, 0x75, 0x75, 0x79, 0x70, 0x79
   };
 
   size_t i;
   for(i = 0; i < sr; i++) {
      c = (unsigned char) *pS++;
      *pD++ = aASCII7Table[c];
      if(c == 0)
         break;
   }
   *pD = '\0';
 
   if(b_aiff) {
      int len = (int)strlen(pDest.get());
      if((len % 2) != 0) {
         // In case of an odd length string, add a space char
         strcat(pDest.get(), " ");
      }
   }
 
   return pDest;
}

References sf_format.

Referenced by AddStrings().

Here is the caller graph for this function:

◆ Initialize()

bool PCMExportProcessor::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 536 of file ExportPCM.cpp.

{
   context.t0 = t0;
   context.t1 = t1;
   context.fName = fName;
 
   const auto &tracks = TrackList::Get( project );
 
   // Set a default in case the settings aren't found
   int& sf_format = context.sf_format;
 
   switch (context.subformat)
   {
#if defined(__WXMAC__)
      case FMT_AIFF:
         sf_format = SF_FORMAT_AIFF;
      break;
#endif
 
      case FMT_WAV:
         sf_format = SF_FORMAT_WAV;
      break;
 
   default:
      // Retrieve the current format.
      sf_format = ExportPluginHelpers::GetParameterValue(parameters, OptionIDSFType, 0);
      break;
   }
 
   sf_format |= ExportPluginHelpers::GetParameterValue(parameters, sf_format, 0);
 
   // If subtype is still not specified, supply a default.
   if (!(sf_format & SF_FORMAT_SUBMASK))
   {
      sf_format |= SF_FORMAT_PCM_16;
   }
 
   int& fileFormat = context.fileFormat;
   fileFormat = sf_format & SF_FORMAT_TYPEMASK;
   
   {
      wxFile &f = context.f;
      SNDFILE* &sf = context.sf;
 
      wxString     formatStr;
      SF_INFO      &info = context.info;
      //int          err;
 
      //This whole operation should not occur while a file is being loaded on OD,
      //(we are worried about reading from a file being written to,) so we block.
      //Furthermore, we need to do this because libsndfile is not threadsafe.
      formatStr = SFCall<wxString>(sf_header_name, fileFormat);
 
      // Use libsndfile to export file
 
      info.samplerate = (unsigned int)(sampleRate + 0.5);
      info.frames = (unsigned int)((t1 - t0)*sampleRate + 0.5);
      info.channels = numChannels;
      info.format = sf_format;
      info.sections = 1;
      info.seekable = 0;
 
      // Bug 46.  Trap here, as sndfile.c does not trap it properly.
      if( (numChannels != 1) && ((sf_format & SF_FORMAT_SUBMASK) == SF_FORMAT_GSM610) )
      {
         throw ExportException(_("GSM 6.10 requires mono"));
      }
 
      if (sf_format == SF_FORMAT_WAVEX + SF_FORMAT_GSM610) {
         throw ExportException(_("WAVEX and GSM 6.10 formats are not compatible"));
      }
 
      // If we can't export exactly the format they requested,
      // try the default format for that header type...
      // 
      // LLL: I don't think this is valid since libsndfile checks
      // for all allowed subtypes explicitly and doesn't provide
      // for an unspecified subtype.
      if (!sf_format_check(&info))
         info.format = (info.format & SF_FORMAT_TYPEMASK);
      if (!sf_format_check(&info)) {
         throw ExportException(_("Cannot export audio in this format."));
      }
      const auto path = fName.GetFullPath();
      if (f.Open(path, wxFile::write)) {
         // Even though there is an sf_open() that takes a filename, use the one that
         // takes a file descriptor since wxWidgets can open a file with a Unicode name and
         // libsndfile can't (under Windows).
         sf = sf_open_fd(f.fd(), SFM_WRITE, &info, FALSE);
         //add clipping for integer formats.  We allow floats to clip.
         sf_command(sf, SFC_SET_CLIPPING, NULL, sf_subtype_is_integer(sf_format)?SF_TRUE:SF_FALSE) ;
      }
 
      if (!sf) {
         throw ExportException(_("Cannot export audio to %s").Format( path ));
      }
      // Retrieve tags if not given a set
      if (metadata == NULL)
         metadata = &Tags::Get( project );
 
      // Install the meta data at the beginning of the file (except for
      // WAV and WAVEX formats)
      if (fileFormat != SF_FORMAT_WAV &&
          fileFormat != SF_FORMAT_WAVEX) {
         AddStrings(sf, metadata, sf_format);
      }
      context.metadata = std::make_unique<Tags>(*metadata);
      
      if (sf_subtype_more_than_16_bits(info.format))
         context.format = floatSample;
      else
         context.format = int16Sample;
 
      // Bug 2200
      // Only trap size limit for file types we know have an upper size limit.
      // The error message mentions aiff and wav.
      if( (fileFormat == SF_FORMAT_WAV) ||
          (fileFormat == SF_FORMAT_WAVEX) ||
          (fileFormat == SF_FORMAT_AIFF ))
      {
         float sampleCount = (float)(t1-t0)*sampleRate*info.channels;
         float byteCount = sampleCount * sf_subtype_bytes_per_sample( info.format);
         // Test for 4 Gibibytes, rather than 4 Gigabytes
         if( byteCount > 4.295e9)
         {
            //Temporary translation hack, to say 'WAV or AIFF' rather than 'WAV'
            const auto message =
               XO("You have attempted to Export a WAV or AIFF file which would be greater than 4GB.\n"
               "Audacity cannot do this, the Export was abandoned.");
            throw ExportErrorException(message,
               wxT("Size_limits_for_WAV_and_AIFF_files"));
         }
      }
 
      
      context.status = (selectionOnly
         ? XO("Exporting the selected audio as %s")
         : XO("Exporting the audio as %s")).Format( formatStr );
 
      
      wxASSERT(info.channels >= 0);
      context.mixer = ExportPluginHelpers::CreateMixer(tracks, selectionOnly,
                               t0, t1,
                               info.channels, maxBlockLen, true,
                               sampleRate, context.format, mixerSpec);
   }
 
   return true;
}

References _, AddStrings(), context, ExportPluginHelpers::CreateMixer(), f, fileFormat, floatSample, anonymous_namespace{ExportPCM.cpp}::FMT_AIFF, anonymous_namespace{ExportPCM.cpp}::FMT_WAV, fName, Tags::Get(), TrackList::Get(), ExportPluginHelpers::GetParameterValue(), info, int16Sample, maxBlockLen, metadata, anonymous_namespace{ExportPCM.cpp}::OptionIDSFType, project, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, sf, sf_format, sf_header_name(), sf_subtype_bytes_per_sample(), sf_subtype_is_integer(), sf_subtype_more_than_16_bits(), t0, t1, tracks, wxT(), and XO().

Here is the call graph for this function:

◆ Process()

ExportResult PCMExportProcessor::Process ( ExportProcessorDelegate & delegate )

overridevirtual

Implements ExportProcessor.

Definition at line 692 of file ExportPCM.cpp.

{
   delegate.SetStatusString(context.status);
 
   auto exportResult = ExportResult::Success;
   
   {
      std::vector<char> dither;
      if ((context.info.format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_24) {
         dither.reserve(maxBlockLen * context.info.channels * SAMPLE_SIZE(int24Sample));
      }
 
      while (exportResult == ExportResult::Success) {
         sf_count_t samplesWritten;
         size_t numSamples = context.mixer->Process();
         if (numSamples == 0)
            break;
 
         auto mixed = context.mixer->GetBuffer();
 
         // Bug 1572: Not ideal, but it does add the desired dither
         if ((context.info.format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_24) {
            for (int c = 0; c < context.info.channels; ++c) {
               CopySamples(
                  mixed + (c * SAMPLE_SIZE(context.format)), context.format,
                  dither.data() + (c * SAMPLE_SIZE(int24Sample)), int24Sample,
                  numSamples, gHighQualityDither, context.info.channels, context.info.channels
               );
               // Copy back without dither
               CopySamples(
                  dither.data() + (c * SAMPLE_SIZE(int24Sample)), int24Sample,
                  const_cast<samplePtr>(mixed) // PRL fix this!
                     + (c * SAMPLE_SIZE(context.format)), context.format,
                  numSamples, DitherType::none, context.info.channels, context.info.channels);
            }
         }
 
         if (context.format == int16Sample)
            samplesWritten = SFCall<sf_count_t>(sf_writef_short, context.sf, (const short *)mixed, numSamples);
         else
            samplesWritten = SFCall<sf_count_t>(sf_writef_float, context.sf, (const float *)mixed, numSamples);
 
         if (static_cast<size_t>(samplesWritten) != numSamples) {
            char buffer2[1000];
            sf_error_str(context.sf, buffer2, 1000);
            //Used to give this error message
#if 0
            AudacityMessageBox(
               XO(
               /* i18n-hint: %s will be the error message from libsndfile, which
                * is usually something unhelpful (and untranslated) like "system
                * error" */
"Error while writing %s file (disk full?).\nLibsndfile says \"%s\"")
                  .Format( formatStr, wxString::FromAscii(buffer2) ));
#else
            // But better to give the same error message as for
            // other cases of disk exhaustion.
            // The thrown exception doesn't escape but GuardedCall
            // will enqueue a message.
            GuardedCall([&]{
               throw FileException{
                  FileException::Cause::Write, context.fName }; });
#endif
            exportResult = ExportResult::Error;
            break;
         }
         if(exportResult == ExportResult::Success)
            exportResult = ExportPluginHelpers::UpdateProgress(
               delegate, *context.mixer, context.t0, context.t1);
      }
   }
   
   // Install the WAV metata in a "LIST" chunk at the end of the file
   if (exportResult != ExportResult::Cancelled && exportResult != ExportResult::Error) {
      if (context.fileFormat == SF_FORMAT_WAV ||
          context.fileFormat == SF_FORMAT_WAVEX) {
         AddStrings(context.sf, context.metadata.get(), context.sf_format);
      }
   }
 
   if (0 != sf_close(context.sf)) {
      // TODO: more precise message
      throw ExportErrorException("PCM:681");
   }
 
   context.sf = nullptr;
   context.f.Close();
 
   if (exportResult != ExportResult::Cancelled && exportResult != ExportResult::Error)
   {
      if ((context.fileFormat == SF_FORMAT_AIFF) ||
          (context.fileFormat == SF_FORMAT_WAV))
         // Note: file has closed, and gets reopened and closed again here:
         if (!AddID3Chunk(context.fName, context.metadata.get(), context.sf_format) ) {
            // TODO: more precise message
            throw ExportErrorException("PCM:694");
         }
   }
   return exportResult;
}