[.net2] faire une image iso d'un cd/dvd

Soyez le premier à donner votre avis sur cette source.

Vue 36 507 fois - Téléchargée 1 226 fois

Description

C'est juste une traduction de la traduction en C de Vecchio56 d'une source écrit par BruNews en assembleur

Vous trouvez l'original ici:
http://www.asmfr.com/codes/FAIRE-FICHIER-ISO-MASM32_22635.aspx
Sa traduction en C:
http://www.cppfrance.com/codes/FAIRE-FICHIER-ISO-WIN32_37943.aspx

Informations:
Windows 2000 ou supérieur requis.

Fait un fichier Iso9660 depuis un CD ou DVD.
On peut stopper pendant l'opération.
Les CDs musique non pris en charge.

La source est commentée, assez simple à comprendre :)

Source / Exemple :


using System;
using System.IO;
using System.Threading;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

namespace Iso9660
{
    public class Iso9660
    {

        #region 'Variables'

        Thread _thIso;
        string _output;
        long _cdsize;
        FileStream _fsr;
        FileStream _fsw;
        SafeFileHandle _hdev;

        #endregion

        #region 'Constantes'

        const int BUFFER_SIZE = 0x20000;            //128ko taille des blocs de copie
        const long FAT32_LIMIT = 4294967296;        //4go taille max. d'un fichier sur FAT32

        #endregion

        #region 'Evénement'

        /// <summary>Indique la progression.</summary>
        public event Iso9660EventHandler OnProgress;
        /// <summary>Se déclenche lors d'un message pendant la création.</summary>
        public event Iso9660EventHandler OnMessage;
        /// <summary>Se déclenche quand l'image est créée.</summary>
        public event Iso9660EventHandler OnFinish;

        #endregion
        

        #region 'Propriété'

        /// <summary>
        /// Retourne la taille en octets du CD.
        /// </summary>
        public long SizeOfCD
        {
            get { return _cdsize; }
        }
	
        #endregion

        #region 'Constructeur'

        /// <summary>
        /// Constructeur.
        /// </summary>
        public Iso9660()
        {
            _thIso = null;
            _output = @"C:\MyCd.iso";
        }

        #endregion

        #region 'Méthodes'

        /// <summary>
        /// Créer une image ISO9660 d'un cd/dvd.
        /// </summary>
        /// <param name="source">Lecteur cd/dvd.</param>
        /// <param name="output">Fichier iso de sortie.</param>
        /// <returns>1 = Création de l'image en cours.
        /// -1 = Handle du lecteur invalide.
        /// -2 = La source n'est pas un cd/dvd.
        /// -3 = Espace disque insuffisant pour la création de l'image.
        /// -4 = Volume de destination FAT32 et taille de la source > 4 096 Mo.</returns>
        public int MakeIsoFromCD(string source, string output)
        {
            //Source CD/DVD
            if (new DriveInfo(source).DriveType != DriveType.CDRom) return -2;

            //récupérer taille du cd
            _cdsize = CDLenght(source);

            //vérif espace disque
            long hddsize = new DriveInfo(Path.GetPathRoot(output)).AvailableFreeSpace;
            if (hddsize <= _cdsize) return -3;

            //Test capacité > 4 096 Mo (partition NTFS)
            if (!IsNTFS(output) & _cdsize >= FAT32_LIMIT) return -4;

            //Ouverture
            _hdev = NativeMethods.CreateFileR(source);
            if (output != "") _output = output;

            //Si handle invalide ou fermé
            if (_hdev.IsClosed | _hdev.IsInvalid) return -1;

            //Création thread pour copie + Démarrage
            _thIso = new Thread(new ThreadStart(ThProcIso));
            _thIso.Start();

            return 1;
        }

        /// <summary>
        /// Arrete la création de l'image.
        /// (+ Supprime l'image créer)
        /// </summary>
        public void Stop()
        {
            _thIso.Abort();

            CloseAll();

            if (File.Exists(_output)) File.Delete(_output);

            if (OnMessage != null)
            {
                EventIso9660 e = new EventIso9660(@"Création de l'image annulée");
                OnMessage(e);
            }
        }

        /// <summary>
        /// Méthode - C'est ici que l'ont crée l'image iso9660.
        /// </summary>
        private void ThProcIso()
        {
            System.Diagnostics.Stopwatch chrono = new System.Diagnostics.Stopwatch();
            chrono.Start();

            try
            {
                _fsr = new FileStream(_hdev, FileAccess.Read, BUFFER_SIZE);
                _fsw = new FileStream(_output, FileMode.Create, FileAccess.Write, FileShare.None, BUFFER_SIZE);

                byte[] buffer = new byte[BUFFER_SIZE];

                //Lecture des blocs de données du volume -> écriture des blocs dans le fichier iso
                do
                {
                    _fsr.Read(buffer, 0, BUFFER_SIZE);
                    _fsw.Write(buffer, 0, BUFFER_SIZE);

                    if (OnProgress != null)
                    {
                        EventIso9660 e = new EventIso9660(_fsw.Position);
                        OnProgress(e);
                    }

                } while (_fsw.Position == _fsr.Position);
            }
            catch (Exception ex)
            {
                //En cas d'erreur.
                if (OnMessage != null)
                {
                    EventIso9660 e = new EventIso9660("Erreur pendant la création de l'image: " + ex.Message);
                    OnMessage(e);
                }
            }
            finally
            {
                CloseAll();

                if (OnFinish != null)
                {
                    EventIso9660 e = new EventIso9660(chrono.Elapsed);
                    OnFinish(e);
                }
            }
        }

        /// <summary>
        /// Ferme les flux + handles et libère les ressources utilisées.
        /// </summary>
        private void CloseAll()
        {
            //Ferme les flux sur les 2 fichiers et libère les ressources utilisées.
            _fsr.Close();
            _fsw.Close();

            //Marque le handle et libère les ressources utilisées.
            _hdev.Close();
            _hdev.Dispose();
        }

        /// <summary>
        /// Taille du cd/dvd.
        /// </summary>
        /// <param name="drive">Lecteur source.</param>
        /// <returns>Taille en octets.</returns>
        private long CDLenght(string drive)
        {
            return new DriveInfo(drive).TotalSize;
        }

        /// <summary>
        /// Indique si système de fichiers du volume est NTFS.
        /// </summary>
        /// <param name="destination">Image ISO de sortie.</param>
        /// <returns>True si NTFS.</returns>
        private bool IsNTFS(string destination)
        {
            return new DriveInfo(Path.GetPathRoot(destination)).DriveFormat == "NTFS" ? true : false;
        }

        #endregion

    }
}

Conclusion :


Voila,
A vos notes et commentaires :)

++

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
1642
Date d'inscription
samedi 6 novembre 2004
Statut
Modérateur
Dernière intervention
28 avril 2011
2
Eh bien, en parlant de traduction, en voici maintenant la traduction en VB.NET 2 (alias VB 2005, alias VB 8.0, c'est comme on veut :p) :

http://www.vbfrance.com/codes/NET2-CREER-IMAGE-ISO-PARTIR-DISQUE_38076.aspx

Il manquerait encore Delphi, Java et VB6 et on aura à peu près fait le tour :)
Messages postés
2375
Date d'inscription
jeudi 12 juillet 2001
Statut
Modérateur
Dernière intervention
15 décembre 2018
20
Lol Kenji, effectivement si il y a des courageux pour traduire elle peut faire le tour de la communautée CS :)

Je suis en train de bosser sur la création d'un UltraISO like, sa viendra par la suite peut etre dans un autre language :)
Messages postés
3172
Date d'inscription
dimanche 15 février 2004
Statut
Membre
Dernière intervention
9 avril 2017
30
Ben c'est bien tout ca.
Dommage que l'on puisse pas séléctionner les fichiers à encoder.
Faut t-il la traduire en vb ? java ? ... Une source qui va loin.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.