double GetMidiSourceLengthPPQ (MediaItem_Take* take, bool accountPlayrateIfIgnoringProjTempo, bool* isMidiSource /*=NULL*/)
{
bool isMidi = false;
double length = 0;
if (take && IsMidi(take))
{
MediaItem* item = GetMediaItemTake_Item(take);
double itemStart = GetMediaItemInfo_Value(item, "D_POSITION");
double takeOffset = GetMediaItemTakeInfo_Value(take, "D_STARTOFFS");
double sourceLength = GetMediaItemTake_Source(take)->GetLength();
double startPPQ = MIDI_GetPPQPosFromProjTime(take, itemStart - takeOffset);
double endPPQ = MIDI_GetPPQPosFromProjTime(take, itemStart - takeOffset + sourceLength);
isMidi = true;
length = endPPQ - startPPQ;
if (accountPlayrateIfIgnoringProjTempo)
{
bool ignoreProjTempo;
if (GetMidiTakeTempoInfo(take, &ignoreProjTempo, NULL, NULL, NULL) && ignoreProjTempo)
length /= GetMediaItemTakeInfo_Value(take, "D_PLAYRATE");
}
}
WritePtr(isMidiSource, isMidi);
return length;
}
/******************************************************************************
* BR_MidiItemTimePos *
******************************************************************************/
BR_MidiItemTimePos::BR_MidiItemTimePos (MediaItem* item) :
item (item),
position (GetMediaItemInfo_Value(item, "D_POSITION")),
length (GetMediaItemInfo_Value(item, "D_LENGTH")),
timeBase (GetMediaItemInfo_Value(item, "C_BEATATTACHMODE")),
looped (!!GetMediaItemInfo_Value(item, "B_LOOPSRC")),
loopStart (-1),
loopEnd (-1),
loopedOffset (0)
{
// When restoring position and lenght, the only way to restore it for looped MIDI items is to use MIDI_SetItemExtents which will disable looping
// for the whole item. Since we have no idea what will happen before this->Restore() is called take data for active MIDI item right now instead of
// in this->Restore() (for example, if client calls SetIgnoreTempo() from BR_Util.h before restoring to disable "ignore project tempo" length of MIDI item source may change)
if (looped)
{
if (MediaItem_Take* activeTake = GetActiveTake(item))
{
double sourceLenPPQ = GetMidiSourceLengthPPQ(activeTake, true);
loopStart = MIDI_GetProjTimeFromPPQPos(activeTake, sourceLenPPQ); // we're not using MIDI_GetProjTimeFromPPQPos(activeTake, 0) because later we will use MIDI_SetItemExtents to make sure looped item
loopEnd = MIDI_GetProjTimeFromPPQPos(activeTake, sourceLenPPQ*2); // position info is restored and 0 PPQ in take could theoretically be behind project start in which case MIDI_SetItemExtents wont' work properly
loopedOffset = GetMediaItemTakeInfo_Value(activeTake, "D_STARTOFFS");
}
}
int takeCount = CountTakes(item);
for (int i = 0; i < takeCount; ++i)
{
MediaItem_Take* take = GetTake(item, i);
int noteCount, ccCount, textCount;
int midiEventCount = MIDI_CountEvts(take, ¬eCount, &ccCount, &textCount);
// In case of looped item, if active take wasn't midi, get looped position here for first MIDI take
if (looped && loopStart == -1 && loopEnd == -1 && IsMidi(take, NULL) && (midiEventCount > 0 || i == takeCount - 1))
{
double sourceLenPPQ = GetMidiSourceLengthPPQ(take, true);
loopStart = MIDI_GetProjTimeFromPPQPos(take, sourceLenPPQ);
loopEnd = MIDI_GetProjTimeFromPPQPos(take, sourceLenPPQ*2);
loopedOffset = GetMediaItemTakeInfo_Value(take, "D_STARTOFFS");
}
if (midiEventCount > 0)
{
savedMidiTakes.push_back(BR_MidiItemTimePos::MidiTake(take, noteCount, ccCount, textCount));
BR_MidiItemTimePos::MidiTake* midiTake = &savedMidiTakes.back();
for (int i = 0; i < noteCount; ++i)
midiTake->noteEvents.push_back(BR_MidiItemTimePos::MidiTake::NoteEvent(take, i));
for (int i = 0; i < ccCount; ++i)
midiTake->ccEvents.push_back(BR_MidiItemTimePos::MidiTake::CCEvent(take, i));
for (int i = 0; i < textCount; ++i)
midiTake->sysEvents.push_back(BR_MidiItemTimePos::MidiTake::SysEvent(take, i));
}
}
}
bool IsOpenInInlineEditor (MediaItem_Take* take)
{
bool inProject = false;
if (GetActiveTake(GetMediaItemTake_Item(take)) == take && IsMidi(take, &inProject) && inProject)
{
if (PCM_source* source = GetMediaItemTake_Source(take))
{
if (source->Extended(PCM_SOURCE_EXT_INLINEEDITOR, 0, 0, 0) > 0)
return true;
}
}
return false;
}
// returns number of tracks imported
bool Importer::Import(const wxString &fName,
TrackFactory *trackFactory,
TrackHolders &tracks,
Tags *tags,
wxString &errorMessage)
{
AudacityProject *pProj = GetActiveProject();
auto cleanup = valueRestorer( pProj->mbBusyImporting, true );
wxString extension = fName.AfterLast(wxT('.'));
// Always refuse to import MIDI, even though the FFmpeg plugin pretends to know how (but makes very bad renderings)
#ifdef USE_MIDI
// MIDI files must be imported, not opened
if (IsMidi(fName)) {
errorMessage.Printf(_("\"%s\" \nis a MIDI file, not an audio file. \nAudacity cannot open this type of file for playing, but you can\nedit it by clicking File > Import > MIDI."), fName);
return false;
}
#endif
using ImportPluginPtrs = std::vector< ImportPlugin* >;
// This list is used to call plugins in correct order
ImportPluginPtrs importPlugins;
// This list is used to remember plugins that should have been compatible with the file.
ImportPluginPtrs compatiblePlugins;
// If user explicitly selected a filter,
// then we should try importing via corresponding plugin first
wxString type = gPrefs->Read(wxT("/LastOpenType"),wxT(""));
// Not implemented (yet?)
wxString mime_type = wxT("*");
// First, add user-selected filter
bool usersSelectionOverrides;
gPrefs->Read(wxT("/ExtendedImport/OverrideExtendedImportByOpenFileDialogChoice"), &usersSelectionOverrides, false);
wxLogDebug(wxT("LastOpenType is %s"),type);
wxLogDebug(wxT("OverrideExtendedImportByOpenFileDialogChoice is %i"),usersSelectionOverrides);
if (usersSelectionOverrides)
{
for (const auto &plugin : mImportPluginList)
{
if (plugin->GetPluginFormatDescription().CompareTo(type) == 0)
{
// This plugin corresponds to user-selected filter, try it first.
wxLogDebug(wxT("Inserting %s"),plugin->GetPluginStringID());
importPlugins.insert(importPlugins.begin(), plugin.get());
}
}
}
wxLogMessage(wxT("File name is %s"), fName);
wxLogMessage(wxT("Mime type is %s"), mime_type.Lower());
for (const auto &uItem : mExtImportItems)
{
ExtImportItem *item = uItem.get();
bool matches_ext = false, matches_mime = false;
wxLogDebug(wxT("Testing extensions"));
for (size_t j = 0; j < item->extensions.Count(); j++)
{
wxLogDebug(wxT("%s"), item->extensions[j].Lower());
if (wxMatchWild (item->extensions[j].Lower(),fName.Lower(), false))
{
wxLogDebug(wxT("Match!"));
matches_ext = true;
break;
}
}
if (item->extensions.Count() == 0)
{
wxLogDebug(wxT("Match! (empty list)"));
matches_ext = true;
}
if (matches_ext)
wxLogDebug(wxT("Testing mime types"));
else
wxLogDebug(wxT("Not testing mime types"));
for (size_t j = 0; matches_ext && j < item->mime_types.Count(); j++)
{
if (wxMatchWild (item->mime_types[j].Lower(),mime_type.Lower(), false))
{
wxLogDebug(wxT("Match!"));
matches_mime = true;
break;
}
}
if (item->mime_types.Count() == 0)
{
wxLogDebug(wxT("Match! (empty list)"));
matches_mime = true;
}
if (matches_ext && matches_mime)
{
wxLogDebug(wxT("Complete match!"));
for (size_t j = 0; j < item->filter_objects.size() && (item->divider < 0 || (int) j < item->divider); j++)
{
// the filter_object can be NULL if a suitable importer was not found
// this happens when we recompile with --without-ffmpeg and there
// is still ffmpeg in prefs from previous --with-ffmpeg builds
if (!(item->filter_objects[j]))
continue;
wxLogDebug(wxT("Inserting %s"),item->filter_objects[j]->GetPluginStringID());
importPlugins.push_back(item->filter_objects[j]);
}
}
}
// Add all plugins that support the extension
// Here we rely on the fact that the first plugin in mImportPluginList is libsndfile.
// We want to save this for later insertion ahead of libmad, if libmad supports the extension.
// The order of plugins in mImportPluginList is determined by the Importer constructor alone and
// is not changed by user selection overrides or any other mechanism, but we include an assert
// in case subsequent code revisions to the constructor should break this assumption that
// libsndfile is first.
ImportPlugin *libsndfilePlugin = mImportPluginList.begin()->get();
wxASSERT(libsndfilePlugin->GetPluginStringID().IsSameAs(wxT("libsndfile")));
for (const auto &plugin : mImportPluginList)
{
// Make sure its not already in the list
if (importPlugins.end() ==
std::find(importPlugins.begin(), importPlugins.end(), plugin.get()))
{
if (plugin->SupportsExtension(extension))
{
// If libmad is accidentally fed a wav file which has been incorrectly
// given an .mp3 extension then it can choke on the contents and crash.
// To avoid this, put libsndfile ahead of libmad in the lists created for
// mp3 files, or for any of the extensions supported by libmad.
// A genuine .mp3 file will first fail an attempted import with libsndfile
// but then get processed as desired by libmad.
// But a wav file which bears an incorrect .mp3 extension will be successfully
// processed by libsndfile and thus avoid being submitted to libmad.
if (plugin->GetPluginStringID().IsSameAs(wxT("libmad")))
{
// Make sure libsndfile is not already in the list
if (importPlugins.end() ==
std::find(importPlugins.begin(), importPlugins.end(), libsndfilePlugin))
{
wxLogDebug(wxT("Appending %s"),libsndfilePlugin->GetPluginStringID());
importPlugins.push_back(libsndfilePlugin);
}
}
wxLogDebug(wxT("Appending %s"),plugin->GetPluginStringID());
importPlugins.push_back(plugin.get());
}
}
}
// Add remaining plugins, except for libmad, which should not be used as a fallback for anything.
// Otherwise, if FFmpeg (libav) has not been installed, libmad will still be there near the
// end of the preference list importPlugins, where it will claim success importing FFmpeg file
// formats unsuitable for it, and produce distorted results.
for (const auto &plugin : mImportPluginList)
{
if (!(plugin->GetPluginStringID().IsSameAs(wxT("libmad"))))
{
// Make sure its not already in the list
if (importPlugins.end() ==
std::find(importPlugins.begin(), importPlugins.end(), plugin.get()))
{
wxLogDebug(wxT("Appending %s"),plugin->GetPluginStringID());
importPlugins.push_back(plugin.get());
}
}
}
// Try the import plugins, in the permuted sequences just determined
for (const auto plugin : importPlugins)
{
// Try to open the file with this plugin (probe it)
wxLogMessage(wxT("Opening with %s"),plugin->GetPluginStringID());
auto inFile = plugin->Open(fName);
if ( (inFile != NULL) && (inFile->GetStreamCount() > 0) )
{
wxLogMessage(wxT("Open(%s) succeeded"), fName);
// File has more than one stream - display stream selector
if (inFile->GetStreamCount() > 1)
{
ImportStreamDialog ImportDlg(inFile.get(), NULL, -1, _("Select stream(s) to import"));
if (ImportDlg.ShowModal() == wxID_CANCEL)
{
return false;
}
}
// One stream - import it by default
else
inFile->SetStreamUsage(0,TRUE);
auto res = inFile->Import(trackFactory, tracks, tags);
if (res == ProgressResult::Success || res == ProgressResult::Stopped)
{
// LOF ("list-of-files") has different semantics
if (extension.IsSameAs(wxT("lof"), false))
{
return true;
}
if (tracks.size() > 0)
{
// success!
return true;
}
}
if (res == ProgressResult::Cancelled || res == ProgressResult::Failed)
{
return false;
}
// We could exit here since we had a match on the file extension,
// but there may be another plug-in that can import the file and
// that may recognize the extension, so we allow the loop to
// continue.
}
}
wxLogError(wxT("Importer::Import: Opening failed."));
// None of our plugins can handle this file. It might be that
// Audacity supports this format, but support was not compiled in.
// If so, notify the user of this fact
for (const auto &unusableImportPlugin : mUnusableImportPluginList)
{
if( unusableImportPlugin->SupportsExtension(extension) )
{
errorMessage.Printf(_("This version of Audacity was not compiled with %s support."),
unusableImportPlugin->
GetPluginFormatDescription());
return false;
}
}
/* warnings for unsupported data types */
if (compatiblePlugins.empty())
{
// if someone has sent us a .cda file, send them away
if (extension.IsSameAs(wxT("cda"), false)) {
/* i18n-hint: %s will be the filename */
errorMessage.Printf(_("\"%s\" is an audio CD track. \nAudacity cannot open audio CDs directly. \nExtract (rip) the CD tracks to an audio format that \nAudacity can import, such as WAV or AIFF."), fName);
return false;
}
// playlist type files
if ((extension.IsSameAs(wxT("m3u"), false))||(extension.IsSameAs(wxT("ram"), false))||(extension.IsSameAs(wxT("pls"), false))) {
errorMessage.Printf(_("\"%s\" is a playlist file. \nAudacity cannot open this file because it only contains links to other files. \nYou may be able to open it in a text editor and download the actual audio files."), fName);
return false;
}
//WMA files of various forms
if ((extension.IsSameAs(wxT("wma"), false))||(extension.IsSameAs(wxT("asf"), false))) {
errorMessage.Printf(_("\"%s\" is a Windows Media Audio file. \nAudacity cannot open this type of file due to patent restrictions. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName);
return false;
}
//AAC files of various forms (probably not encrypted)
if ((extension.IsSameAs(wxT("aac"), false))||(extension.IsSameAs(wxT("m4a"), false))||(extension.IsSameAs(wxT("m4r"), false))||(extension.IsSameAs(wxT("mp4"), false))) {
errorMessage.Printf(_("\"%s\" is an Advanced Audio Coding file. \nAudacity cannot open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName);
return false;
}
// encrypted itunes files
if ((extension.IsSameAs(wxT("m4p"), false))) {
errorMessage.Printf(_("\"%s\" is an encrypted audio file. \nThese typically are from an online music store. \nAudacity cannot open this type of file due to the encryption. \nTry recording the file into Audacity, or burn it to audio CD then \nextract the CD track to a supported audio format such as WAV or AIFF."), fName);
return false;
}
// Real Inc. files of various sorts
if ((extension.IsSameAs(wxT("ra"), false))||(extension.IsSameAs(wxT("rm"), false))||(extension.IsSameAs(wxT("rpm"), false))) {
errorMessage.Printf(_("\"%s\" is a RealPlayer media file. \nAudacity cannot open this proprietary format. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName);
return false;
}
// Other notes-based formats
if ((extension.IsSameAs(wxT("kar"), false))||(extension.IsSameAs(wxT("mod"), false))||(extension.IsSameAs(wxT("rmi"), false))) {
errorMessage.Printf(_("\"%s\" is a notes-based file, not an audio file. \nAudacity cannot open this type of file. \nTry converting it to an audio file such as WAV or AIFF and \nthen import it, or record it into Audacity."), fName);
return false;
}
// MusePack files
if ((extension.IsSameAs(wxT("mp+"), false))||(extension.IsSameAs(wxT("mpc"), false))||(extension.IsSameAs(wxT("mpp"), false))) {
errorMessage.Printf(_("\"%s\" is a Musepack audio file. \nAudacity cannot open this type of file. \nIf you think it might be an mp3 file, rename it to end with \".mp3\" \nand try importing it again. Otherwise you need to convert it to a supported audio \nformat, such as WAV or AIFF."), fName);
return false;
}
// WavPack files
if ((extension.IsSameAs(wxT("wv"), false))||(extension.IsSameAs(wxT("wvc"), false))) {
errorMessage.Printf(_("\"%s\" is a Wavpack audio file. \nAudacity cannot open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName);
return false;
}
// AC3 files
if ((extension.IsSameAs(wxT("ac3"), false))) {
errorMessage.Printf(_("\"%s\" is a Dolby Digital audio file. \nAudacity cannot currently open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName);
return false;
}
// Speex files
if ((extension.IsSameAs(wxT("spx"), false))) {
errorMessage.Printf(_("\"%s\" is an Ogg Speex audio file. \nAudacity cannot currently open this type of file. \nYou need to convert it to a supported audio format, such as WAV or AIFF."), fName);
return false;
}
// Video files of various forms
if ((extension.IsSameAs(wxT("mpg"), false))||(extension.IsSameAs(wxT("mpeg"), false))||(extension.IsSameAs(wxT("avi"), false))||(extension.IsSameAs(wxT("wmv"), false))||(extension.IsSameAs(wxT("rv"), false))) {
errorMessage.Printf(_("\"%s\" is a video file. \nAudacity cannot currently open this type of file. \nYou need to extract the audio to a supported format, such as WAV or AIFF."), fName);
return false;
}
// Audacity project
if (extension.IsSameAs(wxT("aup"), false)) {
errorMessage.Printf(_("\"%s\" is an Audacity Project file. \nUse the 'File > Open' command to open Audacity Projects."), fName);
return false;
}
// we were not able to recognize the file type
errorMessage.Printf(_("Audacity did not recognize the type of the file '%s'.\nTry installing FFmpeg. For uncompressed files, also try File > Import > Raw Data."),fName);
}
else
{
// We DO have a plugin for this file, but import failed.
wxString pluglist;
for (const auto &plugin : compatiblePlugins)
{
if (pluglist.empty())
pluglist = plugin->GetPluginFormatDescription();
else
pluglist = wxString::Format( _("%s, %s"),
pluglist, plugin->GetPluginFormatDescription() );
}
errorMessage.Printf(_("Audacity recognized the type of the file '%s'.\nImporters supposedly supporting such files are:\n%s,\nbut none of them understood this file format."),fName, pluglist);
}
return false;
}
double GetOriginalPpqPos (MediaItem_Take* take, double ppqPos, bool* loopedItem, double* posVisInsertStartPpq, double* posVisInsertEndPpq)
{
double returnPos = 0;
MediaItem* item = GetMediaItemTake_Item(take);
if (!take || !item || !IsMidi(take, NULL))
{
WritePtr(loopedItem, false);
WritePtr(posVisInsertStartPpq, 0.0);
WritePtr(posVisInsertEndPpq, 0.0);
}
else
{
double itemStart = GetMediaItemInfo_Value(item, "D_POSITION");
double itemEnd = itemStart + GetMediaItemInfo_Value(item, "D_LENGTH");
if (GetMediaItemInfo_Value(item, "B_LOOPSRC") == 0)
{
WritePtr(loopedItem, false);
WritePtr(posVisInsertStartPpq, MIDI_GetPPQPosFromProjTime(take, itemStart));
WritePtr(posVisInsertEndPpq, MIDI_GetPPQPosFromProjTime(take, itemEnd));
returnPos = ppqPos;
}
else
{
WritePtr(loopedItem, true);
double visibleItemStartPpq = MIDI_GetPPQPosFromProjTime(take, itemStart);
double visibleItemEndPpq = MIDI_GetPPQPosFromProjTime(take, itemEnd);
double sourceLenPpq = GetMidiSourceLengthPPQ(take, true);
// Deduct take offset to get correct current loop iteration
double itemStartPpq = MIDI_GetPPQPosFromProjTime(take, itemStart - GetMediaItemTakeInfo_Value(take, "D_STARTOFFS"));
int currentLoop;
int loopCount = GetLoopCount(take, MIDI_GetProjTimeFromPPQPos(take, ppqPos), ¤tLoop);
returnPos = (ppqPos >= visibleItemStartPpq) ? (ppqPos - (currentLoop * sourceLenPpq)) : ppqPos;
if (ppqPos > visibleItemEndPpq) // position after item end
{
WritePtr(posVisInsertStartPpq, 0.0);
WritePtr(posVisInsertEndPpq, 0.0);
}
else if (ppqPos < visibleItemStartPpq || currentLoop == 0) // position in first loop iteration or before it
{
WritePtr(posVisInsertStartPpq, visibleItemStartPpq);
WritePtr(posVisInsertEndPpq, (visibleItemEndPpq - visibleItemStartPpq >= sourceLenPpq) ? itemStartPpq + sourceLenPpq : visibleItemEndPpq);
}
else if (currentLoop == loopCount) // position in last loop iteration
{
WritePtr(posVisInsertStartPpq, itemStartPpq);
WritePtr(posVisInsertEndPpq, itemStartPpq + (visibleItemEndPpq - (currentLoop * sourceLenPpq)));
}
else // position in other loop iterations
{
WritePtr(posVisInsertStartPpq, itemStartPpq);
WritePtr(posVisInsertEndPpq, itemStartPpq + sourceLenPpq);
}
}
}
return returnPos;
}