An ImportFileHandle for PCM data. More...

Inheritance diagram for PCMImportFileHandle:

Collaboration diagram for PCMImportFileHandle:

Public Member Functions
	PCMImportFileHandle (const FilePath &name, SFFile &&file, SF_INFO info)

	~PCMImportFileHandle ()

TranslatableString	GetFileDescription () override

ByteCount	GetFileUncompressedBytes () override

void	Import (ImportProgressListener &progressListener, WaveTrackFactory trackFactory, TrackHolders &outTracks, Tags tags) override

wxInt32	GetStreamCount () override

const TranslatableStrings &	GetStreamInfo () override

void	SetStreamUsage (wxInt32 WXUNUSED(StreamID), bool WXUNUSED(Use)) override

Public Member Functions inherited from ImportFileHandleEx
	ImportFileHandleEx (const FilePath &filename)

FilePath	GetFilename () const override

void	Cancel () override

void	Stop () 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)=0

virtual void	Cancel ()=0

virtual void	Stop ()=0

Private Attributes
SFFile	mFile

const SF_INFO	mInfo

sampleFormat	mEffectiveFormat

sampleFormat	mFormat

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

Protected Member Functions inherited from ImportFileHandleEx
void	BeginImport ()

bool	IsCancelled () const noexcept

bool	IsStopped () const noexcept

Detailed Description

An ImportFileHandle for PCM data.

Definition at line 75 of file ImportPCM.cpp.

Constructor & Destructor Documentation

◆ PCMImportFileHandle()

PCMImportFileHandle::PCMImportFileHandle	(	const FilePath &	name,
		SFFile &&	file,
		SF_INFO	info
	)

Definition at line 180 of file ImportPCM.cpp.

:  ImportFileHandleEx(name),
   mFile(std::move(file)),
   mInfo(info)
{
   wxASSERT(info.channels >= 0);
 
   //
   // Figure out the format to use.
   //
   // In general, go with the user's preferences.  However, if
   // the file is higher-quality, go with a format which preserves
   // the quality of the original file.
   //
 
   // Effective format
   mEffectiveFormat = sf_subtype_to_effective_format(mInfo.format);
   // But maybe different storage format
   mFormat = ImportUtils::ChooseFormat(mEffectiveFormat);
}

References ImportUtils::ChooseFormat(), mEffectiveFormat, mFormat, mInfo, and sf_subtype_to_effective_format().

Here is the call graph for this function:

◆ ~PCMImportFileHandle()

PCMImportFileHandle::~PCMImportFileHandle ( )

Definition at line 585 of file ImportPCM.cpp.

586{

587}

Member Function Documentation

◆ GetFileDescription()

TranslatableString PCMImportFileHandle::GetFileDescription ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 202 of file ImportPCM.cpp.

{
   // Library strings
   // See the major_formats and subtype_formats tables in command.c in
   // libsndfile for this list of possibilities
 
using Unevaluated = decltype(
   /* major_formats */
     XO("AIFF (Apple/SGI)")
   , XO("AU (Sun/NeXT)")
   , XO("AVR (Audio Visual Research)")
   , XO("CAF (Apple Core Audio File)")
   /* i18n-hint: "codec" is short for a "coder-decoder" algorithm */
   , XO("FLAC (FLAC Lossless Audio Codec)")
   , XO("HTK (HMM Tool Kit)")
   , XO("IFF (Amiga IFF/SVX8/SV16)")
   , XO("MAT4 (GNU Octave 2.0 / Matlab 4.2)")
   , XO("MAT5 (GNU Octave 2.1 / Matlab 5.0)")
   , XO("MPC (Akai MPC 2k)")
   , XO("OGG (OGG Container format)")
   , XO("PAF (Ensoniq PARIS)")
   , XO("PVF (Portable Voice Format)")
   , XO("RAW (header-less)")
   , XO("RF64 (RIFF 64)")
   , XO("SD2 (Sound Designer II)")
   , XO("SDS (Midi Sample Dump Standard)")
   , XO("SF (Berkeley/IRCAM/CARL)")
   , XO("VOC (Creative Labs)")
   , XO("W64 (SoundFoundry WAVE 64)")
   , XO("WAV (Microsoft)")
   , XO("WAV (NIST Sphere)")
   , XO("WAVEX (Microsoft)")
   , XO("WVE (Psion Series 3)")
   , XO("XI (FastTracker 2)")
);
 
using Unevaluated2 = decltype(
   /* subtype_formats */
     XO("Signed 8 bit PCM")
   , XO("Signed 16 bit PCM")
   , XO("Signed 24 bit PCM")
   , XO("Signed 32 bit PCM")
   , XO("Unsigned 8 bit PCM")
   , XO("32 bit float")
   , XO("64 bit float")
   , XO("U-Law")
   , XO("A-Law")
   , XO("IMA ADPCM")
   , XO("Microsoft ADPCM")
   , XO("GSM 6.10")
   , XO("32kbs G721 ADPCM")
   , XO("24kbs G723 ADPCM")
   , XO("12 bit DWVW")
   , XO("16 bit DWVW")
   , XO("24 bit DWVW")
   , XO("VOX ADPCM")
   , XO("16 bit DPCM")
   , XO("8 bit DPCM")
   , XO("Vorbis")
);
 
   auto untranslated = SFCall<wxString>(sf_header_name, mInfo.format);
   return TranslatableString{
      untranslated, {} };
}

References mInfo, sf_header_name(), and XO().

Here is the call graph for this function:

◆ GetFileUncompressedBytes()

auto PCMImportFileHandle::GetFileUncompressedBytes ( )

overridevirtual

Implements ImportFileHandle.

Definition at line 268 of file ImportPCM.cpp.

{
   return mInfo.frames * mInfo.channels * SAMPLE_SIZE(mFormat);
}

References SAMPLE_SIZE.

◆ GetStreamCount()

wxInt32 PCMImportFileHandle::GetStreamCount ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 88 of file ImportPCM.cpp.

88{ return 1; }

◆ GetStreamInfo()

const TranslatableStrings & PCMImportFileHandle::GetStreamInfo ( )

inlineoverridevirtual

Implements ImportFileHandle.

Definition at line 90 of file ImportPCM.cpp.

   {
      static TranslatableStrings empty;
      return empty;
   }

◆ Import()

void PCMImportFileHandle::Import	(	ImportProgressListener &	progressListener,
		WaveTrackFactory *	trackFactory,
		TrackHolders &	outTracks,
		Tags *	tags
	)

overridevirtual

Implements ImportFileHandle.

Definition at line 280 of file ImportPCM.cpp.

{
   BeginImport();
   
   outTracks.clear();
 
   wxASSERT(mFile.get());
 
   auto trackList = ImportUtils::NewWaveTrack(
      *trackFactory,
      mInfo.channels,
      mFormat,
      mInfo.samplerate);
 
   auto fileTotalFrames =
      (sampleCount)mInfo.frames; // convert from sf_count_t
   auto maxBlockSize = (*trackList->Any<WaveTrack>().begin())->GetMaxBlockSize();
 
   {
      // Otherwise, we're in the "copy" mode, where we read in the actual
      // samples from the file and store our own local copy of the
      // samples in the tracks.
 
      // PRL:  guard against excessive memory buffer allocation in case of many channels
      using type = decltype(maxBlockSize);
      if (mInfo.channels < 1)
      {
         progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
         return;
      }
      auto maxBlock = std::min(maxBlockSize,
         std::numeric_limits<type>::max() /
            (mInfo.channels * SAMPLE_SIZE(mFormat))
      );
      if (maxBlock < 1)
      {
         progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
         return;
      }
      
      SampleBuffer srcbuffer, buffer;
      wxASSERT(mInfo.channels >= 0);
      while (NULL == srcbuffer.Allocate(maxBlock * mInfo.channels, mFormat).ptr() ||
             NULL == buffer.Allocate(maxBlock, mFormat).ptr())
      {
         maxBlock /= 2;
         if (maxBlock < 1)
         {
            progressListener.OnImportResult(ImportProgressListener::ImportResult::Error);
            return;
         }
      }
 
      decltype(fileTotalFrames) framescompleted = 0;
 
      long block;
      do {
         block = maxBlock;
 
         if (mFormat == int16Sample)
            block = SFCall<sf_count_t>(sf_readf_short, mFile.get(), (short *)srcbuffer.ptr(), block);
         //import 24 bit int as float and have the append function convert it.  This is how PCMAliasBlockFile worked too.
         else
            block = SFCall<sf_count_t>(sf_readf_float, mFile.get(), (float *)srcbuffer.ptr(), block);
 
         if(block < 0 || block > (long)maxBlock) {
            wxASSERT(false);
            block = maxBlock;
         }
 
         if (block) {
            unsigned c = 0;
            ImportUtils::ForEachChannel(*trackList, [&](auto& channel)
            {
               if (mFormat==int16Sample) {
                  for(int j=0; j<block; j++)
                     ((short *)buffer.ptr())[j] =
                        ((short *)srcbuffer.ptr())[mInfo.channels*j+c];
               }
               else {
                  for(int j=0; j<block; j++)
                     ((float *)buffer.ptr())[j] =
                        ((float *)srcbuffer.ptr())[mInfo.channels*j+c];
               }
 
               channel.AppendBuffer(
                  buffer.ptr(),
                  (mFormat == int16Sample) ? int16Sample : floatSample,
                  block, 1, mEffectiveFormat
               );
               ++c;
            });
            framescompleted += block;
         }
         if(fileTotalFrames > 0)
            progressListener.OnImportProgress(framescompleted.as_double() / fileTotalFrames.as_double());
      } while (block > 0 && !IsCancelled() && !IsStopped());
   }
 
   if(IsCancelled())
   {
      progressListener.OnImportResult(ImportProgressListener::ImportResult::Cancelled);
      return;
   }
 
   ImportUtils::FinalizeImport(outTracks, trackList);
 
   const char *str;
 
   str = sf_get_string(mFile.get(), SF_STR_TITLE);
   if (str) {
      tags->SetTag(TAG_TITLE, UTF8CTOWX(str));
   }
 
   str = sf_get_string(mFile.get(), SF_STR_ALBUM);
   if (str) {
      tags->SetTag(TAG_ALBUM, UTF8CTOWX(str));
   }
 
   str = sf_get_string(mFile.get(), SF_STR_ARTIST);
   if (str) {
      tags->SetTag(TAG_ARTIST, UTF8CTOWX(str));
   }
 
   str = sf_get_string(mFile.get(), SF_STR_COMMENT);
   if (str) {
      tags->SetTag(TAG_COMMENTS, UTF8CTOWX(str));
   }
 
   str = sf_get_string(mFile.get(), SF_STR_DATE);
   if (str) {
      tags->SetTag(TAG_YEAR, UTF8CTOWX(str));
   }
 
   str = sf_get_string(mFile.get(), SF_STR_COPYRIGHT);
   if (str) {
      tags->SetTag(TAG_COPYRIGHT, UTF8CTOWX(str));
   }
 
   str = sf_get_string(mFile.get(), SF_STR_SOFTWARE);
   if (str) {
      tags->SetTag(TAG_SOFTWARE, UTF8CTOWX(str));
   }
 
   str = sf_get_string(mFile.get(), SF_STR_TRACKNUMBER);
   if (str) {
      tags->SetTag(TAG_TRACK, UTF8CTOWX(str));
   }
 
   str = sf_get_string(mFile.get(), SF_STR_GENRE);
   if (str) {
      tags->SetTag(TAG_GENRE, UTF8CTOWX(str));
   }
 
#if defined(USE_LIBID3TAG)
   if (((mInfo.format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AIFF) ||
       ((mInfo.format & SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV)) {
      wxFFile f(GetFilename(), wxT("rb"));
      if (f.IsOpened()) {
         char id[5];
         wxUint32 len;
 
         id[4] = '\0';
 
         f.Seek(12);        // Skip filetype, length, and formtype
 
         while (!f.Error()) {
            f.Read(id, 4);    // Get chunk type
            if (f.Eof()) {
               break;
            }
            f.Read(&len, 4);
            if((mInfo.format & SF_FORMAT_TYPEMASK) == SF_FORMAT_AIFF)
               len = wxUINT32_SWAP_ON_LE(len);
 
            if (wxStricmp(id, "ID3 ") != 0) {  // must be case insensitive
               f.Seek(len + (len & 0x01), wxFromCurrent);
               continue;
            }
 
 
            id3_tag_holder tp;
            {
               ArrayOf<id3_byte_t> buffer{ len };
               if (!buffer) {
                  break;
               }
 
               f.Read(buffer.get(), len);
               tp.reset( id3_tag_parse(buffer.get(), len) );
            }
 
            if (!tp) {
               break;
            }
 
            // Loop through all frames
            bool have_year = false;
            for (int i = 0; i < (int) tp->nframes; i++) {
               struct id3_frame *frame = tp->frames[i];
 
               // wxPrintf("ID: %08x '%4s'\n", (int) *(int *)frame->id, frame->id);
               // wxPrintf("Desc: %s\n", frame->description);
               // wxPrintf("Num fields: %d\n", frame->nfields);
 
               // for (int j = 0; j < (int) frame->nfields; j++) {
               //    wxPrintf("field %d type %d\n", j, frame->fields[j].type );
               //    if (frame->fields[j].type == ID3_FIELD_TYPE_STRINGLIST) {
               //       wxPrintf("num strings %d\n", frame->fields[j].stringlist.nstrings);
               //    }
               // }
 
               wxString n, v;
 
               // Determine the tag name
               if (strcmp(frame->id, ID3_FRAME_TITLE) == 0) {
                  n = TAG_TITLE;
               }
               else if (strcmp(frame->id, ID3_FRAME_ARTIST) == 0) {
                  n = TAG_ARTIST;
               }
               else if (strcmp(frame->id, ID3_FRAME_ALBUM) == 0) {
                  n = TAG_ALBUM;
               }
               else if (strcmp(frame->id, ID3_FRAME_TRACK) == 0) {
                  n = TAG_TRACK;
               }
               else if (strcmp(frame->id, ID3_FRAME_YEAR) == 0) {
                  // LLL:  When libid3tag encounters the "TYER" tag, it converts it to a
                  //       "ZOBS" (obsolete) tag and adds a "TDRC" tag at the end of the
                  //       list of tags using the first 4 characters of the "TYER" tag.
                  //       Since we write both the "TDRC" and "TYER" tags, the "TDRC" tag
                  //       will always be encountered first in the list.  We want use it
                  //       since the converted "TYER" tag may have been truncated.
                  if (have_year) {
                     continue;
                  }
                  n = TAG_YEAR;
                  have_year = true;
               }
               else if (strcmp(frame->id, ID3_FRAME_COMMENT) == 0) {
                  n = TAG_COMMENTS;
               }
               else if (strcmp(frame->id, ID3_FRAME_GENRE) == 0) {
                  n = TAG_GENRE;
               }
               else {
                  // Use frame description as default tag name.  The descriptions
                  // may include several "meanings" separated by "/" characters, so
                  // we just use the first meaning
                  n = UTF8CTOWX(frame->description).BeforeFirst(wxT('/'));
               }
 
               const id3_ucs4_t *ustr = NULL;
 
               if (n == TAG_COMMENTS) {
                  ustr = id3_field_getfullstring(&frame->fields[3]);
               }
               else if (frame->nfields == 3) {
                  ustr = id3_field_getstring(&frame->fields[1]);
                  if (ustr) {
                     // Is this duplication really needed?
                     MallocString<> convStr{ (char *)id3_ucs4_utf8duplicate(ustr) };
                     n = UTF8CTOWX(convStr.get());
                  }
 
                  ustr = id3_field_getstring(&frame->fields[2]);
               }
               else if (frame->nfields >= 2) {
                  ustr = id3_field_getstrings(&frame->fields[1], 0);
               }
 
               if (ustr) {
                  // Is this duplication really needed?
                  MallocString<> convStr{ (char *)id3_ucs4_utf8duplicate(ustr) };
                  v = UTF8CTOWX(convStr.get());
               }
 
               if (!n.empty() && !v.empty()) {
                  tags->SetTag(n, v);
               }
            }
 
            // Convert v1 genre to name
            if (tags->HasTag(TAG_GENRE)) {
               long g = -1;
               if (tags->GetTag(TAG_GENRE).ToLong(&g)) {
                  tags->SetTag(TAG_GENRE, tags->GetGenre(g));
               }
            }
 
            break;
         }
      }
   }
#endif
 
   progressListener.OnImportResult(IsStopped()
                                   ? ImportProgressListener::ImportResult::Stopped
                                   : ImportProgressListener::ImportResult::Success);
}

References SampleBuffer::Allocate(), ImportFileHandleEx::BeginImport(), ImportProgressListener::Cancelled, ImportProgressListener::Error, ImportUtils::FinalizeImport(), floatSample, ImportUtils::ForEachChannel(), ImportFileHandleEx::GetFilename(), Tags::GetGenre(), Tags::GetTag(), Tags::HasTag(), int16Sample, ImportFileHandleEx::IsCancelled(), ImportFileHandleEx::IsStopped(), anonymous_namespace{StaffPadTimeAndPitch.cpp}::maxBlockSize, mEffectiveFormat, mFile, mFormat, min(), mInfo, ImportUtils::NewWaveTrack(), ImportProgressListener::OnImportProgress(), ImportProgressListener::OnImportResult(), SampleBuffer::ptr(), SAMPLE_SIZE, Tags::SetTag(), ImportProgressListener::Stopped, str, ImportProgressListener::Success, TAG_ALBUM, TAG_ARTIST, TAG_COMMENTS, TAG_COPYRIGHT, TAG_GENRE, TAG_SOFTWARE, TAG_TITLE, TAG_TRACK, TAG_YEAR, UTF8CTOWX, and wxT().

Here is the call graph for this function:

◆ SetStreamUsage()

void PCMImportFileHandle::SetStreamUsage	(	wxInt32	WXUNUSEDStreamID,
		bool	WXUNUSEDUse
	)

inlineoverride

Definition at line 96 of file ImportPCM.cpp.

97 {}

Member Data Documentation

◆ mEffectiveFormat

sampleFormat PCMImportFileHandle::mEffectiveFormat

private

Definition at line 102 of file ImportPCM.cpp.

Referenced by Import(), and PCMImportFileHandle().

◆ mFile

SFFile PCMImportFileHandle::mFile

private

Definition at line 100 of file ImportPCM.cpp.

Referenced by Import().

◆ mFormat

sampleFormat PCMImportFileHandle::mFormat

private

Definition at line 103 of file ImportPCM.cpp.

Referenced by Import(), and PCMImportFileHandle().

◆ mInfo

const SF_INFO PCMImportFileHandle::mInfo

private

Definition at line 101 of file ImportPCM.cpp.

Referenced by GetFileDescription(), Import(), and PCMImportFileHandle().

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

ImportPCM.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PCMImportFileHandle()

◆ ~PCMImportFileHandle()

Member Function Documentation

◆ GetFileDescription()

◆ GetFileUncompressedBytes()

◆ GetStreamCount()

◆ GetStreamInfo()

◆ Import()

◆ SetStreamUsage()

Member Data Documentation

◆ mEffectiveFormat

◆ mFile

◆ mFormat

◆ mInfo