コード例 #1
0
        /// <summary>
        /// Permette di convertire una Lista di Nodi partendo dai file sorgenti specificati nel file index e come destinazione ha la DestFolder
        /// Viene usato il ConversionParameter per specificare come convertire i media
        /// </summary>
        /// <param name="ListaNodi">Lista dei Nodi da convertire</param>
        /// <param name="IndexFileSorgente"> IndexFile dei media sorgenti</param>
        /// <param name="DestFolder"> Cartella di destinazione dei media</param>
        /// <param name="cp">Parametri di conversione</param>
        public bool BeginConvertPlaylist(IEnumerable<FileSystemNodePlus<MyAddittionalData>> ListaNodi, IndexFile IndexFileSorgente, String DestFolder, ConversionParameter cp)
        {
            if (GetConvertMediaStatus() == ConvertMediaAsyncStatus.nul)
            {
                WorkerThread = new Thread(() =>
                {
                    ConvertPlaylist(ListaNodi, IndexFileSorgente, DestFolder, cp);
                    if (CanUseGui)
                        WaitGUIClose();

                    OnEnd?.Invoke();
                });
                WorkerThread.Start();
                return true;
            }
            else
            {
                return false;
            }
        }
コード例 #2
0
        /// <summary>
        /// Permette di convertire una Lista di Nodi partendo dai file sorgenti specificati nel file index e come destinazione ha la DestFolder
        /// Viene usato il ConversionParameter per specificare come convertire i media
        /// </summary>
        /// <param name="ListaNodi">Lista dei Nodi da convertire</param>
        /// <param name="IndexFileSorgente"> IndexFile dei media sorgenti</param>
        /// <param name="DestFolder"> Cartella di destinazione dei media</param>
        /// <param name="cp">Parametri di conversione</param>
        public void ConvertPlaylist(IEnumerable<FileSystemNodePlus<MyAddittionalData>> ListaNodi, IndexFile IndexFileSorgente, String DestFolder, ConversionParameter cp)
        {
            if (GUI)
                StartGui();

            //seleziono effettivamente tutti i file
            IEnumerable<FileSystemNodePlus<MyAddittionalData>> i = ListaNodi.Where(x => x.Type == FileSystemNodePlusType.File);


            bool Abort = false;
            
            if (CanUseGui)
            {
                CMForm.SetPause += (bool pau) => {
                    Pause = pau;
                };
                CMForm.Stop += () =>
                {
                    Abort = true;
                };

                CMForm.SetProgressTotalMax(i.Count());
            }


            foreach (FileSystemNodePlus<MyAddittionalData> n in i)
            {
                while (Pause && !Abort)
                    Thread.Sleep(100);
                if (Abort)
                    break;

                FileSystemNodePlus<MyAddittionalData> tt = IndexFileSorgente.RootFileSystem.FindFirst((x) => { return x.AddittionalData.MD5 == n.AddittionalData.MD5; });
                if (tt == null)
                {
                    //TODO: non trovato -> gestire la ricerca dei file non trovati
                }
                else
                {
                   



                    if (cp.TipoConversione == ConversinType.Mai)
                    {
                        String PathSource = IndexFileSorgente.RootFileSystem.GetFullPath(tt);
                        String PathDestination = SystemService.Combine(DestFolder, (n.GetFullPath().TrimStart('\\', '/')));

                        if (CanUseGui)
                            CMForm.StartConvertItem(PathSource, PathDestination);
                        OnStartConverting?.Invoke(PathSource, PathDestination);
                        SystemService.CopySecure(PathSource, PathDestination, cp.OverrideIfExist, (double Percent, ref bool cancelFlag) =>
                        {
                            if (CanUseGui)
                                CMForm.UpdateProgressPartial((int)Percent);
                            OnProgressConverting?.Invoke(PathSource, PathDestination, Percent);
                        },
                        (bool copiato, Exception ex) =>
                        {
                            OnEndConverting?.Invoke(PathSource, PathDestination, copiato ? ConvertMediaError.nul : ConvertMediaError.ErrDuranteLaCopia);
                        });
                    }
                    else
                    {

                        String PathSource = IndexFileSorgente.RootFileSystem.GetFullPath(tt);
                        String PathDestination = SystemService.Combine(DestFolder, SystemService.ChangeExtension(n.GetFullPath().TrimStart('\\', '/'), cp.ConvertiIn.GetDefaultExtension()));



                        ConvertionEntity Source = new ConvertionEntity(PathSource, tt.AddittionalData.Metadata.MediaMetadata);
                        ConvertionEntity Dest = new ConvertionEntity(PathDestination, cp.ConvertiIn);


                        bool ForceConversion = cp.TipoConversione == ConversinType.Sempre ? true : false;
                        bool Err = false;
                        FFmpeg.ConvertTo(Source, Dest, ForceConversion, cp.OverrideIfExist, (st, src, des) =>
                        {
                            if (st == FFmpegStatus.Running)
                            {
                                if (CanUseGui)
                                    CMForm.StartConvertItem(src, des);
                                OnStartConverting?.Invoke(src, des);
                            }

                        }, (Percent, src, Destination, Error) =>
                        {
                            if (Error == FFmpegError.DestFolderNotFound)
                            {
                                Err = true;
                                if (CanUseGui)
                                    CMForm.AppendLog("[ERR] File non trovato " + src);
                                OnEndConverting?.Invoke(src, Destination, ConvertMediaError.FileNonTrovato);
                            }
                            else
                            {
                                if (CanUseGui)
                                    CMForm.UpdateProgressPartial(Percent);
                                OnProgressConverting?.Invoke(src, Destination, Percent);
                            }
                        }, false);

                        if (!Err)
                            OnEndConverting?.Invoke(PathSource, PathDestination, ConvertMediaError.nul);
                    }
                }
            }
            if (CanUseGui)
                CMForm.Finito();
            
        }
コード例 #3
0
        /// <summary>
        /// Permette di convertire una Playlist partendo dai file sorgenti specificati nel file index e come destinazione ha la DestFolder
        /// Viene usato il ConversionParameter per specificare come convertire i media
        /// </summary>
        /// <param name="p">Playlist da convertire</param>
        /// <param name="IndexFileSorgente"> IndexFile dei media sorgenti</param>
        /// <param name="DestFolder"> Cartella di destinazione dei media</param>
        /// <param name="cp">Parametri di conversione</param>
        public bool BeginConvertPlaylist(Playlist p, IndexFile IndexFileSorgente, String DestFolder, ConversionParameter cp)
        {
            if (GetConvertMediaStatus() == ConvertMediaAsyncStatus.nul)
            {
                WorkerThread = new Thread(() =>
                {
                    ConvertPlaylist(p, IndexFileSorgente, DestFolder, cp);
                    if (CanUseGui)
                        WaitGUIClose();

                    OnEnd?.Invoke();
                });
                WorkerThread.Start();
                return true;
            }
            else
            {
                return false;
            }
        }
コード例 #4
0
 /// <summary>
 /// Permette di convertire una Playlist partendo dai file sorgenti specificati nel file index e come destinazione ha la DestFolder
 /// Viene usato il ConversionParameter per specificare come convertire i media
 /// </summary>
 /// <param name="p">Playlist da convertire</param>
 /// <param name="IndexFileSorgente"> IndexFile dei media sorgenti</param>
 /// <param name="DestFolder"> Cartella di destinazione dei media</param>
 /// <param name="cp">Parametri di conversione</param>
 public void ConvertPlaylist(Playlist p, IndexFile IndexFileSorgente, String DestFolder, ConversionParameter cp)
 {
     ConvertPlaylist(p.FileSystem.Flatten(), IndexFileSorgente, DestFolder, cp);
 }