Performs actual export. More...

Collaboration diagram for FFmpegExporter:

Public Member Functions
	FFmpegExporter (std::shared_ptr< FFmpegFunctions > ffmpeg, const wxFileNameWrapper &filename, int numChannels, int subformat)

bool	Init (const char shortname, AudacityProject project, int sampleRate, const Tags *metadata, const ExportProcessor::Parameters &parameters)
	Format initialization. More...

bool	EncodeAudioFrame (int16_t *pFrame, size_t frameSize)
	Encodes audio. More...

bool	Finalize ()
	Flushes audio encoder. More...

std::unique_ptr< Mixer >	CreateMixer (const AudacityProject &project, bool selectionOnly, double startTime, double stopTime, MixerOptions::Downmix *mixerSpec)

Private Member Functions
bool	AddTags (const Tags *metadata)
	Writes metadata. More...

void	SetMetadata (const Tags tags, const char name, const wxChar *tag)
	Sets individual metadata values. More...

bool	CheckSampleRate (int rate, int lowrate, int highrate, const int *sampRates)
	Check whether or not current project sample rate is compatible with the export codec. More...

int	AskResample (int bitrate, int rate, int lowrate, int highrate, const int *sampRates)
	Asks user to resample the project or cancel the export procedure. More...

bool	InitCodecs (int sampleRate, const ExportProcessor::Parameters &parameters)
	Codec initialization. More...

void	WritePacket (AVPacketWrapper &packet)

int	EncodeAudio (AVPacketWrapper &pkt, int16_t *audio_samples, int nb_samples)

Private Attributes
std::shared_ptr< FFmpegFunctions >	mFFmpeg

std::unique_ptr< AVOutputFormatWrapper >	mEncFormatDesc

int	mDefaultFrameSize {}

std::unique_ptr< AVStreamWrapper >	mEncAudioStream

int	mEncAudioFifoOutBufSize {}

wxFileNameWrapper	mName

int	mSubFormat {}

int	mBitRate {}

int	mSampleRate {}

unsigned	mChannels {}

bool	mSupportsUTF8 {true}

std::unique_ptr< FifoBuffer >	mEncAudioFifo

AVDataBuffer< int16_t >	mEncAudioFifoOutBuf

std::unique_ptr< AVFormatContextWrapper >	mEncFormatCtx

std::unique_ptr< AVCodecContextWrapper >	mEncAudioCodecCtx

Static Private Attributes
static constexpr auto	MaxAudioPacketSize { 128 * 1024 }

Detailed Description

Performs actual export.

Definition at line 588 of file ExportFFmpeg.cpp.

Constructor & Destructor Documentation

◆ FFmpegExporter()

FFmpegExporter::FFmpegExporter	(	std::shared_ptr< FFmpegFunctions >	ffmpeg,
		const wxFileNameWrapper &	filename,
		int	numChannels,
		int	subformat
	)

Definition at line 714 of file ExportFFmpeg.cpp.

   : mFFmpeg(std::move(ffmpeg))
   , mName(filename)
   , mChannels(numChannels)
   , mSubFormat(subFormat)
{
   if (!mFFmpeg) {
      mFFmpeg = FFmpegFunctions::Load();
   }
}

References FFmpegFunctions::Load(), and mFFmpeg.

Here is the call graph for this function:

Member Function Documentation

◆ AddTags()

bool FFmpegExporter::AddTags ( const Tags * metadata )

private

Writes metadata.

Definition at line 1694 of file ExportFFmpeg.cpp.

{
   if (tags == NULL)
   {
      return false;
   }
 
   SetMetadata(tags, "album", TAG_ALBUM);
   SetMetadata(tags, "comment", TAG_COMMENTS);
   SetMetadata(tags, "genre", TAG_GENRE);
   SetMetadata(tags, "title", TAG_TITLE);
   SetMetadata(tags, "track", TAG_TRACK);
 
   // Bug 2564: Add m4a tags
   if (mEncFormatDesc->GetAudioCodec() == mFFmpeg->GetAVCodecID(AUDACITY_AV_CODEC_ID_AAC))
   {
      SetMetadata(tags, "artist", TAG_ARTIST);
      SetMetadata(tags, "date", TAG_YEAR);
   }
   else
   {
      SetMetadata(tags, "author", TAG_ARTIST);
      SetMetadata(tags, "year", TAG_YEAR);
   }
 
   return true;
}

References AUDACITY_AV_CODEC_ID_AAC, mEncFormatDesc, mFFmpeg, SetMetadata(), TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_GENRE, TAG_TITLE, TAG_TRACK, and TAG_YEAR.

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AskResample()

int FFmpegExporter::AskResample	(	int	bitrate,
		int	rate,
		int	lowrate,
		int	highrate,
		const int *	sampRates
	)

private

Asks user to resample the project or cancel the export procedure.

Definition at line 1740 of file ExportFFmpeg.cpp.

{
#if defined(FFMPEG_AUTO_RESAMPLE)
   std::vector<int> rates;
 
   for (int i = 0; sampRates[i]; ++i)
   {
      rates.push_back(sampRates[i]);
   }
 
   std::sort(rates.begin(), rates.end());
 
   int bestRate = 0;
   for (auto i : rates)
   {
      bestRate = i;
      if (i > rate)
      {
         break;
      }
   }
 
   return bestRate;
#else
   wxDialogWrapper d(nullptr, wxID_ANY, XO("Invalid sample rate"));
   d.SetName();
   wxChoice *choice;
   ShuttleGui S(&d, eIsCreating);
 
   int selected = -1;
 
   S.StartVerticalLay();
   {
      S.SetBorder(10);
      S.StartStatic(XO("Resample"));
      {
         S.StartHorizontalLay(wxALIGN_CENTER, false);
         {
            S.AddTitle(
               (bitrate == 0
                  ? XO(
"The project sample rate (%d) is not supported by the current output\nfile format. ")
                       .Format( rate )
                  : XO(
"The project sample rate (%d) and bit rate (%d kbps) combination is not\nsupported by the current output file format. ")
                       .Format( rate, bitrate/1000))
               + XO("You may resample to one of the rates below.")
            );
         }
         S.EndHorizontalLay();
 
         S.StartHorizontalLay(wxALIGN_CENTER, false);
         {
            choice = S.AddChoice(XO("Sample Rates"),
               [&]{
                  TranslatableStrings choices;
                  for (int i = 0; sampRates[i] > 0; i++)
                  {
                     int label = sampRates[i];
                     if ((!lowrate || label >= lowrate) && (!highrate || label <= highrate))
                     {
                        wxString name = wxString::Format(wxT("%d"),label);
                        choices.push_back( Verbatim( name ) );
                        if (label <= rate)
                           selected = i;
                     }
                  }
                  return choices;
               }(),
               std::max( 0, selected )
            );
         }
         S.EndHorizontalLay();
      }
      S.EndStatic();
 
      S.AddStandardButtons();
   }
   S.EndVerticalLay();
 
   d.Layout();
   d.Fit();
   d.SetMinSize(d.GetSize());
   d.Center();
 
   if (d.ShowModal() == wxID_CANCEL) {
      return 0;
   }
 
   return wxAtoi(choice->GetStringSelection());
#endif
}

References eIsCreating, label, name, S, sampRates, wxDialogWrapper::SetName(), Verbatim(), wxT(), and XO().

Referenced by InitCodecs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CheckSampleRate()

bool FFmpegExporter::CheckSampleRate	(	int	rate,
		int	lowrate,
		int	highrate,
		const int *	sampRates
	)

private

Check whether or not current project sample rate is compatible with the export codec.

Definition at line 956 of file ExportFFmpeg.cpp.

{
   if (lowrate && highrate)
   {
      if (rate < lowrate || rate > highrate)
      {
         return false;
      }
   }
 
   if (sampRates)
   {
      for (int i = 0; sampRates[i] > 0; i++)
      {
         if (rate == sampRates[i])
         {
            return true;
         }
      }
   }
 
   return false;
}

References sampRates.

Referenced by InitCodecs().

Here is the caller graph for this function:

◆ CreateMixer()

std::unique_ptr< Mixer > FFmpegExporter::CreateMixer	(	const AudacityProject &	project,
		bool	selectionOnly,
		double	startTime,
		double	stopTime,
		MixerOptions::Downmix *	mixerSpec
	)

Definition at line 728 of file ExportFFmpeg.cpp.

{
   return ExportPluginHelpers::CreateMixer(
      project, selectionOnly, startTime, stopTime, mChannels, mDefaultFrameSize,
      true, mSampleRate, int16Sample, mixerSpec);
}

References ExportPluginHelpers::CreateMixer(), int16Sample, mChannels, mDefaultFrameSize, mSampleRate, and project.

Here is the call graph for this function:

◆ EncodeAudio()

int FFmpegExporter::EncodeAudio	(	AVPacketWrapper &	pkt,
		int16_t *	audio_samples,
		int	nb_samples
	)

private

Definition at line 1331 of file ExportFFmpeg.cpp.

{
   // Assume *pkt is already initialized.
 
   int i, ch, buffer_size, ret, got_output = 0;
   AVDataBuffer<uint8_t> samples;
 
   std::unique_ptr<AVFrameWrapper> frame;
 
   if (audio_samples) {
      frame = mFFmpeg->CreateAVFrameWrapper();
 
      if (!frame)
         return AUDACITY_AVERROR(ENOMEM);
 
      frame->SetSamplesCount(nb_samples);
      frame->SetFormat(mEncAudioCodecCtx->GetSampleFmt());
      frame->SetChannelLayout(mEncAudioCodecCtx->GetChannelLayout());
 
      buffer_size = mFFmpeg->av_samples_get_buffer_size(
         NULL, mEncAudioCodecCtx->GetChannels(), nb_samples,
         mEncAudioCodecCtx->GetSampleFmt(), 0);
 
      if (buffer_size < 0) {
         throw ExportException(_("FFmpeg : ERROR - Could not get sample buffer size"));
      }
 
      samples = mFFmpeg->CreateMemoryBuffer<uint8_t>(buffer_size);
 
      if (samples.empty()) {
         throw ExportException(_("FFmpeg : ERROR - Could not allocate bytes for samples buffer"));
      }
      /* setup the data pointers in the AVFrame */
      ret = mFFmpeg->avcodec_fill_audio_frame(
         frame->GetWrappedValue(), mEncAudioCodecCtx->GetChannels(),
         mEncAudioCodecCtx->GetSampleFmt(), samples.data(), buffer_size, 0);
 
      if (ret < 0) {
         throw ExportException(_("FFmpeg : ERROR - Could not setup audio frame"));
      }
 
      const int channelsCount = mEncAudioCodecCtx->GetChannels();
 
      for (ch = 0; ch < mEncAudioCodecCtx->GetChannels(); ch++)
      {
         for (i = 0; i < nb_samples; i++) {
            switch (static_cast<AudacityAVSampleFormat>(
               mEncAudioCodecCtx->GetSampleFmt()))
            {
            case AUDACITY_AV_SAMPLE_FMT_U8:
               ((uint8_t*)(frame->GetData(0)))[ch + i*channelsCount] = audio_samples[ch + i*channelsCount]/258 + 128;
               break;
            case AUDACITY_AV_SAMPLE_FMT_U8P:
               ((uint8_t*)(frame->GetData(ch)))[i] = audio_samples[ch + i*channelsCount]/258 + 128;
               break;
            case AUDACITY_AV_SAMPLE_FMT_S16:
               ((int16_t*)(frame->GetData(0)))[ch + i*channelsCount] = audio_samples[ch + i*channelsCount];
               break;
            case AUDACITY_AV_SAMPLE_FMT_S16P:
               ((int16_t*)(frame->GetData(ch)))[i] = audio_samples[ch + i*channelsCount];
               break;
            case AUDACITY_AV_SAMPLE_FMT_S32:
               ((int32_t*)(frame->GetData(0)))[ch + i*channelsCount] = audio_samples[ch + i*channelsCount]<<16;
               break;
            case AUDACITY_AV_SAMPLE_FMT_S32P:
               ((int32_t*)(frame->GetData(ch)))[i] = audio_samples[ch + i*channelsCount]<<16;
               break;
            case AUDACITY_AV_SAMPLE_FMT_FLT:
               ((float*)(frame->GetData(0)))[ch + i*channelsCount] = audio_samples[ch + i*channelsCount] / 32767.0;
               break;
            case AUDACITY_AV_SAMPLE_FMT_FLTP:
               ((float*)(frame->GetData(ch)))[i] = audio_samples[ch + i*channelsCount] / 32767.;
               break;
            default:
               wxASSERT(false);
               break;
            }
         }
      }
   }
 
   pkt.ResetData();
 
   pkt.SetStreamIndex(mEncAudioStream->GetIndex());
 
   if (mFFmpeg->avcodec_send_frame != nullptr)
   {
      ret = mFFmpeg->avcodec_send_frame(
         mEncAudioCodecCtx->GetWrappedValue(),
         frame ? frame->GetWrappedValue() : nullptr);
 
      while (ret >= 0)
      {
         ret = mFFmpeg->avcodec_receive_packet(
            mEncAudioCodecCtx->GetWrappedValue(), pkt.GetWrappedValue());
 
         if (ret == AUDACITY_AVERROR(EAGAIN) || ret == AUDACITY_AVERROR_EOF)
         {
            ret = 0;
            break;
         }
         else if (ret < 0)
            break;
 
         WritePacket(pkt);
 
         got_output = true;
      }
   }
   else
   {
      ret = mFFmpeg->avcodec_encode_audio2(
         mEncAudioCodecCtx->GetWrappedValue(), pkt.GetWrappedValue(),
         frame ? frame->GetWrappedValue() : nullptr, &got_output);
 
      if (ret == 0)
      {
         WritePacket(pkt);
      }
   }
 
   if (ret < 0 && ret != AUDACITY_AVERROR_EOF) {
 
      char buf[64];
      mFFmpeg->av_strerror(ret, buf, sizeof(buf));
      wxLogDebug(buf);
 
      throw ExportException(_("FFmpeg : ERROR - encoding frame failed"));
   }
 
   pkt.ResetTimestamps(); // We don't set frame timestamps thus don't trust the AVPacket timestamps
 
   return got_output;
}

References _, AUDACITY_AV_SAMPLE_FMT_FLT, AUDACITY_AV_SAMPLE_FMT_FLTP, AUDACITY_AV_SAMPLE_FMT_S16, AUDACITY_AV_SAMPLE_FMT_S16P, AUDACITY_AV_SAMPLE_FMT_S32, AUDACITY_AV_SAMPLE_FMT_S32P, AUDACITY_AV_SAMPLE_FMT_U8, AUDACITY_AV_SAMPLE_FMT_U8P, AUDACITY_AVERROR, AUDACITY_AVERROR_EOF, AVPacketWrapper::GetWrappedValue(), mEncAudioCodecCtx, mEncAudioStream, mFFmpeg, AVPacketWrapper::ResetData(), AVPacketWrapper::ResetTimestamps(), AVPacketWrapper::SetStreamIndex(), and WritePacket().

Referenced by EncodeAudioFrame(), and Finalize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EncodeAudioFrame()

bool FFmpegExporter::EncodeAudioFrame	(	int16_t *	pFrame,
		size_t	frameSize
	)

Encodes audio.

Definition at line 1549 of file ExportFFmpeg.cpp.

{
   const auto frameSize = numSamples * sizeof(int16_t) *  mChannels;
   int nBytesToWrite = 0;
   uint8_t *pRawSamples = nullptr;
   int nAudioFrameSizeOut = mDefaultFrameSize * mEncAudioCodecCtx->GetChannels() * sizeof(int16_t);
   int ret;
 
   nBytesToWrite = frameSize;
   pRawSamples  = (uint8_t*)pFrame;
 
   // Put the raw audio samples into the FIFO.
   ret = mEncAudioFifo->Write(pRawSamples, nBytesToWrite);
 
   if (ret != nBytesToWrite) {
      throw ExportErrorException("FFmpeg:913");
   }
 
   if (nAudioFrameSizeOut > mEncAudioFifoOutBufSize) {
      throw ExportException(_("FFmpeg : ERROR - nAudioFrameSizeOut too large."));
   }
 
   // Read raw audio samples out of the FIFO in nAudioFrameSizeOut byte-sized groups to encode.
   while (mEncAudioFifo->GetAvailable() >= nAudioFrameSizeOut)
   {
      mEncAudioFifo->Read(
         mEncAudioFifoOutBuf.data(), nAudioFrameSizeOut);
 
      std::unique_ptr<AVPacketWrapper> pkt = mFFmpeg->CreateAVPacketWrapper();
 
      ret = EncodeAudio(*pkt,                       // out
         mEncAudioFifoOutBuf.data(), // in
         mDefaultFrameSize);
 
      if (ret < 0)
         return false;
   }
   return true;
}

References _, EncodeAudio(), mChannels, mDefaultFrameSize, mEncAudioCodecCtx, mEncAudioFifo, mEncAudioFifoOutBuf, mEncAudioFifoOutBufSize, and mFFmpeg.

Here is the call graph for this function:

◆ Finalize()

bool FFmpegExporter::Finalize ( )

Flushes audio encoder.

Definition at line 1467 of file ExportFFmpeg.cpp.

{
   // Flush the audio FIFO and encoder.
   for (;;)
   {
      std::unique_ptr<AVPacketWrapper> pkt = mFFmpeg->CreateAVPacketWrapper();
 
      const auto nFifoBytes =
         mEncAudioFifo->GetAvailable(); // any bytes left in audio FIFO?
 
      int encodeResult = 0;
 
      // Flush the audio FIFO first if necessary. It won't contain a _full_ audio frame because
      // if it did we'd have pulled it from the FIFO during the last encodeAudioFrame() call
      if (nFifoBytes > 0)
      {
         const int nAudioFrameSizeOut = mDefaultFrameSize * mEncAudioCodecCtx->GetChannels() * sizeof(int16_t);
 
         if (nAudioFrameSizeOut > mEncAudioFifoOutBufSize || nFifoBytes > mEncAudioFifoOutBufSize) {
            throw ExportException(_("FFmpeg : ERROR - Too much remaining data."));
         }
 
         // We have an incomplete buffer of samples left, encode it.
         // If codec supports CODEC_CAP_SMALL_LAST_FRAME, we can feed it with smaller frame
         // Or if frame_size is 1, then it's some kind of PCM codec, they don't have frames and will be fine with the samples
         // Otherwise we'll send a full frame of audio + silence padding to ensure all audio is encoded
         int frame_size = mDefaultFrameSize;
         if (
            mEncAudioCodecCtx->GetCodec()->GetCapabilities() &
               AUDACITY_AV_CODEC_CAP_SMALL_LAST_FRAME ||
            frame_size == 1)
         {
            frame_size = nFifoBytes /
                         (mEncAudioCodecCtx->GetChannels() * sizeof(int16_t));
         }
 
         wxLogDebug(wxT("FFmpeg : Audio FIFO still contains %lld bytes, writing %d sample frame ..."),
            nFifoBytes, frame_size);
 
         // Fill audio buffer with zeroes. If codec tries to read the whole buffer,
         // it will just read silence. If not - who cares?
         memset(mEncAudioFifoOutBuf.data(), 0, mEncAudioFifoOutBufSize);
         //const AVCodec *codec = mEncAudioCodecCtx->codec;
 
         // Pull the bytes out from the FIFO and feed them to the encoder.
         if (mEncAudioFifo->Read(mEncAudioFifoOutBuf.data(), nFifoBytes) == nFifoBytes)
         {
            encodeResult = EncodeAudio(*pkt, mEncAudioFifoOutBuf.data(), frame_size);
         }
         else
         {
            wxLogDebug(wxT("FFmpeg : Reading from Audio FIFO failed, aborting"));
            // TODO: more precise message
            throw ExportErrorException("FFmpeg:825");
         }
      }
      else
      {
         // Fifo is empty, flush encoder. May be called multiple times.
         encodeResult =
            EncodeAudio(*pkt.get(), nullptr, 0);
      }
 
      if (encodeResult < 0) {
         // TODO: more precise message
         throw ExportErrorException("FFmpeg:837");
      }
      else if (encodeResult == 0)
         break;
   }
 
   // Write any file trailers.
   if (mFFmpeg->av_write_trailer(mEncFormatCtx->GetWrappedValue()) != 0)
   {
      // TODO: more precise message
      throw ExportErrorException("FFmpeg:868");
   }
 
   return true;
}

References _, AUDACITY_AV_CODEC_CAP_SMALL_LAST_FRAME, EncodeAudio(), mDefaultFrameSize, mEncAudioCodecCtx, mEncAudioFifo, mEncAudioFifoOutBuf, mEncAudioFifoOutBufSize, mEncFormatCtx, mFFmpeg, and wxT().

Here is the call graph for this function:

◆ Init()

bool FFmpegExporter::Init	(	const char *	shortname,
		AudacityProject *	project,
		int	sampleRate,
		const Tags *	metadata,
		const ExportProcessor::Parameters &	parameters
	)

Format initialization.

Definition at line 859 of file ExportFFmpeg.cpp.

{
   if (!mFFmpeg)
      return false;
 
   // See if libavformat has modules that can write our output format. If so, mEncFormatDesc
   // will describe the functions used to write the format (used internally by libavformat)
   // and the default video/audio codecs that the format uses.
   const auto path = mName.GetFullPath();
   if ((mEncFormatDesc = mFFmpeg->GuessOutputFormat(shortname, OSINPUT(path), nullptr)) == nullptr)
   {
      throw ExportException(_("FFmpeg : ERROR - Can't determine format description for file \"%s\".").Format(path));
   }
 
   // mEncFormatCtx is used by libavformat to carry around context data re our output file.
   mEncFormatCtx = mFFmpeg->CreateAVFormatContext();
   if (!mEncFormatCtx)
   {
      throw ExportException(_("FFmpeg : ERROR - Can't allocate output format context."));
   }
 
   // Initialise the output format context.
   mEncFormatCtx->SetOutputFormat(mFFmpeg->CreateAVOutputFormatWrapper(mEncFormatDesc->GetWrappedValue()));
   mEncFormatCtx->SetFilename(OSINPUT(path));
 
   // At the moment Audacity can export only one audio stream
   if ((mEncAudioStream = mEncFormatCtx->CreateStream()) == nullptr)
   {
      throw ExportException(_("FFmpeg : ERROR - Can't add audio stream to output file \"%s\"."));
   }
 
   // Documentation for avformat_new_stream says
   // "User is required to call avcodec_close() and avformat_free_context() to clean
   // up the allocation by avformat_new_stream()."
 
   // We use smart pointers that ensure these cleanups either in their destructors or
   // sooner if they are reset.  These are std::unique_ptr with nondefault deleter
   // template parameters.
 
   // mEncFormatCtx takes care of avformat_free_context(), so
   // mEncAudioStream can be a plain pointer.
 
   // mEncAudioCodecCtx now becomes responsible for closing the codec:
   mEncAudioCodecCtx = mEncAudioStream->GetAVCodecContext();
   mEncAudioStream->SetId(0);
 
   // Open the output file.
   if (!(mEncFormatDesc->GetFlags() & AUDACITY_AVFMT_NOFILE))
   {
      AVIOContextWrapper::OpenResult result =
         mEncFormatCtx->OpenOutputContext(path);
 
      if (result != AVIOContextWrapper::OpenResult::Success)
      {
         throw ExportException(_("FFmpeg : ERROR - Can't open output file \"%s\" to write. Error code is %d.")
            .Format(path, static_cast<int>(result)));
      }
   }
 
   // Open the audio stream's codec and initialise any stream related data.
   if(!InitCodecs(sampleRate, parameters))
      return false;
 
   if (mEncAudioStream->SetParametersFromContext(*mEncAudioCodecCtx) < 0)
      return false;
 
   if (metadata == NULL)
      metadata = &Tags::Get( *project );
 
   // Add metadata BEFORE writing the header.
   // At the moment that works with ffmpeg-git and ffmpeg-0.5 for MP4.
   const auto canmeta = ExportFFmpegOptions::fmts[mSubFormat].canmetadata;
   const auto avfver = mFFmpeg->AVFormatVersion.GetIntVersion();
   if (canmeta && (canmeta == AV_CANMETA || canmeta <= avfver))
   {
      mSupportsUTF8 = ExportFFmpegOptions::fmts[mSubFormat].canutf8;
      AddTags(metadata);
   }
 
   // Write headers to the output file.
   int err =
      mFFmpeg->avformat_write_header(mEncFormatCtx->GetWrappedValue(), nullptr);
 
   if (err < 0)
   {
      throw ExportException(XO("FFmpeg : ERROR - Can't write headers to output file \"%s\". Error code is %d.")
         .Format( path, err )
         .Translation());
   }
 
   return true;
}

References _, AddTags(), AUDACITY_AVFMT_NOFILE, AV_CANMETA, ExposedFormat::canmetadata, ExposedFormat::canutf8, ExportFFmpegOptions::fmts, Tags::Get(), InitCodecs(), mEncAudioCodecCtx, mEncAudioStream, mEncFormatCtx, mEncFormatDesc, mFFmpeg, mName, mSubFormat, mSupportsUTF8, OSINPUT, project, anonymous_namespace{ClipSegmentTest.cpp}::sampleRate, AVIOContextWrapper::Success, and XO().

Here is the call graph for this function:

◆ InitCodecs()

bool FFmpegExporter::InitCodecs	(	int	sampleRate,
		const ExportProcessor::Parameters &	parameters
	)

private

Codec initialization.

Definition at line 980 of file ExportFFmpeg.cpp.

{
   std::unique_ptr<AVCodecWrapper> codec;
 
   AVDictionaryWrapper options(*mFFmpeg);
 
   // Get the sample rate from the passed settings if we haven't set it before.
   // Doing this only when not set allows us to carry the sample rate from one
   // iteration of ExportMultiple to the next.  This prevents multiple resampling
   // dialogs in the event the codec can't support the specified rate.
   if (!mSampleRate)
   {
      //TODO: Does not work with export multiple any more...
      mSampleRate = sampleRate;
   }
 
   // Configure the audio stream's codec context.
 
   const auto codecID = ExportFFmpegOptions::fmts[mSubFormat].codecid;
 
   mEncAudioCodecCtx->SetGlobalQuality(-99999); //quality mode is off by default;
 
   // Each export type has its own settings
   switch (mSubFormat)
   {
   case FMT_M4A:
   {
      int q = ExportPluginHelpers::GetParameterValue(parameters, AACOptionIDQuality, -99999);
 
      q = wxClip( q, 98 * mChannels, 160 * mChannels );
      // Set bit rate to between 98 kbps and 320 kbps (if two channels)
      mEncAudioCodecCtx->SetBitRate(q * 1000);
      mEncAudioCodecCtx->SetProfile(AUDACITY_FF_PROFILE_AAC_LOW);
      mEncAudioCodecCtx->SetCutoff(0);
 
      break;
   }
   case FMT_AC3:
      mEncAudioCodecCtx->SetBitRate(ExportPluginHelpers::GetParameterValue(parameters, AC3OptionIDBitRate, 192000));
      if (!CheckSampleRate(
             mSampleRate, iAC3SampleRates[0],
             iAC3SampleRates[2],
             &iAC3SampleRates[0]))
      {
         mSampleRate = AskResample(
            mEncAudioCodecCtx->GetBitRate(), mSampleRate,
            iAC3SampleRates[0],
            iAC3SampleRates[2],
            &iAC3SampleRates[0]);
      }
      break;
   case FMT_AMRNB:
      mSampleRate = 8000;
      mEncAudioCodecCtx->SetBitRate(ExportPluginHelpers::GetParameterValue(parameters, AMRNBOptionIDBitRate, 12200));
      break;
#ifdef SHOW_FFMPEG_OPUS_EXPORT
   case FMT_OPUS:
      options.Set("b", ExportPluginHelpers::GetParameterValue<std::string>(parameters, OPUSOptionIDBitRate, "128000"), 0);
      options.Set("vbr", ExportPluginHelpers::GetParameterValue<std::string>(parameters, OPUSOptionIDVBRMode, "on"), 0);
      options.Set("compression_level", ExportPluginHelpers::GetParameterValue<std::string>(parameters, OPUSOptionIDCompression, "10"), 0);
      options.Set("frame_duration", ExportPluginHelpers::GetParameterValue<std::string>(parameters, OPUSOptionIDFrameDuration, "20"), 0);
      options.Set("application", ExportPluginHelpers::GetParameterValue<std::string>(parameters, OPUSOptionIDApplication, "audio"), 0);
      options.Set("cutoff", ExportPluginHelpers::GetParameterValue<std::string>(parameters, OPUSOptionIDCutoff, "0"), 0);
      options.Set("mapping_family", mChannels <= 2 ? "0" : "255", 0);
      break;
#endif
   case FMT_WMA2:
      mEncAudioCodecCtx->SetBitRate(ExportPluginHelpers::GetParameterValue(parameters, WMAOptionIDBitRate, 198000));
      if (!CheckSampleRate(
             mSampleRate, iWMASampleRates[0],
             iWMASampleRates[4],
             &iWMASampleRates[0]))
      {
         mSampleRate = AskResample(
            mEncAudioCodecCtx->GetBitRate(), mSampleRate,
            iWMASampleRates[0],
            iWMASampleRates[4],
            &iWMASampleRates[0]);
      }
      break;
   case FMT_OTHER:
   {
      AVDictionaryWrapper streamMetadata = mEncAudioStream->GetMetadata();
      streamMetadata.Set(
         "language",
         ExportPluginHelpers::GetParameterValue<std::string>(parameters, FELanguageID), 0);
 
      mEncAudioStream->SetMetadata(streamMetadata);
 
      mEncAudioCodecCtx->SetSampleRate(
         ExportPluginHelpers::GetParameterValue(parameters, FESampleRateID, 0));
 
      if (mEncAudioCodecCtx->GetSampleRate() != 0)
         mSampleRate = mEncAudioCodecCtx->GetSampleRate();
 
      mEncAudioCodecCtx->SetBitRate(
         ExportPluginHelpers::GetParameterValue(parameters, FEBitrateID, 0));
 
      mEncAudioCodecCtx->SetCodecTagFourCC(
         ExportPluginHelpers::GetParameterValue<std::string>(parameters, FETagID).c_str());
 
      mEncAudioCodecCtx->SetGlobalQuality(
         ExportPluginHelpers::GetParameterValue(parameters, FEQualityID, -99999));
      mEncAudioCodecCtx->SetCutoff(
         ExportPluginHelpers::GetParameterValue(parameters, FECutoffID, 0));
      mEncAudioCodecCtx->SetFlags2(0);
 
      if (ExportPluginHelpers::GetParameterValue(parameters, FEBitReservoirID, true))
         options.Set("reservoir", "1", 0);
 
      if (ExportPluginHelpers::GetParameterValue(parameters, FEVariableBlockLenID, true))
         mEncAudioCodecCtx->SetFlags2(
            mEncAudioCodecCtx->GetFlags2() | 0x0004); // WMA only?
 
      mEncAudioCodecCtx->SetCompressionLevel(
         ExportPluginHelpers::GetParameterValue(parameters, FECompLevelID, -1));
      mEncAudioCodecCtx->SetFrameSize(
         ExportPluginHelpers::GetParameterValue(parameters, FEFrameSizeID, 0));
 
      // FIXME The list of supported options for the selected encoder should be
      // extracted instead of a few hardcoded
 
      options.Set(
         "lpc_coeff_precision",
         ExportPluginHelpers::GetParameterValue(parameters, FELPCCoeffsID, 0));
      options.Set(
         "min_prediction_order",
         ExportPluginHelpers::GetParameterValue(parameters, FEMinPredID, -1));
      options.Set(
         "max_prediction_order",
         ExportPluginHelpers::GetParameterValue(parameters, FEMaxPredID, -1));
      options.Set(
         "min_partition_order",
         ExportPluginHelpers::GetParameterValue(parameters, FEMinPartOrderID, -1));
      options.Set(
         "max_partition_order",
         ExportPluginHelpers::GetParameterValue(parameters, FEMaxPartOrderID, -1));
      options.Set(
         "prediction_order_method",
         ExportPluginHelpers::GetParameterValue(parameters, FEPredOrderID, 0));
      options.Set(
         "muxrate",
         ExportPluginHelpers::GetParameterValue(parameters, FEMuxRateID, 0));
 
      mEncFormatCtx->SetPacketSize(
         ExportPluginHelpers::GetParameterValue(parameters, FEPacketSizeID, 0));
 
      codec = mFFmpeg->CreateEncoder(
         ExportPluginHelpers::GetParameterValue<std::string>(parameters, FECodecID).c_str());
 
      if (!codec)
         codec = mFFmpeg->CreateEncoder(mEncFormatDesc->GetAudioCodec());
   }
      break;
   default:
      return false;
   }
 
   // This happens if user refused to resample the project
   if (mSampleRate == 0) return false;
 
   if (mEncAudioCodecCtx->GetGlobalQuality() >= 0)
   {
      mEncAudioCodecCtx->SetFlags(
         mEncAudioCodecCtx->GetFlags() | AUDACITY_AV_CODEC_FLAG_QSCALE);
   }
   else
   {
      mEncAudioCodecCtx->SetGlobalQuality(0);
   }
 
   mEncAudioCodecCtx->SetGlobalQuality(mEncAudioCodecCtx->GetGlobalQuality() * AUDACITY_FF_QP2LAMBDA);
   mEncAudioCodecCtx->SetSampleRate(mSampleRate);
   mEncAudioCodecCtx->SetChannelLayout(mFFmpeg->CreateDefaultChannelLayout(mChannels).get());
   mEncAudioCodecCtx->SetTimeBase({ 1, mSampleRate });
   mEncAudioCodecCtx->SetSampleFmt(static_cast<AVSampleFormatFwd>(AUDACITY_AV_SAMPLE_FMT_S16));
   mEncAudioCodecCtx->SetStrictStdCompliance(
      AUDACITY_FF_COMPLIANCE_EXPERIMENTAL);
 
   if (codecID == AUDACITY_AV_CODEC_ID_AC3)
   {
      // As of Jan 4, 2011, the default AC3 encoder only accept SAMPLE_FMT_FLT samples.
      // But, currently, Audacity only supports SAMPLE_FMT_S16.  So, for now, look for the
      // "older" AC3 codec.  this is not a proper solution, but will suffice until other
      // encoders no longer support SAMPLE_FMT_S16.
      codec = mFFmpeg->CreateEncoder("ac3_fixed");
   }
 
   if (!codec)
   {
      codec = mFFmpeg->CreateEncoder(mFFmpeg->GetAVCodecID(codecID));
   }
 
   // Is the required audio codec compiled into libavcodec?
   if (codec == NULL)
   {
      /* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
      throw ExportException(XO("FFmpeg cannot find audio codec 0x%x.\nSupport for this codec is probably not compiled in.")
                  .Format(static_cast<const unsigned int>(codecID.value))
                  .Translation());
   }
 
   if (codec->GetSampleFmts()) {
      for (int i = 0; codec->GetSampleFmts()[i] != AUDACITY_AV_SAMPLE_FMT_NONE; i++)
      {
         AVSampleFormatFwd fmt = codec->GetSampleFmts()[i];
 
         if (
            fmt == AUDACITY_AV_SAMPLE_FMT_U8 ||
            fmt == AUDACITY_AV_SAMPLE_FMT_U8P ||
            fmt == AUDACITY_AV_SAMPLE_FMT_S16 ||
            fmt == AUDACITY_AV_SAMPLE_FMT_S16P ||
            fmt == AUDACITY_AV_SAMPLE_FMT_S32 ||
            fmt == AUDACITY_AV_SAMPLE_FMT_S32P ||
            fmt == AUDACITY_AV_SAMPLE_FMT_FLT ||
            fmt == AUDACITY_AV_SAMPLE_FMT_FLTP)
         {
            mEncAudioCodecCtx->SetSampleFmt(fmt);
         }
 
         if (
            fmt == AUDACITY_AV_SAMPLE_FMT_S16 ||
            fmt == AUDACITY_AV_SAMPLE_FMT_S16P)
            break;
      }
   }
 
   if (codec->GetSupportedSamplerates())
   {
      // Workaround for crash in bug #2378.  Proper fix is to get a newer version of FFmpeg.
      if (codec->GetId() == mFFmpeg->GetAVCodecID(AUDACITY_AV_CODEC_ID_AAC))
      {
         std::vector<int> rates;
         int i = 0;
 
         while (codec->GetSupportedSamplerates()[i] &&
                codec->GetSupportedSamplerates()[i] != 7350)
         {
            rates.push_back(codec->GetSupportedSamplerates()[i++]);
         }
 
         rates.push_back(0);
 
         if (!CheckSampleRate(mSampleRate, 0, 0, rates.data()))
         {
            mSampleRate = AskResample(0, mSampleRate, 0, 0, rates.data());
            mEncAudioCodecCtx->SetSampleRate(mSampleRate);
         }
      }
      else
      {
         if (!CheckSampleRate(
                mSampleRate, 0, 0, codec->GetSupportedSamplerates()))
         {
            mSampleRate = AskResample(
               0, mSampleRate, 0, 0, codec->GetSupportedSamplerates());
            mEncAudioCodecCtx->SetSampleRate(mSampleRate);
         }
      }
 
      // This happens if user refused to resample the project
      if (mSampleRate == 0)
      {
         return false;
      }
   }
 
   if (mEncFormatCtx->GetOutputFormat()->GetFlags() & AUDACITY_AVFMT_GLOBALHEADER)
   {
      mEncAudioCodecCtx->SetFlags(mEncAudioCodecCtx->GetFlags() | AUDACITY_AV_CODEC_FLAG_GLOBAL_HEADER);
      mEncFormatCtx->SetFlags(mEncFormatCtx->GetFlags() | AUDACITY_AV_CODEC_FLAG_GLOBAL_HEADER);
   }
 
   // Open the codec.
   int rc = mEncAudioCodecCtx->Open(codec.get(), &options);
   if (rc < 0)
   {
      TranslatableString errmsg;
 
      switch (rc)
      {
      case AUDACITY_AVERROR(EPERM):
         errmsg = XO("The codec reported a generic error (EPERM)");
         break;
      case AUDACITY_AVERROR(EINVAL):
         errmsg = XO("The codec reported an invalid parameter (EINVAL)");
         break;
      default:
         char buf[64];
         mFFmpeg->av_strerror(rc, buf, sizeof(buf));
         errmsg = Verbatim(buf);
      }
 
      /* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
      throw ExportException(XO("Can't open audio codec \"%s\" (0x%x)\n\n%s")
         .Format(codec->GetName(), codecID.value, errmsg)
         .Translation());
   }
 
   mDefaultFrameSize = mEncAudioCodecCtx->GetFrameSize();
 
   if (mDefaultFrameSize == 0)
      mDefaultFrameSize = 1024; // arbitrary non zero value;
 
   wxLogDebug(
      wxT("FFmpeg : Audio Output Codec Frame Size: %d samples."),
      mEncAudioCodecCtx->GetFrameSize());
 
   // The encoder may require a minimum number of raw audio samples for each encoding but we can't
   // guarantee we'll get this minimum each time an audio frame is decoded from the input file so
   // we use a FIFO to store up incoming raw samples until we have enough for one call to the codec.
   mEncAudioFifo = std::make_unique<FifoBuffer>(mDefaultFrameSize * mChannels * sizeof(int16_t));
 
   mEncAudioFifoOutBufSize = 2*MaxAudioPacketSize;
   // Allocate a buffer to read OUT of the FIFO into. The FIFO maintains its own buffer internally.
   mEncAudioFifoOutBuf = mFFmpeg->CreateMemoryBuffer<int16_t>(mEncAudioFifoOutBufSize);
 
   if (mEncAudioFifoOutBuf.empty())
   {
      throw ExportException(_("FFmpeg : ERROR - Can't allocate buffer to read into from audio FIFO."));
   }
 
   return true;
}

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMetadata()

void FFmpegExporter::SetMetadata	(	const Tags *	tags,
		const char *	name,
		const wxChar *	tag
	)

private

Sets individual metadata values.

Definition at line 1722 of file ExportFFmpeg.cpp.

{
   if (tags->HasTag(tag))
   {
      wxString value = tags->GetTag(tag);
 
      AVDictionaryWrapper metadata = mEncFormatCtx->GetMetadata();
 
      metadata.Set(name, mSupportsUTF8 ? value : value.mb_str(), 0);
      mEncFormatCtx->SetMetadata(metadata);
   }
}

References Tags::GetTag(), Tags::HasTag(), mEncFormatCtx, mSupportsUTF8, name, and AVDictionaryWrapper::Set().

Referenced by AddTags().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WritePacket()

void FFmpegExporter::WritePacket ( AVPacketWrapper & packet )

private

Definition at line 1306 of file ExportFFmpeg.cpp.

{
   // Set presentation time of frame (currently in the codec's timebase) in the
   // stream timebase.
   if (pkt.GetPresentationTimestamp() != AUDACITY_AV_NOPTS_VALUE)
      pkt.RescalePresentationTimestamp(
         mEncAudioCodecCtx->GetTimeBase(), mEncAudioStream->GetTimeBase());
 
   if (pkt.GetDecompressionTimestamp() != AUDACITY_AV_NOPTS_VALUE)
      pkt.RescaleDecompressionTimestamp(
         mEncAudioCodecCtx->GetTimeBase(), mEncAudioStream->GetTimeBase());
 
   if (pkt.GetDuration() > 0)
      pkt.RescaleDuration(
         mEncAudioCodecCtx->GetTimeBase(), mEncAudioStream->GetTimeBase());
 
   if (
      mFFmpeg->av_interleaved_write_frame(
         mEncFormatCtx->GetWrappedValue(), pkt.GetWrappedValue()) != 0)
   {
      throw ExportException(_("FFmpeg : ERROR - Couldn't write audio frame to output file."));
   }
}

References _, AUDACITY_AV_NOPTS_VALUE, AVPacketWrapper::GetDecompressionTimestamp(), AVPacketWrapper::GetDuration(), AVPacketWrapper::GetPresentationTimestamp(), AVPacketWrapper::GetWrappedValue(), mEncAudioCodecCtx, mEncAudioStream, mEncFormatCtx, mFFmpeg, AVPacketWrapper::RescaleDecompressionTimestamp(), AVPacketWrapper::RescaleDuration(), and AVPacketWrapper::RescalePresentationTimestamp().

Referenced by EncodeAudio().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ MaxAudioPacketSize

constexpr auto FFmpegExporter::MaxAudioPacketSize { 128 * 1024 }

staticconstexprprivate

Definition at line 590 of file ExportFFmpeg.cpp.

Referenced by InitCodecs().

◆ mBitRate

int FFmpegExporter::mBitRate {}

private

Definition at line 649 of file ExportFFmpeg.cpp.

◆ mChannels

unsigned FFmpegExporter::mChannels {}

private

Definition at line 651 of file ExportFFmpeg.cpp.

Referenced by CreateMixer(), EncodeAudioFrame(), and InitCodecs().

◆ mDefaultFrameSize

int FFmpegExporter::mDefaultFrameSize {}

private

Definition at line 642 of file ExportFFmpeg.cpp.

Referenced by CreateMixer(), EncodeAudioFrame(), Finalize(), and InitCodecs().

◆ mEncAudioCodecCtx

std::unique_ptr<AVCodecContextWrapper> FFmpegExporter::mEncAudioCodecCtx

private

Definition at line 658 of file ExportFFmpeg.cpp.

Referenced by EncodeAudio(), EncodeAudioFrame(), Finalize(), Init(), InitCodecs(), and WritePacket().

◆ mEncAudioFifo

std::unique_ptr<FifoBuffer> FFmpegExporter::mEncAudioFifo

private

Definition at line 655 of file ExportFFmpeg.cpp.

Referenced by EncodeAudioFrame(), Finalize(), and InitCodecs().

◆ mEncAudioFifoOutBuf

AVDataBuffer<int16_t> FFmpegExporter::mEncAudioFifoOutBuf

private

Definition at line 656 of file ExportFFmpeg.cpp.

Referenced by EncodeAudioFrame(), Finalize(), and InitCodecs().

◆ mEncAudioFifoOutBufSize

int FFmpegExporter::mEncAudioFifoOutBufSize {}

private

Definition at line 644 of file ExportFFmpeg.cpp.

Referenced by EncodeAudioFrame(), Finalize(), and InitCodecs().

◆ mEncAudioStream

std::unique_ptr<AVStreamWrapper> FFmpegExporter::mEncAudioStream

private

Definition at line 643 of file ExportFFmpeg.cpp.

Referenced by EncodeAudio(), Init(), InitCodecs(), and WritePacket().

◆ mEncFormatCtx

std::unique_ptr<AVFormatContextWrapper> FFmpegExporter::mEncFormatCtx

private

Definition at line 657 of file ExportFFmpeg.cpp.

Referenced by Finalize(), Init(), InitCodecs(), SetMetadata(), and WritePacket().

◆ mEncFormatDesc

std::unique_ptr<AVOutputFormatWrapper> FFmpegExporter::mEncFormatDesc

private

Definition at line 641 of file ExportFFmpeg.cpp.

Referenced by AddTags(), Init(), and InitCodecs().

◆ mFFmpeg

std::shared_ptr<FFmpegFunctions> FFmpegExporter::mFFmpeg

private

Definition at line 639 of file ExportFFmpeg.cpp.

Referenced by AddTags(), EncodeAudio(), EncodeAudioFrame(), FFmpegExporter(), Finalize(), Init(), InitCodecs(), and WritePacket().

◆ mName

wxFileNameWrapper FFmpegExporter::mName

private

Definition at line 646 of file ExportFFmpeg.cpp.

Referenced by Init().

◆ mSampleRate

int FFmpegExporter::mSampleRate {}

private

Definition at line 650 of file ExportFFmpeg.cpp.

Referenced by CreateMixer(), and InitCodecs().

◆ mSubFormat

int FFmpegExporter::mSubFormat {}

private

Definition at line 648 of file ExportFFmpeg.cpp.

Referenced by Init(), and InitCodecs().

◆ mSupportsUTF8

bool FFmpegExporter::mSupportsUTF8 {true}

private

Definition at line 652 of file ExportFFmpeg.cpp.

Referenced by Init(), and SetMetadata().

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

ExportFFmpeg.cpp

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FFmpegExporter()

Member Function Documentation

◆ AddTags()

◆ AskResample()

◆ CheckSampleRate()

◆ CreateMixer()

◆ EncodeAudio()

◆ EncodeAudioFrame()

◆ Finalize()

◆ Init()

◆ InitCodecs()

◆ SetMetadata()

◆ WritePacket()

Member Data Documentation

◆ MaxAudioPacketSize

◆ mBitRate

◆ mChannels

◆ mDefaultFrameSize

◆ mEncAudioCodecCtx

◆ mEncAudioFifo

◆ mEncAudioFifoOutBuf

◆ mEncAudioFifoOutBufSize

◆ mEncAudioStream

◆ mEncFormatCtx

◆ mEncFormatDesc

◆ mFFmpeg

◆ mName

◆ mSampleRate

◆ mSubFormat

◆ mSupportsUTF8