! Does actual import, returned by FFmpegImportPlugin::Open More...

Inheritance diagram for FFmpegImportFileHandle:

Collaboration diagram for FFmpegImportFileHandle:

Public Member Functions
	FFmpegImportFileHandle (const FilePath &name)

	~FFmpegImportFileHandle ()

bool	Init ()

bool	InitCodecs ()

TranslatableString	GetFileDescription () override

ByteCount	GetFileUncompressedBytes () override

void	Import (ImportProgressListener &progressListener, WaveTrackFactory trackFactory, TrackHolders &outTracks, Tags tags, std::optional< LibFileFormats::AcidizerTags > &outAcidTags) override

FilePath	GetFilename () const override

void	Cancel () override

void	Stop () override

void	WriteData (StreamContext sc, const AVPacketWrapper packet)

void	WriteMetadata (Tags *tags)

void	GetMetadata (Tags &tags, const wxChar tag, const char name)

wxInt32	GetStreamCount () override

const TranslatableStrings &	GetStreamInfo () override

void	SetStreamUsage (wxInt32 StreamID, bool Use) override

Public Member Functions inherited from ImportFileHandle
virtual	~ImportFileHandle ()

virtual FilePath	GetFilename () const =0

virtual TranslatableString	GetErrorMessage () const

virtual TranslatableString	GetFileDescription ()=0

virtual ByteCount	GetFileUncompressedBytes ()=0

virtual wxInt32	GetStreamCount ()=0

virtual const TranslatableStrings &	GetStreamInfo ()=0

virtual void	SetStreamUsage (wxInt32 StreamID, bool Use)=0

virtual void	Import (ImportProgressListener &progressListener, WaveTrackFactory trackFactory, TrackHolders &outTracks, Tags tags, std::optional< LibFileFormats::AcidizerTags > &acidTags)=0

virtual void	Cancel ()=0

virtual void	Stop ()=0

Private Attributes
const std::shared_ptr< FFmpegFunctions >	mFFmpeg = FFmpegFunctions::Load()

std::vector< StreamContext >	mStreamContexts

std::unique_ptr< AVFormatContextWrapper >	mAVFormatContext

TranslatableStrings	mStreamInfo
	Array of stream descriptions. After Init() and before Import(), same size as mStreamContexts. More...

wxInt64	mProgressPos = 0
	Current timestamp, file position or whatever is used as first argument for Update() More...

wxInt64	mProgressLen = 1
	Duration, total length or whatever is used as second argument for Update() More...

bool	mCancelled = false
	True if importing was canceled by user. More...

bool	mStopped = false
	True if importing was stopped by user. More...

const FilePath	mName

std::vector< WaveTrack::Holder >	mStreams

Additional Inherited Members
Public Types inherited from ImportFileHandle
using	ByteCount = unsigned long long

Detailed Description

! Does actual import, returned by FFmpegImportPlugin::Open

An ImportFileHandle for FFmpeg data.

Definition at line 191 of file ImportFFmpeg.cpp.

Constructor & Destructor Documentation

◆ FFmpegImportFileHandle()

FFmpegImportFileHandle::FFmpegImportFileHandle ( const FilePath & name )

Definition at line 336 of file ImportFFmpeg.cpp.

   : mName{ name }
{
}

◆ ~FFmpegImportFileHandle()

FFmpegImportFileHandle::~FFmpegImportFileHandle ( )

Definition at line 706 of file ImportFFmpeg.cpp.

{
 
}

Member Function Documentation

◆ Cancel()

void FFmpegImportFileHandle::Cancel ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 554 of file ImportFFmpeg.cpp.

{
   if(!mStopped)
      mCancelled = true;
}

References mCancelled, and mStopped.

◆ GetFileDescription()

TranslatableString FFmpegImportFileHandle::GetFileDescription ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 439 of file ImportFFmpeg.cpp.

{
   return DESC;
}

References DESC.

◆ GetFilename()

FilePath FFmpegImportFileHandle::GetFilename ( ) const

overridevirtual

Implements ImportFileHandle.

Definition at line 549 of file ImportFFmpeg.cpp.

{
   return mName;
}

References mName.

◆ GetFileUncompressedBytes()

auto FFmpegImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 445 of file ImportFFmpeg.cpp.

{
   // TODO: Get Uncompressed byte count.
   return 0;
}

◆ GetMetadata()

void FFmpegImportFileHandle::GetMetadata	(	Tags &	tags,
		const wxChar *	tag,
		const char *	name
	)

! Retrieves metadata from FFmpeg and converts to wxString

Parameters

avf	- file context \ tags - Audacity tags object \ tag - name of tag to set \ name - name of metadata item to retrieve

Definition at line 697 of file ImportFFmpeg.cpp.

{
   auto metadata = mAVFormatContext->GetMetadata();
 
   if (metadata.HasValue(name, DICT_IGNORE_SUFFIX))
      tags.SetTag(tag, wxString::FromUTF8(std::string(metadata.Get(name, {}, DICT_IGNORE_SUFFIX))));
}

References DICT_IGNORE_SUFFIX, mAVFormatContext, name, and Tags::SetTag().

Referenced by WriteMetadata().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStreamCount()

wxInt32 FFmpegImportFileHandle::GetStreamCount ( )

inlineoverridevirtual

! Called by Import.cpp

Returns: number of readable streams in the file

Implements ImportFileHandle.

Definition at line 238 of file ImportFFmpeg.cpp.

   {
      return static_cast<wxInt32>(mStreamContexts.size());
   }

References mStreamContexts.

◆ GetStreamInfo()

const TranslatableStrings & FFmpegImportFileHandle::GetStreamInfo ( )

inlineoverridevirtual

! Called by Import.cpp

Returns: array of strings - descriptions of the streams

Implements ImportFileHandle.

Definition at line 245 of file ImportFFmpeg.cpp.

   {
      return mStreamInfo;
   }

References mStreamInfo.

◆ Import()

void FFmpegImportFileHandle::Import	(	ImportProgressListener &	progressListener,
		WaveTrackFactory *	trackFactory,
		TrackHolders &	outTracks,
		Tags *	tags,
		std::optional< LibFileFormats::AcidizerTags > &	outAcidTags
	)

overridevirtual

This may break the correspondence with mStreamInfo

TODO: Nag FFmpeg devs about start_time until they finally say WHAT is this and HOW to handle it.

Implements ImportFileHandle.

Definition at line 451 of file ImportFFmpeg.cpp.

{
   outTracks.clear();
   mCancelled = false;
   mStopped = false;
 
   mStreamContexts.erase (std::remove_if (mStreamContexts.begin (), mStreamContexts.end (), [](const StreamContext& ctx) {
      return !ctx.Use;
   }), mStreamContexts.end());
 
   for(unsigned s = 0; s < mStreamContexts.size(); ++s)
   {
      const StreamContext& sc = mStreamContexts[s];
 
      auto stream = ImportUtils::NewWaveTrack(
         *trackFactory,
         sc.InitialChannels,
         sc.SampleFormat,
         sc.CodecContext->GetSampleRate()
      );
 
      // Handles the start_time by creating silence. This may or may not be correct.
      // There is a possibility that we should ignore first N milliseconds of audio instead. I do not know.
 
      int64_t stream_delay = 0;
 
      const int64_t streamStartTime =
         mAVFormatContext->GetStream(sc.StreamIndex)->GetStartTime();
 
      if (streamStartTime != int64_t(AUDACITY_AV_NOPTS_VALUE) && streamStartTime > 0)
      {
         stream_delay = streamStartTime;
 
         wxLogDebug(
            wxT("Stream %d start_time = %lld, that would be %f milliseconds."),
            s, (long long)streamStartTime, double(streamStartTime) / 1000);
      }
 
      if (stream_delay > 0) {
         stream->InsertSilence(0, double(stream_delay) / AUDACITY_AV_TIME_BASE);
      }
 
      mStreams.push_back(stream);
   }
 
   // This is the heart of the importing process
 
   // Read frames.
   for (std::unique_ptr<AVPacketWrapper> packet;
        (packet = mAVFormatContext->ReadNextPacket()) != nullptr &&
        !mCancelled && !mStopped;)
   {
      // Find a matching StreamContext
      auto streamContextIt = std::find_if(
         mStreamContexts.begin(), mStreamContexts.end(),
         [index = packet->GetStreamIndex()](const StreamContext& ctx)
         { return ctx.StreamIndex == index;
      });
 
      if (streamContextIt == mStreamContexts.end())
         continue;
 
      WriteData(&(*streamContextIt), packet.get());
      if(mProgressLen > 0)
         progressListener.OnImportProgress(static_cast<double>(mProgressPos) /
                                           static_cast<double>(mProgressLen));
   }
 
   // Flush the decoders.
   if (!mStreamContexts.empty() && !mCancelled)
   {
      auto emptyPacket = mFFmpeg->CreateAVPacketWrapper();
 
      for (StreamContext& sc : mStreamContexts)
         WriteData(&sc, emptyPacket.get());
   }
 
   if(mCancelled)
   {
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Cancelled);
      return;
   }
 
   // Copy audio from mChannels to newly created tracks (destroying mChannels elements in process)
   ImportUtils::FinalizeImport(outTracks, mStreams);
 
   // Save metadata
   WriteMetadata(tags);
   progressListener.OnImportResult(mStopped
                                   ? ImportProgressListener::ImportResult::Stopped
                                   : ImportProgressListener::ImportResult::Success);
}

References AUDACITY_AV_NOPTS_VALUE, AUDACITY_AV_TIME_BASE, ImportProgressListener::Cancelled, StreamContext::CodecContext, ImportUtils::FinalizeImport(), StreamContext::InitialChannels, mAVFormatContext, mCancelled, mFFmpeg, mProgressLen, mProgressPos, mStopped, mStreamContexts, mStreams, ImportUtils::NewWaveTrack(), ImportProgressListener::OnImportProgress(), ImportProgressListener::OnImportResult(), StreamContext::SampleFormat, ImportProgressListener::Stopped, StreamContext::StreamIndex, anonymous_namespace{MIDIPlay.cpp}::streamStartTime, ImportProgressListener::Success, WriteData(), WriteMetadata(), and wxT().

Here is the call graph for this function:

◆ Init()

bool FFmpegImportFileHandle::Init ( )

! Format initialization

Returns: true if successful, false otherwise

Definition at line 341 of file ImportFFmpeg.cpp.

{
   if (!mFFmpeg)
      return false;
 
   mAVFormatContext = mFFmpeg->CreateAVFormatContext();
 
   const auto err = mAVFormatContext->OpenInputContext(mName, nullptr, AVDictionaryWrapper(*mFFmpeg));
 
   if (err != AVIOContextWrapper::OpenResult::Success)
   {
      wxLogError(wxT("FFmpeg : AVFormatContextWrapper::OpenInputContext() failed for file %s"), mName);
      return false;
   }
 
   if (!InitCodecs())
      return false;
 
   return true;
}

References InitCodecs(), mAVFormatContext, mFFmpeg, mName, AVIOContextWrapper::Success, and wxT().

Here is the call graph for this function:

◆ InitCodecs()

bool FFmpegImportFileHandle::InitCodecs ( )

! Codec initialization

Returns: true if successful, false otherwise

Definition at line 362 of file ImportFFmpeg.cpp.

{
   for (unsigned int i = 0; i < mAVFormatContext->GetStreamsCount(); i++)
   {
      const AVStreamWrapper* stream = mAVFormatContext->GetStream(i);
 
      if (stream->IsAudio())
      {
         const AVCodecIDFwd id = mAVFormatContext->GetStream(i)->GetAVCodecID();
 
         auto codec = mFFmpeg->CreateDecoder(id);
         auto name = mFFmpeg->avcodec_get_name(id);
 
         if (codec == NULL)
         {
            wxLogError(
               wxT("FFmpeg : CreateDecoder() failed. Index[%02d], Codec[%02x - %s]"),
               i, id, name);
            //FFmpeg can't decode this stream, skip it
            continue;
         }
 
         auto codecContextPtr = stream->GetAVCodecContext();
 
         if ( codecContextPtr->Open( codecContextPtr->GetCodec() ) < 0 )
         {
            wxLogError(wxT("FFmpeg : Open() failed. Index[%02d], Codec[%02x - %s]"),i,id,name);
            //Can't open decoder - skip this stream
            continue;
         }
 
         const int channels = codecContextPtr->GetChannels();
         const sampleFormat preferredFormat =
            codecContextPtr->GetPreferredAudacitySampleFormat();
 
         auto codecContext = codecContextPtr.get();
 
         mStreamContexts.emplace_back(
            StreamContext { stream->GetIndex(), std::move(codecContextPtr),
                            channels, preferredFormat, true });
 
         // Stream is decodeable and it is audio. Add it and its description to the arrays
         int duration = 0;
         if (stream->GetDuration() > 0)
            duration = stream->GetDuration() * stream->GetTimeBase().num / stream->GetTimeBase().den;
         else
            duration = mAVFormatContext->GetDuration() / AUDACITY_AV_TIME_BASE;
 
         wxString bitrate;
         if (codecContext->GetBitRate() > 0)
            bitrate.Printf(wxT("%d"),(int)codecContext->GetBitRate());
         else
            bitrate.Printf(wxT("?"));
 
         AVDictionaryWrapper streamMetadata = stream->GetMetadata();
 
         auto lang = std::string(streamMetadata.Get("language", {}));
 
         auto strinfo = XO(
/* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
"Index[%02x] Codec[%s], Language[%s], Bitrate[%s], Channels[%d], Duration[%d]")
            .Format(
               stream->GetIndex(),
               name,
               lang,
               bitrate,
               (int)codecContext->GetChannels(),
               (int)duration);
 
         mStreamInfo.push_back(strinfo);
      }
      //for video and unknown streams do nothing
   }
   //It doesn't really returns false, but GetStreamCount() will return 0 if file is composed entirely of unreadable streams
   return true;
}

References AUDACITY_AV_TIME_BASE, AudacityAVRational::den, AVDictionaryWrapper::Get(), AVStreamWrapper::GetAVCodecContext(), AVStreamWrapper::GetDuration(), AVStreamWrapper::GetIndex(), AVStreamWrapper::GetMetadata(), AVStreamWrapper::GetTimeBase(), AVStreamWrapper::IsAudio(), mAVFormatContext, mFFmpeg, mStreamContexts, mStreamInfo, name, AudacityAVRational::num, wxT(), and XO().

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetStreamUsage()

void FFmpegImportFileHandle::SetStreamUsage	(	wxInt32	StreamID,
		bool	Use
	)

inlineoverridevirtual

! Called by Import.cpp

Parameters

StreamID	- index of the stream in mStreamInfo and mStreamContexts
Use	- true if this stream should be imported, false otherwise

Implements ImportFileHandle.

Definition at line 253 of file ImportFFmpeg.cpp.

   {
      if (StreamID < static_cast<wxInt32>(mStreamContexts.size()))
         mStreamContexts[StreamID].Use = Use;
   }

References mStreamContexts.

◆ Stop()

void FFmpegImportFileHandle::Stop ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 560 of file ImportFFmpeg.cpp.

{
   if(!mCancelled)
      mStopped = true;
}

References mCancelled, and mStopped.

◆ WriteData()

void FFmpegImportFileHandle::WriteData	(	StreamContext *	sc,
		const AVPacketWrapper *	packet
	)

! Writes decoded data into WaveTracks.

Parameters

sc	- stream context

Definition at line 566 of file ImportFFmpeg.cpp.

{
   // Find the stream in mStreamContexts array
   auto streamIt = std::find_if(
      mStreamContexts.begin(),
      mStreamContexts.end(),
      [&](StreamContext& context) { return sc == &context; }
   );
 
   // Stream is not found. This should not really happen
   if (streamIt == mStreamContexts.end())
   {
      //VS: Shouldn't this mean import failure?
      return;
   }
   auto stream = mStreams[std::distance(mStreamContexts.begin(), streamIt)];
 
   const auto nChannels = std::min(sc->CodecContext->GetChannels(), sc->InitialChannels);
 
   // Write audio into WaveTracks
   if (sc->SampleFormat == int16Sample)
   {
      auto data = sc->CodecContext->DecodeAudioPacketInt16(packet);
      const auto channelsCount = sc->CodecContext->GetChannels();
      const auto samplesPerChannel = data.size() / channelsCount;
 
      unsigned chn = 0;
      ImportUtils::ForEachChannel(*stream, [&](auto& channel)
      {
         if(chn >= nChannels)
            return;
 
         channel.AppendBuffer(
            reinterpret_cast<samplePtr>(data.data() + chn),
            sc->SampleFormat,
            samplesPerChannel,
            sc->CodecContext->GetChannels(),
            sc->SampleFormat
         );
         ++chn;
      });
   }
   else if (sc->SampleFormat == floatSample)
   {
      auto data = sc->CodecContext->DecodeAudioPacketFloat(packet);
      const auto channelsCount = sc->CodecContext->GetChannels();
      const auto samplesPerChannel = data.size() / channelsCount;
 
      auto channelIndex = 0;
      ImportUtils::ForEachChannel(*stream, [&](auto& channel)
      {
         if(channelIndex >= nChannels)
            return;
 
         channel.AppendBuffer(
            reinterpret_cast<samplePtr>(data.data() + channelIndex),
            sc->SampleFormat,
            samplesPerChannel,
            sc->CodecContext->GetChannels(),
            sc->SampleFormat
         );
         ++channelIndex;
      });
   }
   const AVStreamWrapper* avStream = mAVFormatContext->GetStream(sc->StreamIndex);
 
   int64_t filesize = mFFmpeg->avio_size(mAVFormatContext->GetAVIOContext()->GetWrappedValue());
   // PTS (presentation time) is the proper way of getting current position
   if (
      packet->GetPresentationTimestamp() != AUDACITY_AV_NOPTS_VALUE &&
      mAVFormatContext->GetDuration() != AUDACITY_AV_NOPTS_VALUE)
   {
      auto timeBase = avStream->GetTimeBase();
 
      mProgressPos =
         packet->GetPresentationTimestamp() * timeBase.num / timeBase.den;
 
      mProgressLen =
         (mAVFormatContext->GetDuration() > 0 ?
             mAVFormatContext->GetDuration() / AUDACITY_AV_TIME_BASE :
             1);
   }
   // When PTS is not set, use number of frames and number of current frame
   else if (
      avStream->GetFramesCount() > 0 && sc->CodecContext->GetFrameNumber() > 0 &&
      sc->CodecContext->GetFrameNumber() <= avStream->GetFramesCount())
   {
      mProgressPos = sc->CodecContext->GetFrameNumber();
      mProgressLen = avStream->GetFramesCount();
   }
   // When number of frames is unknown, use position in file
   else if (
      filesize > 0 && packet->GetPos() > 0 && packet->GetPos() <= filesize)
   {
      mProgressPos = packet->GetPos();
      mProgressLen = filesize;
   }
}

References AUDACITY_AV_NOPTS_VALUE, AUDACITY_AV_TIME_BASE, StreamContext::CodecContext, floatSample, ImportUtils::ForEachChannel(), AVStreamWrapper::GetFramesCount(), AVPacketWrapper::GetPos(), AVPacketWrapper::GetPresentationTimestamp(), AVStreamWrapper::GetTimeBase(), StreamContext::InitialChannels, int16Sample, mAVFormatContext, mFFmpeg, min(), mProgressLen, mProgressPos, mStreamContexts, mStreams, StreamContext::SampleFormat, and StreamContext::StreamIndex.

Referenced by Import().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ WriteMetadata()

void FFmpegImportFileHandle::WriteMetadata ( Tags * tags )

! Writes extracted metadata to tags object

Parameters

avf	- file context \ tags - Audacity tags object

Definition at line 665 of file ImportFFmpeg.cpp.

{
   Tags temp;
 
   GetMetadata(temp, TAG_TITLE, "title");
   GetMetadata(temp, TAG_COMMENTS, "comment");
   GetMetadata(temp, TAG_ALBUM, "album");
   GetMetadata(temp, TAG_TRACK, "track");
   GetMetadata(temp, TAG_GENRE, "genre");
 
   if (wxString(mAVFormatContext->GetInputFormat()->GetName()).Contains("m4a"))
   {
      GetMetadata(temp, TAG_ARTIST, "artist");
      GetMetadata(temp, TAG_YEAR, "date");
   }
   else if (wxString(mAVFormatContext->GetInputFormat()->GetName()).Contains("asf")) /* wma */
   {
      GetMetadata(temp, TAG_ARTIST, "artist");
      GetMetadata(temp, TAG_YEAR, "year");
   }
   else
   {
      GetMetadata(temp, TAG_ARTIST, "author");
      GetMetadata(temp, TAG_YEAR, "year");
   }
 
   if (!temp.IsEmpty())
   {
      *tags = temp;
   }
}

References GetMetadata(), Tags::IsEmpty(), mAVFormatContext, TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_GENRE, TAG_TITLE, TAG_TRACK, and TAG_YEAR.

Referenced by Import().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ mAVFormatContext

std::unique_ptr<AVFormatContextWrapper> FFmpegImportFileHandle::mAVFormatContext

private

Definition at line 266 of file ImportFFmpeg.cpp.

Referenced by GetMetadata(), Import(), Init(), InitCodecs(), WriteData(), and WriteMetadata().

◆ mCancelled

bool FFmpegImportFileHandle::mCancelled = false

private

True if importing was canceled by user.

Definition at line 273 of file ImportFFmpeg.cpp.

Referenced by Cancel(), Import(), and Stop().

◆ mFFmpeg

const std::shared_ptr<FFmpegFunctions> FFmpegImportFileHandle::mFFmpeg = FFmpegFunctions::Load()

private

Definition at line 262 of file ImportFFmpeg.cpp.

Referenced by Import(), Init(), InitCodecs(), and WriteData().

◆ mName

const FilePath FFmpegImportFileHandle::mName

private

Definition at line 275 of file ImportFFmpeg.cpp.

Referenced by GetFilename(), and Init().

◆ mProgressLen

wxInt64 FFmpegImportFileHandle::mProgressLen = 1

private

Duration, total length or whatever is used as second argument for Update()

Definition at line 271 of file ImportFFmpeg.cpp.

Referenced by Import(), and WriteData().

◆ mProgressPos

wxInt64 FFmpegImportFileHandle::mProgressPos = 0

private

Current timestamp, file position or whatever is used as first argument for Update()

Definition at line 270 of file ImportFFmpeg.cpp.

Referenced by Import(), and WriteData().

◆ mStopped

bool FFmpegImportFileHandle::mStopped = false

private

True if importing was stopped by user.

Definition at line 274 of file ImportFFmpeg.cpp.

Referenced by Cancel(), Import(), and Stop().

◆ mStreamContexts

std::vector<StreamContext> FFmpegImportFileHandle::mStreamContexts

private

Definition at line 264 of file ImportFFmpeg.cpp.

Referenced by GetStreamCount(), Import(), InitCodecs(), SetStreamUsage(), and WriteData().

◆ mStreamInfo

TranslatableStrings FFmpegImportFileHandle::mStreamInfo

private

Array of stream descriptions. After Init() and before Import(), same size as mStreamContexts.

Definition at line 268 of file ImportFFmpeg.cpp.

Referenced by GetStreamInfo(), and InitCodecs().

◆ mStreams

std::vector<WaveTrack::Holder> FFmpegImportFileHandle::mStreams

private

Definition at line 276 of file ImportFFmpeg.cpp.

Referenced by Import(), and WriteData().

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

ImportFFmpeg.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FFmpegImportFileHandle()

◆ ~FFmpegImportFileHandle()

Member Function Documentation

◆ Cancel()

◆ GetFileDescription()

◆ GetFilename()

◆ GetFileUncompressedBytes()

◆ GetMetadata()

◆ GetStreamCount()

◆ GetStreamInfo()

◆ Import()

◆ Init()

◆ InitCodecs()

◆ SetStreamUsage()

◆ Stop()

◆ WriteData()

◆ WriteMetadata()

Member Data Documentation

◆ mAVFormatContext

◆ mCancelled

◆ mFFmpeg

◆ mName

◆ mProgressLen

◆ mProgressPos

◆ mStopped

◆ mStreamContexts

◆ mStreamInfo

◆ mStreams