ImportLOF.cpp

Go to the documentation of this file.

/**********************************************************************
 
  Audacity: A Digital Audio Editor
 
  ImportLOF.h
 
  David I. Murray
  Leland Lucius
 
*//****************************************************************//****************************************************************//*******************************************************************/
 
 
 
#include <wx/textfile.h>
#include <wx/tokenzr.h>
 
#ifdef USE_MIDI
#include "ImportMIDI.h"
#endif // USE_MIDI
#include "FileNames.h"
#include "WaveTrack.h"
#include "ImportPlugin.h"
#include "Import.h"
#include "Project.h"
#include "ProjectHistory.h"
#include "../ProjectManager.h"
#include "../ProjectWindow.h"
#include "../ProjectWindows.h"
#include "Prefs.h"
#include "AudacityMessageBox.h"
#include "ProgressDialog.h"
 
#define BINARY_FILE_CHECK_BUFFER_SIZE 1024
 
#define DESC XO("List of Files in basic text format")
 
static const auto exts = {
   wxT("lof")
};
 
class LOFImportPlugin final : public ImportPlugin
{
public:
   LOFImportPlugin()
   :  ImportPlugin( FileExtensions( exts.begin(), exts.end() ) )
   {
   }
 
   ~LOFImportPlugin() { }
 
   wxString GetPluginStringID() override { return wxT("lof"); }
   TranslatableString GetPluginFormatDescription() override;
   std::unique_ptr<ImportFileHandle> Open(
      const FilePath &Filename, AudacityProject *pProject) override;
};
 
 
class LOFImportFileHandle final : public ImportFileHandle
{
public:
   LOFImportFileHandle( AudacityProject *pProject,
      const FilePath & name, std::unique_ptr<wxTextFile> &&file);
   ~LOFImportFileHandle();
 
   TranslatableString GetFileDescription() override;
   ByteCount GetFileUncompressedBytes() override;
   ProgressResult Import(WaveTrackFactory *trackFactory, TrackHolders &outTracks,
              Tags *tags) override;
 
   wxInt32 GetStreamCount() override { return 1; }
 
   const TranslatableStrings &GetStreamInfo() override
   {
      static TranslatableStrings empty;
      return empty;
   }
 
   void SetStreamUsage(wxInt32 WXUNUSED(StreamID), bool WXUNUSED(Use)) override
   {}
 
private:
   // Takes a line of text in lof file and interprets it and opens files
   void lofOpenFiles(wxString* ln);
   void doDurationAndScrollOffset();
 
   std::unique_ptr<wxTextFile> mTextFile;
   wxFileName mLOFFileName;  
   AudacityProject *mProject{};
 
   // In order to know whether or not to create a NEW window
   int nFilesInGroup{ 0 };
 
   // In order to zoom in, it must be done after files are opened
   bool              callDurationFactor{ false };
   double            durationFactor{ 1 };
 
   // In order to offset scrollbar, it must be done after files are opened
   bool              callScrollOffset{ false };
   double            scrollOffset{ 0 };
};
 
LOFImportFileHandle::LOFImportFileHandle( AudacityProject *pProject,
   const FilePath & name, std::unique_ptr<wxTextFile> &&file)
:  ImportFileHandle(name)
   , mTextFile(std::move(file))
   , mLOFFileName{name}
   , mProject{ pProject }
{
}
 
TranslatableString LOFImportPlugin::GetPluginFormatDescription()
{
    return DESC;
}
 
std::unique_ptr<ImportFileHandle> LOFImportPlugin::Open(
   const FilePath &filename, AudacityProject *pProject)
{
   // Check if it is a text file.
   {
      wxFile binaryFile;
      if (!binaryFile.Open(filename))
         return nullptr; // File not found
 
      char buf[BINARY_FILE_CHECK_BUFFER_SIZE];
      int count = binaryFile.Read(buf, BINARY_FILE_CHECK_BUFFER_SIZE);
 
      bool isTextFile = false;
      const std::string lofToken("file");
 
      // At least we should get a size more than: <token> + <space> + <filename>.
      if (count > (lofToken.length() + sizeof(' ') + 1))
      {
          // Audacity can import list from LOF only with BOM or ASCII,
          // each other text (like unicode without BOM, bin, etc) can't be recognized.
 
          // UTF-16 BOM checker.
          auto IsUtf16_BE = [](const char* str) -> bool
          {
              return str[0] == static_cast<char>(0xFE) && str[1] == static_cast<char>(0xFF);
          };
          auto IsUtf16_LE = [](const char* str) -> bool
          {
              return str[0] == static_cast<char>(0xFF) && str[1] == static_cast<char>(0xFE);
          };
 
          // UTF-32 BOM checker.
          auto IsUtf32_BE = [](const char* str) -> bool
          {
              return str[0] == static_cast<char>(0x00) &&
                     str[1] == static_cast<char>(0x00) &&
                     str[2] == static_cast<char>(0xFE) &&
                     str[3] == static_cast<char>(0xFF);
          };
          auto IsUtf32_LE = [](const char* str) -> bool
          {
              return str[0] == static_cast<char>(0xFF) &&
                     str[1] == static_cast<char>(0xFE) &&
                     str[2] == static_cast<char>(0x00) &&
                     str[3] == static_cast<char>(0x00);
          };
 
          // Is unicode text file.
          if (IsUtf16_BE(buf) || IsUtf16_LE(buf) || IsUtf32_BE(buf) || IsUtf32_LE(buf))
          {
              isTextFile = true;
          }
          // Try parse as ASCII and UTF-8 text as ASCII too.
          else
          {
              buf[sizeof(buf) - 1] = '\0';
 
              std::string importedText(buf);
 
              if (importedText.find(lofToken) != std::string::npos)
                  isTextFile = true;
          }
      }
 
      if (!isTextFile)
      {
          binaryFile.Close();
          return nullptr;
      }
   }
 
   // Now open the file again as text file
   auto file = std::make_unique<wxTextFile>(filename);
   file->Open();
 
   if (!file->IsOpened())
      return nullptr;
 
   return std::make_unique<LOFImportFileHandle>(
      pProject, filename, std::move(file));
}
 
TranslatableString LOFImportFileHandle::GetFileDescription()
{
   return DESC;
}
 
auto LOFImportFileHandle::GetFileUncompressedBytes() -> ByteCount
{
   return 0;
}
 
ProgressResult LOFImportFileHandle::Import(
   WaveTrackFactory * WXUNUSED(trackFactory), TrackHolders &outTracks,
   Tags * WXUNUSED(tags))
{
   // Unlike other ImportFileHandle subclasses, this one never gives any tracks
   // back to the caller.
   // Instead, it recursively calls AudacityProject::Import for each file listed
   // in the .lof file.
   // Each importation creates a NEW undo state.
   // If there is an error or exception during one of them, only that one's
   // side effects are rolled back, and the rest of the import list is skipped.
   // The file may have "window" directives that cause NEW AudacityProjects
   // to be created, and the undo states are pushed onto the latest project.
   // If a project is created but the first file import into it fails, destroy
   // the project.
 
   outTracks.clear();
 
   wxASSERT(mTextFile->IsOpened());
 
   if(mTextFile->Eof())
   {
      mTextFile->Close();
      return ProgressResult::Failed;
   }
 
   wxString line = mTextFile->GetFirstLine();
 
   while (!mTextFile->Eof())
   {
      lofOpenFiles(&line);
      line = mTextFile->GetNextLine();
   }
 
   // for last line
   lofOpenFiles(&line);
 
   if(!mTextFile->Close())
      return ProgressResult::Failed;
 
   // set any duration/offset factors for last window, as all files were called
   doDurationAndScrollOffset();
 
   return ProgressResult::Success;
}
 
static Importer::RegisteredImportPlugin registered{ "LOF",
   std::make_unique< LOFImportPlugin >()
};
 
#ifdef USE_MIDI
// return null on failure; if success, return the given project, or a NEW
// one, if the given was null; create no NEW project if failure
static AudacityProject *DoImportMIDIProject(
   AudacityProject *pProject, const FilePath &fileName)
{
   AudacityProject *pNewProject {};
   if ( !pProject )
      pProject = pNewProject = ProjectManager::New();
   auto cleanup = finally( [&]
      { if ( pNewProject ) GetProjectFrame( *pNewProject ).Close(true); } );
   
   if ( DoImportMIDI( *pProject, fileName ) ) {
      pNewProject = nullptr;
      return pProject;
   }
   else
      return nullptr;
}
#endif
 
void LOFImportFileHandle::lofOpenFiles(wxString* ln)
{
   wxStringTokenizer tok(*ln, wxT(" "));
   wxStringTokenizer temptok1(*ln, wxT("\""));
   wxStringTokenizer temptok2(*ln, wxT(" "));
   int tokenplace = 0;
 
   wxString targetfile;
   wxString tokenholder = tok.GetNextToken();
 
 
   if (tokenholder.IsSameAs(wxT("window"), false))
   {
      // set any duration/offset factors for last window, as all files were called
      doDurationAndScrollOffset();
 
      if (nFilesInGroup > 0 )
         // Cause a project to be created with the next import
         mProject = nullptr;
 
      nFilesInGroup = 0;
 
      while (tok.HasMoreTokens())
      {
         tokenholder = tok.GetNextToken();
 
         if (tokenholder.IsSameAs(wxT("offset"), false))
         {
            if (tok.HasMoreTokens())
               tokenholder = tok.GetNextToken();
 
            if (Internat::CompatibleToDouble(tokenholder, &scrollOffset))
            {
               callScrollOffset = true;
            }
            else
            {
               AudacityMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid window offset in LOF file."),
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("LOF Error"),
                  wxOK | wxCENTRE);
            }
 
            if (tok.HasMoreTokens())
               tokenholder = tok.GetNextToken();
         }
 
         if (tokenholder.IsSameAs(wxT("duration"), false))
         {
            if (tok.HasMoreTokens())
               tokenholder = tok.GetNextToken();
 
            if (Internat::CompatibleToDouble(tokenholder, &durationFactor))
            {
               callDurationFactor = true;
            }
            else
            {
               AudacityMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid duration in LOF file."),
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("LOF Error"),
                  wxOK | wxCENTRE);
            }
         }     // End if statement
 
         if (tokenholder == wxT("#"))
         {
            // # indicates comments; ignore line
            tok = wxStringTokenizer(wxT(""), wxT(" "));
         }
      }     // End while loop
   }        // End if statement handling "window" lines
 
   else if (tokenholder.IsSameAs(wxT("file"), false))
   {
      nFilesInGroup++;
      // To identify filename and open it
      tokenholder = temptok1.GetNextToken();
      wxString targettoken = temptok1.GetNextToken();
      targetfile = targettoken;
 
      // If path is relative, make absolute path from LOF path
      if(!wxIsAbsolutePath(targetfile)) {
         wxFileName fName(targetfile);
         fName.Normalize(wxPATH_NORM_ALL, mLOFFileName.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR));
         if(fName.FileExists()) {
            targetfile = fName.GetFullPath();
         }
      }
 
      // Do recursive call to import
 
#ifdef USE_MIDI
      // If file is a midi
      if (FileNames::IsMidi(targetfile))
      {
         mProject = DoImportMIDIProject(mProject, targetfile);
      }
 
      // If not a midi, open audio file
      else
 
#else // !USE_MIDI
         /* if we don't have midi support, go straight on to opening as an
          * audio file. TODO: Some sort of message here? */
 
#endif // USE_MIDI
         mProject = ProjectManager::OpenProject( mProject, targetfile,
            true /* addtohistory */, true /* reuseNonemptyProject */ );
 
      // Set tok to right after filename
      temptok2.SetString(targettoken);
      tokenplace = temptok2.CountTokens();
 
      for (int i = 0; i < tokenplace; i++)
         tokenholder = tok.GetNextToken();
 
      if (tok.HasMoreTokens())
      {
         tokenholder = tok.GetNextToken();
 
         if (tokenholder == wxT("#"))
         {
            // # indicates comments; ignore line
            tok = wxStringTokenizer(wxT(""), wxT(" "));
         }
 
         if (tokenholder.IsSameAs(wxT("offset"), false))
         {
            if (tok.HasMoreTokens())
               tokenholder = tok.GetNextToken();
            double offset;
 
            // handle an "offset" specifier
            if (!mProject)
               // there was an import error,
               // presumably with its own error message
               ;
            else if (Internat::CompatibleToDouble(tokenholder, &offset))
            {
               auto &tracks = TrackList::Get( *mProject );
               auto t = *tracks.Leaders().rbegin();
 
               // t is now the last track in the project, unless the import of
               // all tracks failed, in which case it will be null. In that
               // case we return because we cannot offset a non-existent track.
               if (t == NULL)
                  return;
#ifdef USE_MIDI
               if (targetfile.AfterLast(wxT('.')).IsSameAs(wxT("mid"), false) ||
                   targetfile.AfterLast(wxT('.')).IsSameAs(wxT("midi"), false))
               {
                  AudacityMessageBox(
                     XO("MIDI tracks cannot be offset individually, only audio files can be."),
                     XO("LOF Error"),
                     wxOK | wxCENTRE);
               }
               else
#endif
               {
                  for (auto channel : TrackList::Channels(t))
                     channel->SetOffset(offset);
               }
 
               // Amend the undo transaction made by import
               ProjectHistory::Get( *mProject ).ModifyState(false);
            } // end of converting "offset" argument
            else
            {
               AudacityMessageBox(
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("Invalid track offset in LOF file."),
                  /* i18n-hint: You do not need to translate "LOF" */
                  XO("LOF Error"),
                  wxOK | wxCENTRE);
            }
         }     // End if statement for "offset" parameters
      }     // End if statement (more tokens after file name)
   }     // End if statement "file" lines
 
   else if (tokenholder == wxT("#"))
   {
      // # indicates comments; ignore line
      tok = wxStringTokenizer(wxT(""), wxT(" "));
   }
   else
   {
      // Couldn't parse a line
   }
}
 
void LOFImportFileHandle::doDurationAndScrollOffset()
{
   if (!mProject)
      return;
 
   callScrollOffset = callScrollOffset && (scrollOffset != 0);
   bool doSomething = callDurationFactor || callScrollOffset;
 
   if (callDurationFactor)
   {
      double longestDuration = TrackList::Get( *mProject ).GetEndTime();
      ProjectWindow::Get( *mProject ).ZoomBy(longestDuration / durationFactor);
      callDurationFactor = false;
   }
 
   if (callScrollOffset)
   {
      ProjectWindow::Get( *mProject ).TP_ScrollWindow(scrollOffset);
      callScrollOffset = false;
   }
 
   if (doSomething)
      // Amend last undo state
      ProjectHistory::Get( *mProject ).ModifyState(false);
}
 
LOFImportFileHandle::~LOFImportFileHandle()
{
}