protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
{
try
{
IMccDescompactor Sex = Context.RarManager.InstanciateExctractor(_FN, iel, Context);
if (Sex == null)
return null;
bool exportsuccess = false;
using (Sex)
{
exportsuccess = Sex.Extract(iel, iCancellationToken);
}
OutPutFiles = Sex.DescompactedFiles;
if (iCancellationToken.IsCancellationRequested)
{
return null;
}
if (exportsuccess==false)
return null;
return new XMLImporter(Sex.RootXML, _ImportAllMetaData, Context.Folders.File) { Rerooter = Sex.Rerooter};
}
catch (Exception e)
{
iel.Report(new UnknownRarError(_FN));
Trace.WriteLine("Decompressing problem " + e.ToString());
return null;
}
}
protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
{
string dp = Path.GetFileName(_FileName);
iel.Report(new ExtractProgessEventArgs(dp));
ImporterConverterAbstract next = null;
try
{
IRarDescompactor Sex = Context.RarManager.InstanciateExctractorWithPassword(_FileName, iel);
if (Sex == null)
{
return next;
}
using (Sex)
{
if (iCancellationToken.IsCancellationRequested)
return null;
Sex.DescompactedFiles = _ExtractedFiles;
bool res = Sex.Extract(iel, iCancellationToken);
_RarFileNames =Sex.ArchiveNames;
if (iCancellationToken.IsCancellationRequested)
return null;
if (res)
{
NonRecursiveFolderInspector nfr = new NonRecursiveFolderInspector(_IInternalMusicSession,_ExtractedFiles, Sex.Helper, iel);
ImporterConverterAbstract[] Importers = nfr.Importers;
if (Importers.Length == 0)
{
iel.Report(new NoMusicImportErrorEventArgs(Sex.Helper.DisplayName));
}
else if (Importers.Length > 1)
{
Trace.WriteLine("Unhandled configuration in a rar file");
iel.Report(new UnhandledRarFile(Sex.Helper.DisplayName));
}
else
next = Importers[0];
}
}
}
catch(Exception e)
{
iel.Report(new UnknownRarError(dp));
Trace.WriteLine("Decompressing problem " + e.ToString());
next = null;
}
return next;
}
protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
{
iel.Report(new ImportProgessEventArgs(_NameClue.DisplayName));
List<Track> LocalTrack = GetTracks(iel, iCancellationToken).CancelableToList(iCancellationToken);
if (iCancellationToken.IsCancellationRequested)
{
RawImportEnded(KOEndImport());
return null;
}
if (LocalTrack.Count == 0)
{
ImportEnded();
return null;
}
List<string> Pictures = Images.OrderBy( imp =>
{
string ifn = Path.GetFileNameWithoutExtension(imp).ToLower();
return (ifn.Contains("cover") || ifn.Contains("front"))? 0 : 1;
} ).ToList();
foreach (Album Al in (from r in LocalTrack select r.Owner).Distinct<Album>())
{
using (IModifiableAlbum AM = Al.GetModifiableAlbum(true, Context))
{
if (AM.FrontImage != null)
continue;
int i = 0;
foreach (string apic in Pictures)
{
IAlbumPicture res = AM.AddAlbumPicture(apic, i);
if (res != null)
i++;
}
if (iCancellationToken.IsCancellationRequested)
{
RawImportEnded(KOEndImport());
return null;
}
AM.Commit();
}
}
ImportEnded();
return null;
}
protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
{
iel.Report(new ImportProgessEventArgs(_FN));
IList<AlbumDescriptor> Als = AlbumDescriptorExchanger.Import(_FN, true, _Reroot, Rerooter);
if (Als == null)
{
iel.Report(new UnsupportedFormat(_FN));
return null;
}
Als.TakeWhileNotCancelled(iCancellationToken).Apply(al => Album.GetAlbumFromExportAlbum(al, Context, this, _ImportAllMetaData));
if (iCancellationToken.IsCancellationRequested)
{
RawImportEnded(KOEndImport());
return null;
}
ImportEnded();
return null;
}
private void ExtractCallBack(ExtractFileCallbackArgs efc, IEventListener iel, CancellationToken iCancellationToken)
{
switch (efc.Reason)
{
case ExtractFileCallbackReason.Start:
string nd = null;
bool root = false;
if (efc.ArchiveFileInfo.FileName == MusicExporter.XMLName)
{
nd = _ICC.Folders.Temp;
root = true;
}
else
{
nd = _ICC.Folders.File;
}
efc.ExtractToFile = FileInternalToolBox.CreateNewAvailableName(Path.Combine(nd, efc.ArchiveFileInfo.FileName));
if (root)
_RX = efc.ExtractToFile;
else
{
Directory.CreateDirectory(Path.GetDirectoryName(efc.ExtractToFile));
}
if ((!efc.ArchiveFileInfo.IsDirectory) && !(root))
{
iel.Report(new ExtractProgessEventArgs(string.Format("{0} from {1}", Path.GetFileName(efc.ArchiveFileInfo.SafePath()), _Sex.FileName)));
AddAssociationIfNeeded(efc.ArchiveFileInfo.FileName, efc.ExtractToFile);
}
DescompactedFiles.Add(efc.ExtractToFile);
break;
case ExtractFileCallbackReason.Failure:
iel.OnFactorisableError<UnableToExtractFileFromRar>(string.Format("{0} from {1} : {2}", Path.GetFileName(efc.ArchiveFileInfo.FileName), _Sex.FileName, efc.Exception));
efc.Exception = null;
efc.ExtractToFile = null;
_Success = false;
break;
}
if (iCancellationToken.IsCancellationRequested)
{
_Success = false;
efc.CancelExtraction = true;
}
}
protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
{
if (iCancellationToken.IsCancellationRequested)
{
return null;
}
SpaceChecker sc = new SpaceChecker(Context.ConvertManager.PathFromOutput(_ListMusic[0], _ClueName),
_ListMusic);
if (!sc.OK)
{
iel.Report(new NotEnougthSpace(sc.ToString()));
return null;
}
try
{
_TargetConvertedMusic = ConvertMusic(iel, iCancellationToken).ToList();
}
catch (ImportExportException iee)
{
throw iee;
}
catch (Exception e)
{
Trace.WriteLine(string.Format("Exception during music convestion, could be ok if this a cancellation exception {0}", e));
return null;
}
if (iCancellationToken.IsCancellationRequested)
{
return null;
}
if (_TargetConvertedMusic.Count == 0)
{
return null;
}
return new MusicImporter(_TargetConvertedMusic, _ListImage, _ClueName);
}
private IEnumerable<string> ConvertMusic(IEventListener iel, CancellationToken iCancellationToken)
{
int Current = 0;
if (iCancellationToken.IsCancellationRequested)
yield break;
foreach (string Music in _ListMusic)
{
iel.Report(new ConvertProgessEventArgs(_ClueName.DisplayName, ++Current, _ListMusic.Count));
string OutDirectory = Context.ConvertManager.PathFromOutput(Music, _ClueName);
string TempDir = Context.Folders.Temp;
using (IMusicFileConverter imf = _IMusicConverter.GetMusicConverter(Music, OutDirectory, TempDir))
{
if (iCancellationToken.IsCancellationRequested)
yield break;
bool res = imf.ConvertTomp3();
if (res)
{
AddConvertedFiles(Music, imf.ConvertName);
yield return imf.ConvertName;
}
else
{
Trace.WriteLine("Unable to convert file"+Music);
iel.OnFactorisableError<UnableToConvertFile>(Music);
}
}
}
}
static internal ICollector CollectorForMusicToConvert(IMusicConverter iMusicConverter,
List<string> Music, List<string> Image, List<string> Cue, IImportHelper ClueName, IEventListener IEL)
{
int ccont = Cue.Count;
int mcount =Music.Count;
if (ccont >= mcount)
{
if ((ccont == 1) && (mcount==1))
{
AlbumDescriptor ad = AlbumDescriptor.FromCUESheet(Cue[0]);
if (ad != null)
{
string mus = Path.GetFileNameWithoutExtension(Music[0]).RemoveInvalidCharacters().ToLower();
if ((Path.GetFileNameWithoutExtension(ad.CUEFile).RemoveInvalidCharacters().ToLower() == mus) ||
(mus == Path.GetFileNameWithoutExtension(Cue[0]).RemoveInvalidCharacters().ToLower()))
{
if ((ad.CheckCueConsistency() == false) || (iMusicConverter.GetFileLengthInSeconds(Music[0]) <= ad.GetCueMinLengthInseconds()))
{
CueWillbeDiscarded cwd = new CueWillbeDiscarded(Cue[0],Music[0]);
IEL.Report(cwd);
if (cwd.Continue == false)
return null;
}
else
{
return new CollectorForCueConvertMusic(iMusicConverter, Music[0], Image, ad, ClueName);
}
}
}
}
else
{
var cues = Cue.Select(c=>AlbumDescriptor.FromCUESheet(c)).Where(c=>c!=null);
//Cherchons les matchs parfaits
CuePairingHelper cph = new CuePairingHelper(Music, cues).SetCueGlue(c => Path.GetFileName(c.CUEFile).RemoveInvalidCharacters().ToLower())
.SetMusicGlue(M => Path.GetFileName(M).RemoveInvalidCharacters().ToLower()).Compute();
List<Tuple<string, AlbumDescriptor>> OK = cph.Matches;
if (cph.FullMatch)
{
return new CollectorForCueConvertMusic(iMusicConverter,OK, Image, ClueName);
}
//Cherchons les matchs imparfaits pour les cue restants
cph = new CuePairingHelper(cph.Remaining, cues).SetCueGlue(c => Path.GetFileNameWithoutExtension(c.CUEFile).RemoveInvalidCharacters().ToLower())
.SetMusicGlue(M => Path.GetFileNameWithoutExtension(M).RemoveInvalidCharacters().ToLower()).Compute();
OK.AddRange(cph.Matches);
if (cph.FullMatch)
{
return new CollectorForCueConvertMusic(iMusicConverter,OK, Image, ClueName);
}
//Derniere chance
cph = new CuePairingHelper(cph.Remaining, cues).SetCueGlue(c => Path.GetFileNameWithoutExtension(c.CUESheetFileName).RemoveInvalidCharacters().ToLower())
.SetMusicGlue(M => Path.GetFileNameWithoutExtension(M).RemoveInvalidCharacters().ToLower()).Compute();
if (cph.FullMatch)
{
OK.AddRange(cph.Matches);
return new CollectorForCueConvertMusic(iMusicConverter,OK, Image, ClueName);
}
}
}
return new CollectorForConvertMusic(iMusicConverter,Music, Image, ClueName);
}
protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
{
int CDnumber = _IMusicConverter.GetDriverNumber(_Driver);
if (!CDHelper.CanOpenCDDoor(CDnumber))
{
//ca pue un lecteur de cd qu'on ne peut pas ouvrir
//je ne fair rien dans ce cas (cle 3G?)
Trace.WriteLine("Problem due to device detected as CD driver");
return null;
}
using (CDLocker cdl = CDLocker.GetLocker(CDnumber))
{
if (!cdl.IsOK)
{
iel.Report(new NoCDInsertedArgs());
Trace.WriteLine("CD driver not ready");
return null;
}
if (!CDHelper.IsCDAudio(CDnumber))
{
iel.Report(new NoCDAudioInsertedArgs());
System.Diagnostics.Trace.WriteLine("CD not audio");
return null;
}
iel.Report(new CDIndentifyingProgessEventArgs());
CDInfoHandler cih = new CDInfoHandler(CDnumber);
IEnumerable<MatchAlbum> albums = Context.FindFromHashes(cih.IDs.RawHash);
if (albums.Any())
{
OtherAlbumsConfirmationNeededEventArgs error = new OtherAlbumsConfirmationNeededEventArgs(albums);
iel.Report(error);
System.Diagnostics.Trace.WriteLine("CD potentially aleady imported");
if (!error.Continue)
{
System.Diagnostics.Trace.WriteLine("stopping import");
return null;
}
}
IWebQuery webq = Context.Session.WebQueryFactory.FromCDInfo(cih);
webq.NeedCoverArt = false;
IInternetFinder ifn = Context.Session.GetInternetFinder(webq);
ifn.Compute(iCancellationToken,null);
AmbigueousCDInformationArgs acfi = new AmbigueousCDInformationArgs(ifn.Result.Found, AlbumDescriptor.CreateBasicFromCD(cih, Context));
iel.Report(acfi);
if (!acfi.Continue)
return null;
AlbumDescriptor ifad = acfi.SelectedInfo as AlbumDescriptor;
iel.Report(new CDImportingProgessEventArgs(ifad.Name));
ifad.MergeIDsFromCDInfos(cih);
IMusicfilesConverter IMC = _IMusicConverter.GetCDMusicConverter(ifad, Context.Folders.File, false, CDnumber);
if (IMC == null)
{
TimeSpan ts = TimeSpan.FromSeconds(7);
int repeat = 0;
int Maxtent = 3;
while ((IMC == null) && (repeat < Maxtent))
{
bool Forcebute = repeat == (Maxtent - 1);
Thread.Sleep(ts);
IMC = _IMusicConverter.GetCDMusicConverter(ifad, Context.Folders.File, Forcebute, CDnumber);
repeat++;
Trace.WriteLine(string.Format("Trial {0} to get CDMusicConverter, Forcebute {1} success {2}", repeat, Forcebute, (IMC == null)));
ts = TimeSpan.FromSeconds(ts.TotalSeconds * 3);
}
if (IMC == null)
{
System.Diagnostics.Trace.WriteLine("no importer returned");
iel.Report(new CDInUse());
return null;
}
}
Action ParrallelCoverLoading = null;
IList<WebMatch<IFullAlbumDescriptor>> resultwithimage = null;
if (acfi.PreprocessedWebInfo != null)
{
resultwithimage = acfi.PreprocessedWebInfo;
ParrallelCoverLoading = () => acfi.PreprocessedWebInfo.Apply(wr => wr.FindItem.LoadImages());
}
else
{
IWebQuery webqim = new WebQueryFactory(Context.Session).FromAlbumDescriptor(ifad);
webqim.NeedCoverArt = true;
IInternetFinder ifni = Context.Session.GetInternetFinder(webqim);
resultwithimage = new List<WebMatch<IFullAlbumDescriptor>>();
if (ifad.HasImage())
{
resultwithimage.Add(new WebMatch<IFullAlbumDescriptor>(ifad, MatchPrecision.Suspition, acfi.Provider));
}
ParrallelCoverLoading = () => { ifad.LoadImages(); ifni.Compute(iCancellationToken,null); resultwithimage.AddCollection(ifni.Result.Found); };
}
int TN = ifad.TrackDescriptors.Count;
IAsyncResult ias = ParrallelCoverLoading.BeginInvoke(null, null);
bool feedbacknegative = false;
IProgress<TrackConverted> progress = new SimpleProgress<TrackConverted>
( (e) =>
{
iel.Report(new ConvertProgessEventArgs(ifad.Name, (int)e.Track.TrackNumber, TN));
if (e.OK)
{
_TDs.Add(e.Track);
}
else
{
feedbacknegative = true;
iel.OnFactorisableError<UnableToConvertFile>(e.Track.Name);
}
}
);
bool convres = IMC.ConvertTomp3(progress, iCancellationToken);
if ((convres == false) && (_TDs.Count == 0) && (feedbacknegative == false))
{
iel.Report(new CDUnknownErrorArgs());
return null;
}
if (iCancellationToken.IsCancellationRequested)
{
return null;
}
if (!ias.IsCompleted)
{
iel.Report(new CDImportingProgessAdditionalCoverInfoEventArgs(ifad));
}
if (_OpenCDDoorOnComplete)
CDHelper.OpenCDDoor();
bool okfound = ias.AsyncWaitHandle.WaitOne(TimeSpan.FromMinutes(3), false);
//j'attends pas plus de 1 minute apres avoir grave le cd pour trouver
//les pochettes sur internet
Trace.WriteLine(string.Format("CD import cover from internet time out result (false:timedout): {0}!", okfound));
if (resultwithimage != null)
{
int tracknumber = ifad.RawTrackDescriptors.Count;
var images = resultwithimage.Where(wr => ((wr.FindItem.MatchTrackNumberOnDisk(tracknumber)) && (wr.FindItem.Images != null) && (wr.FindItem.Images.Count > 0))).ToList();
if (images.Count > 0)
{
Trace.WriteLine(string.Format("{0} Image(s) found!!", images.Count));
CDCoverInformationArgs cdfi = new CDCoverInformationArgs(images, ifad);
iel.Report(cdfi);
}
else
{
Trace.WriteLine(string.Format("Information found but no matching image found for CD:{0} !",ifad));
}
}
else
{
Trace.WriteLine("No image found for CD!");
}
Trace.WriteLine("Import CD OK");
return new MusicWithMetadaImporter(_TDs.ToArray(), new List<string>(), new ICDInfosHelperAdpt(ifad));
}
}
private bool OnErrorUserExit(IEventListener iel,CorruptedRarOrMissingPasswordArgs cr)
{
iel.Report(cr);
if ((cr.accept) && (cr.SavePassword))
_IUnrarUserSettings. AddPassword(cr.Password);
if (_AddRar!=cr.SavePassword)
{
_IUnrarUserSettings.AddUseRarPasswordToList = cr.SavePassword;
_AddRar = cr.SavePassword;
return true;
}
return false;
}
protected override ImporterConverterAbstract GetNext(IEventListener iel, CancellationToken iCancellationToken)
{
if (_Done)
throw new InvalidOperationException("reentrance");
_Done = true;
if (!Analyse())
{
//Cue does not match..let's do the easy way.
return new MusicConverterImporter(_IMusicConverter, _MusicandCueFile.Select(i => i.Item1).ToList(), _ListImage, _ClueName);
}
foreach (Tuple<string, AlbumDescriptor> MAC in _MusicandCueFile)
{
_MusicConverted.Add(MAC.Item1);
_MusicConverted.Add(MAC.Item2.CUESheetFileName);
}
List<TrackConverted> tracks = new List<TrackConverted>();
SpaceChecker sc = new SpaceChecker(Context.ConvertManager.PathFromOutput(_MusicandCueFile[0].Item1, _ClueName),
from mac in _MusicandCueFile select mac.Item1);
if (!sc.OK)
{
iel.Report(new NotEnougthSpace(sc.ToString()));
return null;
}
if (iCancellationToken.IsCancellationRequested)
{
return null;
}
foreach (Tuple<string, AlbumDescriptor> MAC in _MusicandCueFile)
{
string MusicPath = MAC.Item1;
AlbumDescriptor Cs = MAC.Item2;
int Current = 1;
iel.Report(new ConvertProgessEventArgs(_ClueName.DisplayName, Current, Cs.RawTrackDescriptors.Count));
bool OK = false;
using (IMusicfilesConverter imcc = _IMusicConverter.GetMusicConverter(MusicPath, Cs.RawTrackDescriptors, Context.ConvertManager.PathFromOutput(MusicPath, _ClueName), Context.Folders.Temp))
{
IProgress<TrackConverted> progress = new SimpleProgress<TrackConverted>
( (e) =>
{
iel.Report(new ConvertProgessEventArgs(_ClueName.DisplayName, ++Current, Cs.RawTrackDescriptors.Count));
if (e.OK)
{
tracks.Add(e);
AddConvertedFiles(MusicPath, e.Track.Path);
}
else
iel.OnFactorisableError<UnableToConvertFile>(e.Track.Name);
});
OK = imcc.ConvertTomp3(progress, iCancellationToken);
}
}
if (iCancellationToken.IsCancellationRequested)
{
return null;
}
return new MusicWithMetadaImporter((from t in tracks select t.Track).ToArray<ITrackDescriptor>(), _ListImage, _ClueName); ;
}
private void ExtractCallBack(ExtractFileCallbackArgs efc, IEventListener iel, CancellationToken iCancellationToken)
{
switch (efc.Reason)
{
case ExtractFileCallbackReason.Start:
string Dest = GetFileName(efc.ArchiveFileInfo);
if (Dest == null)
{
efc.ExtractToFile = null;
break;
}
efc.ExtractToFile = Dest;
if (!efc.ArchiveFileInfo.IsDirectory)
iel.Report(new ExtractProgessEventArgs(string.Format("{0} from {1}", Path.GetFileName(efc.ArchiveFileInfo.SafePath()), RarContext.DisplayName)));
Files.Add(Dest);
break;
case ExtractFileCallbackReason.Failure:
iel.OnFactorisableError<UnableToExtractFileFromRar>(string.Format("{0} from {1} : {2}", Path.GetFileName(efc.ArchiveFileInfo.SafePath()), RarContext.DisplayName, efc.Exception));
efc.Exception = null;
efc.ExtractToFile = null;
_DOK = false;
break;
}
if (iCancellationToken.IsCancellationRequested)
efc.CancelExtraction = true;
}
public bool Extract(IEventListener Listener, CancellationToken iCancellationToken)
{
if (!CanBeImported)
{
Listener.Report(new FileTooLongArgs((_RarContext as IImportHelper).DisplayName));
return false;
}
if (!ContainsMusic)
{
Listener.Report(new NoMusicImportErrorEventArgs((_RarContext as IImportHelper).DisplayName));
return false;
}
//check available space
SpaceChecker sc = new SpaceChecker(Root, _Sex.UnpackedSize * (ContainsCompressedMusic ? 2 : 1));
if (!sc.OK)
{
Listener.Report(new NotEnougthSpace(sc.ToString()));
return false;
}
return PrivateDecompactor(Listener, iCancellationToken);
}
IImporter IImporter.Import(IEventListener iel, CancellationToken iCancellationToken)
{
ITracksDescriptorBuilder TD = TrackDescriptor.GetItunesBuilder();
try
{
FileInfo iTunesFile = new FileInfo(_MyXMLFile);
if (!iTunesFile.Exists)
{
iel.Report(new FileNotFoundArgs("Itunes Library"));
return null;
}
iel.Report(new ImportProgessEventArgs("Itunes Library"));
int Count = Convert.ToInt32(iTunesFile.Length / 1500);
XmlReaderSettings settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Ignore;
using (XmlReader reader = XmlReader.Create(_MyXMLFile, settings))
{
if (!reader.Read())
{
iel.Report(new ItunesImportError());
return null;
}
if (!reader.ReadToFollowing(iTunesKeys.List))
{
iel.Report(new ItunesImportError());
return null;
}
if (!reader.ReadToDescendant(iTunesKeys.dict))
{
iel.Report(new ItunesImportError());
return null;
}
if (!reader.ReadToDescendant(iTunesKeys.dict))
{
iel.Report(new ItunesImportError());
return null;
}
XmlReader reader2 = reader.ReadSubtree();
if (!reader2.Read())
{
iel.Report(new ItunesImportError());
return null;
}
if (!reader2.ReadToDescendant(iTunesKeys.dict))
{
iel.Report(new ItunesImportError());
return null;
}
int Compt = 0;
do
{
if ((Compt % 50) == 0)
iel.Report(new ImportingTrack(Compt + 1));
IAttributeObjectBuilder<TrackDescriptor> TuD = TD.DescribeNewTrack();
XmlReader inner = reader2.ReadSubtree();
while (inner.ReadToFollowing(iTunesKeys.Key))
{
TuD.DescribeAttribute(inner.ReadString(), () => { inner.Read(); return inner.ReadString(); });
}
ITrackDescriptor itd = TuD.Mature();
if ((_ImportBrokenTrack) || (File.Exists(itd.Path)))
Track.GetTrackFromTrackDescriptor(itd, false, _IIC);
Compt++;
} while (reader2.ReadToFollowing(iTunesKeys.dict));
}
}
catch (Exception e)
{
iel.Report(new ItunesImportError());
Trace.WriteLine(e.ToString());
}
return null;
}
