[PDF] Cours de base sur le langage C Sharp et le framework .NET | Formation informatique

PARTITION AUDIO

permettant de partitionner les sé-quences Audio de type mp3.

Comme le montre la capture ci-con-tre, on charge un morceau, on lance la lecture (Jouer), on place les mar-queurs de début (<--|) et de fin (|-->). La partie verte représente le mor-ceau à conserver; on clique alors sur partitionner et on obtient la nouvelle séquence.

Pour pouvoir réaliser cet exemple le SDK DirectX doit être installé.

N

♠ Exploitation de l’objet

; celui-ci permet d’écouter

et manipuler les séquences Audio pour définir les positions des coupes;

♠ Exploitation des classes

et

pour reconstituer Octet par Octet les

séquences des fichiers Audio.

C

● Démarrer

,

● Créer une nouvelle

en

,

● La nommer

,

● Par clic droit sur référence dans l’explorateur de solutions, ajouter les références

et

Microsoft.DirectX.AudioVideoPlayback

,

Grâce à DirectX, l‛accès aux séquences Audio est très simple.

● Sélectionner le formulaire en

et régler ses propriétés comme l’illustre le tableau page

suivante:

Propriété

Valeur

Size 640; 370

MinimumSize 640; 370 MaximumSize 640; 370

Text Partitionner les fichiers audio StartPosition CenterScreen

Je choisis ensuite de disposer un Label pour afficher le titre de la séquence Video.

● Insérer un contrôle

et régler ses propriétés comme suit:

Propriété

Valeur

Text Chemin d’accès

Location 8; 8

Size 616; 96

ForeColor Maroon

Font-Size 11

● Puis insérer un contrôle

à l’intérieur de ce

,

Propriété

Valeur

Text Titre de la séquence:

Name titre

Location 8; 20

Size 600; 68

Font-Name Comic Sans MS

Font-Size 11

Je choisis ensuite d‛ajouter un contrôle TrackBar pour permettre à l‛utilisateur de naviguer dans la séquence Audio.

Propriété

Valeur

● Ajouter un premier contrôle

:

Propriété

Valeur

Ce label affichera en noir, le début de la séquence non conservée.

● Ajouter un deuxième contrôle

:

Propriété

Valeur

Ce label affichera la portion de séquence à conserver.

● Ajouter enfin un dernier contrôle

:

Propriété

Valeur

J‛ajoute ensuite les boutons d‛actions pour respectivement, ouvrir la séquence Audio, jouer la séquence Audio, poser le marqueur de début, poser le marqueur de fin, réinitialiser les découpes, partitionner le fichier et quitter l‛application.

● Ajouter tout d’abord un contrôle

,

Propriété

Valeur

● Ajouter ensuite le premier

, à l’intérieur de ce

, comme suit:

Propriété

Valeur

Name parcourir

Text Parcourir...

Location 16; 24

Size 85; 48

● Puis, le bouton suivant:

Propriété

Valeur

● Puis, le bouton suivant:

Propriété

Valeur

● Puis, le bouton suivant:

Propriété

Valeur

● Puis, le bouton suivant:

Propriété

Valeur

● Puis, le bouton suivant:

Propriété

Valeur

● Puis, le bouton suivant:

Propriété

Valeur

Name quitter

Text Quitter

Location 526; 24

Size 85; 48

Je choisis ensuite d‛ajouter une barre de progression pour indiquer l‛avancement de la partition ainsi qu‛une barre d‛état pour afficher diverses informations comme la taille initiale du fichier, la durée de la séquence, et la taille finale du fichier après partition.

● Ajouter un contrôle

comme suit:

Propriété

Valeur

● Ajouter ensuite un contrôle

,

Propriété

Valeur

Name etat

ShowPanels True

Text Vide

Je choisis de répartir les informations dans différents panneau de la barre d‛état (4). Pour ajou-ter des Panels au StatusBar:

● Cliquer sur le bouton à trois points de sa propriété

,

Cette action a pour effet d‛afficher la boîte de dialogue Editeur de Collections StatusBarPanel.

● Cliquer sur le bouton

pour ajouter un premier

:

Propriété

Valeur

Name tailleO

Width 160

Text Taille originale:

● Cliquer de nouveau sur

pour un nouveau

:

Propriété

Valeur

Name dureeO

Width 160

Text Durée originale:

● Cliquer de nouveau sur

pour un nouveau

:

Propriété

Valeur

Name tailleF

Width 160

Text Taille finale:

● Cliquer de nouveau sur

pour un nouveau

:

Propriété

Valeur

Name dureeF

Width 160

Text Vide

Il ne reste plus qu‛à ajouter un Timer et un OpenFileDialog pour permettre à l‛utilisateur de sé-lectionner la séquence Audio.

● Ajouter un contrôle

et le nommer

,

● Ajouter un contrôle

et le nommer

, puis régler sa propriété

à

(ms).

L

L

Je fais référence à DirectX pour lire l‛audio et à IO pour accéder aux fichiers en lecture et en écriture.

● Ajouter les déclarations suivantes en début de code:

using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using System.Data; using Microsoft.DirectX; using Microsoft.DirectX.AudioVideoPlayback; using System.IO;

Ensuite, il faut ajouter la déclaration de l‛objet Audio de DirectX à la classe:

---namespace _67_PartitionAudio {

public class Form1 : System.Windows.Forms.Form {

private System.Windows.Forms.StatusBar etat;

private System.Windows.Forms.StatusBarPanel tailleO; private System.Windows.Forms.StatusBarPanel dureeO; private System.Windows.Forms.StatusBarPanel tailleF; private System.Windows.Forms.StatusBarPanel dureeF; private System.Windows.Forms.ProgressBar progression;

private Microsoft.DirectX.AudioVideoPlayback.Audio monAudio;

private System.Windows.Forms.GroupBox groupe1; private System.Windows.Forms.Button parcourir;

namespace _67_PartitionAudio {

public class Form1 : System.Windows.Forms.Form {

private System.Windows.Forms.StatusBar etat;

private System.Windows.Forms.StatusBarPanel tailleO; private System.Windows.Forms.StatusBarPanel dureeO; private System.Windows.Forms.StatusBarPanel tailleF; private System.Windows.Forms.StatusBarPanel dureeF; private System.Windows.Forms.ProgressBar progression;

private Microsoft.DirectX.AudioVideoPlayback.Audio monAudio;

---private string sequence;

private double duree_Totale;

private long taille_Totale;

private int avancement;

private long position_Debut, position_Fin;

---sequence doit permettre de mémoriser le chemin et le nom de la séquence. duree_Totale doit stocker la longueur en secondes (Grâce au composant Audio DirectX) de la séquence car quelques calculs en dépendent. taille_Totale doit mémoriser la taille du fichier en Octets; là aussi plusieurs calculs s‛en suivent. avancement est une variable qui mémorise à tout instant la position dans le flux du fichier si la lecture est en cours par exemple. position_Debut et position_Fin doivent stocker (en Octets) le début et la fin de la partition en fonction des marqueurs positionnés par l‛utilisateur.

Codons maintenant les boutons en commençant par le plus simple.

● Double cliquer sur le bouton

et saisir son code comme suit:

private void quitter_Click(object sender, System.EventArgs e) {

this.Close(); }

Nous mettons ainsi fin à l‛application.

Le bouton Parcourir doit permettre à l‛utilisateur de sélectionner la séquence MP3, de charger le composant Audio (DirectX), et de récupérer les informations sur la taille du fichier et la longueur de la séquence, tout en permettant ensuite la lecture.

private void parcourir_Click(object sender, System.EventArgs e) {

ouvrir.Title = “Sélectionnez un fichier Audio”; ouvrir.Filter = “Fichiers MP3|*.mp3”;

ouvrir.FilterIndex = 1;

if (ouvrir.ShowDialog()==DialogResult.OK) {

sequence = ouvrir.FileName;

titre.Text = “Titre de la séquence: \n” + sequence; jouer.Enabled = true; debut.Enabled = true; reinitialiser.Enabled = true; } else { return; }

//Accès IO au fichier pour récupérer sa taille

FileStream Lecteur = new FileStream(sequence,FileMode.Open);

//mémorisation publique pour usage ultérieur

taille_Totale = Lecteur.Length;

etat.Panels[0].Text = “Taille originale: “ + calc_Taille(Convert.ToDouble(Lecteur .Length));

Lecteur.Close(); try

{

//En libérant le contrôle, met fin à l’éventuelle séquence

monAudio.Dispose(); }

catch{}

//Création de l’instance de l’objet Audio pour pouvoir le piloter

monAudio = new Audio(sequence,false);

//Variable publique

duree_Totale = monAudio.Duration;

etat.Panels[1].Text = calc_Duree(monAudio.Duration); }

EXPLICATIONS: Avant d‛afficher la boîte de dialogue Ouvrir, nous définissons son titre et son filtre (seuls les fichiers Audio MP3 peuvent être traités):

ouvrir.Title = “Sélectionnez un fichier Audio”; ouvrir.Filter = “Fichiers MP3|*.mp3”;

Si l‛utilisateur clique sur OK, nous mémorisons le chemin et le nom du fichier dans la variable pu-blique sequence, affichons l‛information dans l‛étiquette titre, et rendons disponible les boutons jouer, debut et reinitialiser puisque les travaux de lecture et de découpe peuvent commencer.

if (ouvrir.ShowDialog()==DialogResult.OK) {

sequence = ouvrir.FileName;

titre.Text = “Titre de la séquence: \n” + sequence; jouer.Enabled = true;

debut.Enabled = true;

reinitialiser.Enabled = true; }

Ensuite à l‛aide de la classe FileStream (Espace de noms IO), nous pointons sur le fichier pour en récupérer la taille en Octets, à l‛aide de la propriété length. La valeur retournée est stockée dans la variable publique taille_Totale.

FileStream Lecteur = new FileStream(sequence,FileMode.Open);

//mémorisation publique pour usage ultérieur

taille_Totale = Lecteur.Length;

Puis nous affichons l‛information dans la barre d‛état après avoir traité la taille à l‛aide d‛une fonc-tion calc_Taille (à créer), et refermons le FileStream pour libérer les ressources mémoires:

etat.Panels[0].Text = «Taille originale: « + calc_Taille(Convert.ToDouble(Lecteur.Leng th));

Lecteur.Close();

On tente de libérer le contrôle Audio s‛il s‛agit d‛une seconde ouverture: try

{

//En libérant le contrôle, met fin à l’éventuelle séquence

monAudio.Dispose(); }

On crée l‛instance de l‛objet DirectX pour pouvoir écouter et manipuler la séquence: monAudio = new Audio(sequence,false);

On récupère l‛information sur la durée en secondes que l‛on affiche dans la barre d‛état après traitement par la fonction calc_Duree à créer.

duree_Totale = monAudio.Duration;

etat.Panels[1].Text = calc_Duree(monAudio.Duration); Avant de poursuivre, nous devons donc créer les deux fonctions.

- La première calc_Taille doit renvoyer l‛information dans l‛unité appropriée (Ko, Mo, Go...), - La seconde calc_Duree doit renvoyer le temps en minutes si la séquence dépasse 60s.

● Créer tout d’abord la fonction

comme suit:

private string calc_Taille(double laTaille_Fichier) {

//Convertit la taille du fichier dans l’unité appropriée

if (laTaille_Fichier > 1024000000) { return System.Math.Round(laTaille_Fichier/1024000000,2).ToString() + “ Go.”; } else if (laTaille_Fichier > 1024000) { return System.Math.Round(laTaille_Fichier/1024000,2).ToString() + “ Mo.”; } else if (laTaille_Fichier > 1024) { return System.Math.Round(laTaille_Fichier/1024,2).ToString() + “ Ko.”; } else { return System.Math.Round(laTaille_Fichier,2).ToString() + “ Octets.”; } }

Le code étant très simple, aucune explication supplémentaire n‛est nécessaire. Notons tout de même l‛emploi de la fonction Round de l‛espace de noms System.Math pour ne conserver que deux décimales ((...,2)). La fonction est de type string car le résultat du calcul est converti en chaîne de caractères, prêt à être affiché dans la barre d‛état.

● Créer ensuite la procédure calc_Durre() comme suit:

private string calc_Duree(double laLongueur) {

string[] LesTemps; //Pour mémoriser les temps coupés au niveau de la virgule

laLongueur = (laLongueur / 60);

LesTemps = laLongueur.ToString().Split(‘,’); //A gauche les minutes, à droite les secondes

LesTemps[1] = “0,” + LesTemps[1];

//Reconvertit en double, et multiplie par 60 pour obtenir les secondes

LesTemps[1] = System.Math.Round(Convert.ToDouble(LesTemps[1])*60,0).ToString(); return “Durée originale: “ +

LesTemps[0] + “ mn “ + LesTemps[1] + “ s”; }

Etant donné que la durée est stockée en secondes, nous la divisons par 60 pour connaître le nom-bre de minutes: laLongueur = (laLongueur / 60);. Nous obtenons dans la majeur partie des cas, un nombre décimal. La partie à gauche de la virgule renseigne sur le nombre de minutes tandis que la partie à droite renseigne sur le nombre de secondes. C‛est pourquoi, nous déclarons un tableau de chaînes dans lequel nous stockons ces deux informations à l‛aide de la méthode Split() de la classe string:

string[] LesTemps;

---LesTemps = laLongueur.ToString().Split(‘,’);

Le premier élément du tableau (0) concerne les minutes, le second (1), concerne les secondes. Nous leur ajoutons donc le préfixe ‘0,‛ pour pouvoir faire la conversion:

LesTemps[1] = «0,» + LesTemps[1];

En multipliant par 60, nous obtenons les secondes et ne conservons aucune décimale (Round, pa-ramètre 0).

Nous retournons enfin le résultat pour qu‛il puisse être affiché dans la barre d‛état. return “Durée originale: “ + LesTemps[0] + “ mn “ + LesTemps[1] + “ s”;

● Exécuter la

pour constater à ce stade que tout fonctionne correctement.

Une fois la séquence chargée, celle-ci peut être jouée à l‛aide du composant DirectX.

● Double cliquer sur le bouton Jouer et saisir son code comme suit:

if (jouer.Text == “Jouer”) { try { monAudio.Play(); horloge.Start(); jouer.Text = “||”; } catch{MessageBox.Show(“ok”);} } else { monAudio.Pause(); horloge.Stop(); jouer.Text = “Jouer”; }

Ce bouton agit un peu comme un bouton Bascule. Lorsqu‛il affiche l‛information Jouer il lance la sé-quence et Bascule sur l‛information || (Pause). Un nouveau clique met donc la sésé-quence en pause.

Si le texte était Jouer, il devient ||, puis nous lançons la séquence à l‛aide de la méthode Play et activons l’horloge dont nous devons saisir le code:

monAudio.Play(); horloge.Start(); jouer.Text = «||»;

Dans le cas contraire, nous plaçons la séquence en pause à l‛aide de la méthode pause du compo-sant DirectX et stoppons l‛horloge à l‛aide de la méthode Stop() du Timer.

monAudio.Pause(); horloge.Stop();

jouer.Text = «Jouer»;

L’horloge doit rendre compte (dans le panel) de l‛état d‛avancement de la lecture en pourcentage et dimensionner le label de couleur verte (en fonction de l‛avancement) si le marqueur de début est déjà posé.

● Double cliquer sur le contrôle

et saisir son code comme suit:

private void horloge_Tick(object sender, System.EventArgs e) {

//Progression ramenée à 100 pour le sélecteur.

avancement = Convert.ToInt32((monAudio.CurrentPosition * 100)/duree_Totale); selecteur.Value = avancement;

etat.Panels[3].Text = avancement.ToString() + “ %”; if(!debut.Enabled)

{

position_Fin = avancement;

milieu.Width = avancement * 6 - deb.Width; }

}

Nous récupérons tout d‛abord la position dans la piste Audio à l‛aide de la propriété CurrentPosi-tion du contrôle DirectX ramenée à 100 par rapport à la durée totale:

avancement = Convert.ToInt32((monAudio.CurrentPosition * 100)/duree_Totale);

Nous positionnons régulièrement (Tous les 500 ms), le curseur du TrackBar en fonction de cette valeur, pour rendre compte visuellement et en temps réellement de la progression de la piste: selecteur.Value = avancement;

L‛information est de même affichée dans le StatusBar: etat.Panels[3].Text = avancement.ToString() + « %»;

Si le marqueur de début est posé, le Label deb est donc posé pour indiquer la portion ignorée par la partition. Dans ce cas, nous choisissons d‛afficher en temps réel (toutes les 500 ms) la progression de la piste considérée en redimensionnant le label vert (milieu):

if(!debut.Enabled) {

position_Fin = avancement;

milieu.Width = avancement * 6 - deb.Width; }

Justement, nous devons donc maintenant nous occuper du bouton debut qui a pour charge de poser le marqueur de début de sélection de piste:

● Double cliquer sur le bouton

et saisir son code comme suit:

private void debut_Click(object sender, System.EventArgs e) {

//Label, indicateur noir de position.

position_Debut = avancement; deb.Visible = true; deb.Width = avancement *6; debut.Enabled = false; fin.Enabled = true; milieu.Visible = true; milieu.Top = deb.Top;

milieu.Left = deb.Left + deb.Width; }

Nous mémorisons tout d‛abord la position de début pour la partition à venir: position_Debut = avancement;

Nous affichons le premier label (noir) indiquant la portion de piste ignorée: deb.Visible = true;

deb.Width = avancement *6;

Nous rendons ensuite le bouton Debut inaccessible puisque le marqueur de début est posé, puis rendons en revanche le bouton Fin accessible pour pouvoir placer le marqueur de fin:

debut.Enabled = false; fin.Enabled = true;

Nous ajustons ensuite la position de départ du deuxième label (vert) pour qu‛il puisse être consi-déré par le Timer et indiquer en temps réel la progression de la piste conservée:

milieu.Visible = true; milieu.Top = deb.Top;

Après avoir placé le premier marqueur, il faut pouvoir placer le marqueur de fin.

● Double cliquer sur le bouton

et saisir son code comme suit:

private void fin_Click(object sender, System.EventArgs e) {

position_Fin = avancement; lafin.Visible = true;

milieu.Width = avancement * 6 - deb.Width; lafin.Left = milieu.Left + milieu.Width; lafin.Top = milieu.Top; lafin.Width = 600 - lafin.Left; fin.Enabled = false; monAudio.Stop(); horloge.Stop(); partitionner.Enabled = true;

etat.Panels[2].Text = calc_Taille(((position_Fin - position_Debut)*taille_Totale/ 100));

}

Nous récupérons tout d‛abord la position du marqueur de fin pour savoir ou terminer la partition du fichier à venir:

position_Fin = avancement;

Nous finalisons ensuite la position définitive du Label vert et affichons le troisième Label (noir) pour indiquer visuellement la portion de fin de séquence ignorée:

lafin.Visible = true;

milieu.Width = avancement * 6 - deb.Width; lafin.Left = milieu.Left + milieu.Width; lafin.Top = milieu.Top;

lafin.Width = 600 - lafin.Left;

Le bouton Fin devient logiquement inaccessible: fin.Enabled = false;. Puis nous arrêtons la lec-ture de la séquence, ainsi que les renseignements effectués par le Timer:

monAudio.Stop(); horloge.Stop();

partitionner.Enabled = true;

A ce stade, le programme ne permet pas encore de partitionner, mais il sait lire la séquence, placer les marqueurs de début et de fin tout en affichant les informations en temps réel.

● Exécuter la soltuion pour constater que tout fonctionne à ce stade.

Le fait de déplacer le curseur du TrackBar doit permettre à l‛utilisateur de naviguer dans la piste Audio pour avancer plus vite ou reculer afin de mieux se positionner avant la partition.

● Double cliquer sur le contrôle

et saisir son code comme suit:

private void selecteur_Scroll(object sender, System.EventArgs e) { try { monAudio.Pause(); } catch{} try { avancement = selecteur.Value;

//Permet de se déplacer dans le flux audio

monAudio.CurrentPosition = avancement * duree_Totale / 100; if (jouer.Text == “||”)

monAudio.Play(); }

catch{selecteur.Value=0;} }

On tente tout d‛abord de mettre en pause la piste Audio (Si la lecture est en cours) pour pouvoir déplacer le curseur et en fonction réajuster la CurrentPosition:

try {

monAudio.Pause(); }

catch{}

Cette propriété CurrentPosition permet ensuite de se replacer dans le flux audio en fonction du curseur après conversion en rapport avec la taille:

avancement = selecteur.Value;

//Permet de se déplacer dans le flux audio

monAudio.CurrentPosition = avancement * duree_Totale / 100; Si la lecture est en pause, nous la relançons:

if (jouer.Text == “||”) monAudio.Play();

● Double cliquer sur le bouton

et saisir son code comme suit:

try {

monAudio.Stop(); monAudio.Dispose();

//Indispensable si l’on sort de la partition

monAudio = new Audio(sequence); } catch{} selecteur.Value = 0; debut.Enabled = true; fin.Enabled = false; partitionner.Enabled = false; deb.Visible = false; milieu.Visible = false; lafin.Visible = false; progression.Visible = false; jouer.Text = “Jouer”; }

Ce code réinitialise notamment les marqueurs pour pouvoir les positionner de nouveau.

Voilà, il ne reste plus qu‛à coder le bouton le plus important (Partitionner) permettant de créer une séquence à partir de la portion définie à l‛aide des marqueurs.

● Double cliquer sur le bouton

et saisir son code comme suit:

private void partitionner_Click(object sender, System.EventArgs e) {

string fichier_Seul = Path.GetFileNameWithoutExtension(sequence); string extension_seule = Path.GetExtension(sequence);

try {

//Obliger de libérer le fichier Audio pour y accéder //en BinaryReader

monAudio.Dispose(); }

catch{}

FileStream Lect = new FileStream(sequence,FileMode.Open); BinaryReader Lire = new BinaryReader(Lect);

//Accès en create et non OpenAndCreate pour le remplacer s’il existe

FileStream Graveur = new FileStream(fichier_Seul + “1” + extension_seule, FileMode.Create);

BinaryWriter Ecrire = new BinaryWriter(Graveur); position_Debut = position_Debut*taille_Totale/100;

position_Fin = position_Fin*taille_Totale/100; Lect.Seek(position_Debut,SeekOrigin.Begin); progression.Visible = true;

for (long i = position_Debut; i < position_Fin; i++) { progression.Value = Convert.ToInt32((i-position_Debut)*100/(position_Fin - position_Debut)); Ecrire.Write(Lire.ReadByte()); } Ecrire.Close(); Graveur.Close(); Lire.Close(); Lect.Close(); debut.Enabled = true; fin.Enabled = false; partitionner.Enabled = false; deb.Visible = false; milieu.Visible = false; lafin.Visible = false; jouer.Text = “Jouer”;

if (MessageBox.Show(“Souhaitez vous écouter le résultat ?”,”Message”, MessageBoxButtons.YesNo)==DialogResult.Yes)

{

monAudio = new Audio(fichier_Seul + “1” + extension_seule,true);

//Ce gestionnaire permettra d’intercepter la fin de la partition //et de rétablir le contrôle Audio du départ.

this.monAudio.Ending += new System.EventHandler(monAudio_Ending); progression.Visible = false; } else { progression.Visible = false; try { monAudio.Dispose();

//Indispensable si l’on sort de la partition

monAudio = new Audio(sequence); } catch{} selecteur.Value = 0; debut.Enabled = true; fin.Enabled = false; partitionner.Enabled = false; deb.Visible = false; milieu.Visible = false;

lafin.Visible = false;

progression.Visible = false; jouer.Text = “Jouer”;

} }

Nous mémorisons tout d‛abord le nom du fichier sans extension ainsi que l‛extension seule dans le but de recomposer le fichier selon ces informations:

string fichier_Seul = Path.GetFileNameWithoutExtension(sequence); string extension_seule = Path.GetExtension(sequence);

Le contrôle Audio doit libérer le fichier (Méthode Dispose()) pour que nous puissions y accéder en lecture et écriture binaires:

try {

//Obliger de libérer le fichier Audio pour y accéder //en BinaryReader

monAudio.Dispose(); }

catch{}

Nous créons ensuite les objets BinaryReader (Celui qui récupère les informations binaires du fi-chier source sur la portion considérée) et BinaryWriter (Celui qui recompose la section à l‛aide de ces informations binaires sur la longueur que nous souhaitons conserver).

FileStream Lect = new FileStream(sequence,FileMode.Open); BinaryReader Lire = new BinaryReader(Lect);

//Accès en create et non OpenAndCreate pour le remplacer s’il existe

FileStream Graveur = new FileStream(fichier_Seul + “1” + extension_seule, FileMode.Create);

BinaryWriter Ecrire = new BinaryWriter(Graveur);

Le BinaryWriter crée un fichier du même nom que l‛original accompagné de l‛indice 1 et dans le même dossier: fichier_Seul + «1» + extension_seule.

On récupère ensuite les positions de début et de fin en fonction des marqueurs pour découper le fichier:

position_Debut = position_Debut*taille_Totale/100; position_Fin = position_Fin*taille_Totale/100;

On utilise cette position_Debut pour s‛y placer directement dans le flux: Lect.Seek(position_Debut,SeekOrigin.Begin);

On parcourt ensuite les informations binaires du fichier d‛origine entre ces deux positions en le reconstituant automatiquement.

Tout ce qui est lu dans le fichier d‛origine (Lire.ReadByte()), est instantanément réécrit dans le fichier du même nom indicé de 1 (Ecrire.Write):

for (long i = position_Debut; i < position_Fin; i++) {

progression.Value = Convert.ToInt32((i-position_Debut)*100/ (position_Fin - position_Debut));

Ecrire.Write(Lire.ReadByte()); }

Nous libérons ensuite les ressources: Ecrire.Close();

Graveur.Close(); Lire.Close(); Lect.Close();

Nous réinitialisons ensuite les boutons: debut.Enabled = true; fin.Enabled = false; partitionner.Enabled = false; deb.Visible = false; milieu.Visible = false; lafin.Visible = false; jouer.Text = “Jouer”;

Ensuite nous demandons à l‛utilisateur s‛il souhaite écouter la séquence résultante: if (MessageBox.Show(“Souhaitez vous écouter le résultat ?”,”Message”,

MessageBoxButtons.YesNo)==DialogResult.Yes) {

monAudio = new Audio(fichier_Seul + “1” + extension_seule,true);

//Ce gestionnaire permettra d’intercepter la fin de la partition //et de rétablir le contrôle Audio du départ.

this.monAudio.Ending += new System.EventHandler(monAudio_Ending); progression.Visible = false;

}

La paramètre booléen true dans l‛instanciation de l‛objet DirectX permet en même temps que le chargement de lancer la lecture de la séquence Audio. Puis, suit une notion très importante. Nous créons le gestionnaire d‛événement suivant:

this.monAudio.Ending += new System.EventHandler(monAudio_Ending);

Cela signifie que nous sommes en mesure d‛intercepter l‛événement du à la fin de la séquence Audio.

● Créer la méthode associée à ce gestionnaire comme suit:

private void monAudio_Ending(object sender, System.EventArgs e) {

//Libère le contrôle de la partition

monAudio.Dispose();

monAudio = new Audio(sequence,false); progression.Visible = false;

}

Une fois la partition écoutée, nous recalons l‛objet DirectX sur la séquence d‛origine pour permet-tre de nouvelles découpes.

Ces documents DreamLive sont libres de droits et ouverts à tous alors, profitez, partagez et appréciez ! Pour nous retrouver sur le Web : http://www.dreamlive.fr.