ImportRaw.cpp File Reference

Functions for guessing audio type and attempting to read from unknown sample audio data. Implements ImportRawDialog. More...

#include "ImportRaw.h"
#include "ImportPlugin.h"
#include "ImportUtils.h"
#include "AudioIOBase.h"
#include "FileFormats.h"
#include "Prefs.h"
#include "ProjectRate.h"
#include "SelectFile.h"
#include "ShuttleGui.h"
#include "UserException.h"
#include "WaveTrack.h"
#include "ProgressDialog.h"
#include <cmath>
#include <stdint.h>
#include <vector>
#include <wx/crt.h>
#include <wx/defs.h>
#include <wx/button.h>
#include <wx/choice.h>
#include <wx/combobox.h>
#include <wx/panel.h>
#include <wx/stattext.h>
#include <wx/textctrl.h>
#include "FormatClassifier.h"
#include "sndfile.h"

Include dependency graph for ImportRaw.cpp:

Go to the source code of this file.

Classes
class	ImportRawDialog
	ImportRawDialog prompts you with options such as endianness and sample size to help you importing data of an unknown format. More...

Enumerations
enum	{ ChoiceID = 9000 , PlayID , DetectID }

Functions
void	ImportRaw (const AudacityProject &project, wxWindow *parent, const wxString &fileName, WaveTrackFactory *trackFactory, TrackHolders &outTracks)
static int	getEndianChoice (int sfFormat)

Detailed Description

Functions for guessing audio type and attempting to read from unknown sample audio data. Implements ImportRawDialog.

Definition in file ImportRaw.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
ChoiceID
PlayID
DetectID

Definition at line 280 of file ImportRaw.cpp.

     {
   ChoiceID = 9000,
   PlayID,
   DetectID,
};

Function Documentation

getEndianChoice()

static int getEndianChoice ( int  sfFormat )

static

Definition at line 260 of file ImportRaw.cpp.

                                         {
   switch (sfFormat & SF_FORMAT_ENDMASK)
   {
      default:
      case SF_ENDIAN_FILE:
         return 0;
      case SF_ENDIAN_LITTLE:
         return 1;
      case SF_ENDIAN_BIG:
         return 2;
      case SF_ENDIAN_CPU:
         return 3;
   }
}

Referenced by ImportRawDialog::ImportRawDialog(), and ImportRawDialog::OnDetect().

Here is the caller graph for this function:

ImportRaw()

void ImportRaw	(	const AudacityProject &	project,
		wxWindow *	parent,
		const wxString &	fileName,
		WaveTrackFactory *	trackFactory,
		TrackHolders &	outTracks
	)

Definition at line 106 of file ImportRaw.cpp.

{
   outTracks.clear();
 
   TrackListHolder trackList;
   auto updateResult = ProgressResult::Success;
 
   {
      // On first run, set default sample rate from project rate
      if (ImportRawDialog::mRate < 100.)
         ImportRawDialog::mRate = ProjectRate::Get(project).GetRate();
 
      ImportRawDialog dlog(parent, fileName);
      dlog.ShowModal();
      if (!dlog.GetReturnCode())
         return;
 
      const int encoding = dlog.mEncoding;
      unsigned numChannels = dlog.mChannels;
      double rate = dlog.mRate;
      sf_count_t offset = (sf_count_t)dlog.mOffset;
      double percent = dlog.mPercent;
 
      SF_INFO sndInfo = { 0 };
      sndInfo.samplerate = (int)rate;
      sndInfo.channels = (int)numChannels;
      sndInfo.format = encoding | SF_FORMAT_RAW;
 
      wxFile f;   // will be closed when it goes out of scope
      SFFile sndFile;
 
      if (f.Open(fileName)) {
         // Even though there is an sf_open() that takes a filename, use the one that
         // takes a file descriptor since wxWidgets can open a file with a Unicode name and
         // libsndfile can't (under Windows).
         sndFile.reset(SFCall<SNDFILE*>(sf_open_fd, f.fd(), SFM_READ, &sndInfo, FALSE));
      }
 
      if (!sndFile){
         char str[1000];
         sf_error_str((SNDFILE *)NULL, str, 1000);
         wxPrintf("%s\n", str);
 
         throw FileException{ FileException::Cause::Open, fileName };
      }
 
 
      {
         int result = sf_command(sndFile.get(), SFC_SET_RAW_START_OFFSET, &offset, sizeof(offset));
         if (result != 0) {
            char str[1000];
            sf_error_str(sndFile.get(), str, 1000);
            wxPrintf("%s\n", str);
 
            throw FileException{ FileException::Cause::Read, fileName };
         }
      }
      SFCall<sf_count_t>(sf_seek, sndFile.get(), 0, SEEK_SET);
 
      auto totalFrames =
         // fraction of a sf_count_t value
         (sampleCount)(sndInfo.frames * percent / 100.0);
 
      //
      // Sample format:
      //
      // 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.
      //
 
      const auto format = ImportUtils::ChooseFormat(
         sf_subtype_to_effective_format(encoding));
 
      trackList = trackFactory->CreateMany(numChannels, format, rate);
 
      const auto maxBlockSize = (*trackList->Any<WaveTrack>().begin())->GetMaxBlockSize();
 
      SampleBuffer srcbuffer(maxBlockSize * numChannels, format);
      SampleBuffer buffer(maxBlockSize, format);
 
      decltype(totalFrames) framescompleted = 0;
      if (totalFrames < 0) {
         wxASSERT(false);
         totalFrames = 0;
      }
 
      auto msg = XO("Importing %s").Format( wxFileName::FileName(fileName).GetFullName() );
 
      /* i18n-hint: 'Raw' means 'unprocessed' here and should usually be translated.*/
      ProgressDialog progress(XO("Import Raw"), msg);
 
      size_t block;
      do {
         block =
            limitSampleBufferSize( maxBlockSize, totalFrames - framescompleted );
 
         sf_count_t sf_result;
         if (format == int16Sample)
            sf_result = SFCall<sf_count_t>(sf_readf_short, sndFile.get(), (short *)srcbuffer.ptr(), block);
         else
            sf_result = SFCall<sf_count_t>(sf_readf_float, sndFile.get(), (float *)srcbuffer.ptr(), block);
 
         if (sf_result >= 0) {
            block = sf_result;
         }
         else {
            // This is not supposed to happen, sndfile.h says result is always
            // a count, not an invalid value for error
            throw FileException{ FileException::Cause::Read, fileName };
         }
 
         if (block) {
            size_t c = 0;
            ImportUtils::ForEachChannel(*trackList, [&](auto& channel)
            {
               if (format == int16Sample) {
                  for (size_t j = 0; j < block; ++j)
                     ((short *)buffer.ptr())[j] =
                     ((short *)srcbuffer.ptr())[numChannels * j + c];
               }
               else {
                  for (size_t j = 0; j < block; ++j)
                     ((float *)buffer.ptr())[j] =
                     ((float *)srcbuffer.ptr())[numChannels * j + c];
               }
 
               channel.AppendBuffer(buffer.ptr(),
                  ((format == int16Sample) ? int16Sample : floatSample), block,
                  1, sf_subtype_to_effective_format(encoding));
               ++c;
            });
            framescompleted += block;
         }
 
         updateResult = progress.Update(
            framescompleted.as_long_long(),
            totalFrames.as_long_long()
         );
         if (updateResult != ProgressResult::Success)
            break;
         
      } while (block > 0 && framescompleted < totalFrames);
   }
 
   if (updateResult == ProgressResult::Failed || updateResult == ProgressResult::Cancelled)
      throw UserException{};
 
   ImportUtils::FinalizeImport(outTracks, move(*trackList));
}

References details::begin(), ImportUtils::ChooseFormat(), WaveTrackFactory::CreateMany(), floatSample, ImportUtils::ForEachChannel(), anonymous_namespace{ExportPCM.cpp}::format, ProjectRate::Get(), ProjectRate::GetRate(), int16Sample, limitSampleBufferSize(), anonymous_namespace{StaffPadTimeAndPitch.cpp}::maxBlockSize, ImportRawDialog::mChannels, ImportRawDialog::mEncoding, ImportRawDialog::mOffset, ImportRawDialog::mPercent, ImportRawDialog::mRate, FileException::Open, project, SampleBuffer::ptr(), FileException::Read, sf_subtype_to_effective_format(), str, BasicUI::Success, ProgressDialog::Update(), and XO().

Referenced by anonymous_namespace{FileMenus.cpp}::DoImport().

Here is the call graph for this function:

Here is the caller graph for this function: