C Sharp Dotnet Partionner Les Fichiers Audios Pas À Pas Truc Astuce Dreamlive

DreamLive : www.dreamlive.
fr
Programmation C# - DotNet
Partionner les fichiers Audios
PARTITION AUDIO
Ici je propose de concevoir un logiciel
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é.
NOTIONS ABORDÉES
♠ Exploitation de l’objet Microsoft.DirectX.AudioVideoPlayback.Audio; celui-ci permet d’écouter

et manipuler les séquences Audio pour définir les positions des coupes;
♠ Exploitation des classes BinaryReader et BinaryWriter pour reconstituer Octet par Octet les
séquences des fichiers Audio.
CONCEPTION DU FORMULAIRE
● Démarrer VS.Net,
● Créer une nouvelle application Windows en C#,
● La nommer Partition Audio,
● Par clic droit sur référence dans l’explorateur de solutions, ajouter les références Microsoft.DirectX et
Microsoft.DirectX.AudioVideoPlayback,
Grâce à DirectX, l‛accès aux séquences Audio est très simple.
● Sélectionner le formulaire en mode Design et régler ses propriétés comme l’illustre le tableau page
suivante:
Ces documents DreamLive sont libres de droits et ouverts à tous alors, Page 1
profitez, partagez et appréciez ! Pour nous retrouver sur le Web :
http://www.dreamlive.fr.
DreamLive : www.dreamlive.fr
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 GroupBox 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 Label à l’intérieur de ce GroupBox,
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
Name selecteur
Location 8; 112
Size 600; 45
Maximum 100
LargeChange 1
Je choisis ensuite d‛ajouter des contrôles Label de couleur, pour rendre compte visuellement des
portions à découper.
● Ajouter un premier contrôle Label:
Propriété Valeur
Name deb
Text Vide
Location 22; 168
BackColor Black
Visible False
Ce label affichera en noir, le début de la séquence non conservée.
● Ajouter un deuxième contrôle Label:
Propriété Valeur
Name milieu
Text Vide
Location 24; 168
BackColor PaleGreen
Size 0; 23
Visible False
Ce label affichera la portion de séquence à conserver.
● Ajouter enfin un dernier contrôle Label:
Propriété Valeur
Name lafin
Text Vide
Location 16; 168
BackColor Black
Size 0; 23
Visible False
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 GroupBox,

● Fixer ses propriétés comme indiqué dans le tableau page suivante:
Propriété Valeur
Name groupe1
Text Actions
ForeColor Maroon
Font-Size 10
Location 0; 210
Size 632; 80
● Ajouter ensuite le premier bouton, à l’intérieur de ce GroupBox, comme suit:

Propriété Valeur
Name parcourir
Text Parcourir...
Location 16; 24
Size 85; 48
● Puis, le bouton suivant:

Propriété Valeur
Name jouer
Text Jouer
Location 101; 24
Size 85; 48
Enabled False

Propriété Valeur
Name debut
Text <--|
Location 186; 24
Size 85; 48
Enabled False
Propriété Valeur
Name fin
Text |-->|
Location 271; 24
Size 85; 48
Enabled False
Propriété Valeur
Name reinitialiser
Text Réinitialiser
Location 356; 24
Size 85; 48
Enabled False

Propriété Valeur
Name partitionner
Text Partitionner
Location 441; 24
Size 85; 48
Enabled False

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 ProgressBar comme suit:
Propriété Valeur
Name progression
Maximum 100
Minimum 0
Location 0; 292
Size 632; 23
Step 1
● Ajouter ensuite un contrôle StatusBar,

● Régler ses propriétés comme indiqué dans le tableau page suivante:
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é Panels,

Cette action a pour effet d‛afficher la boîte de dialogue Editeur de Collections StatusBarPanel.
● Cliquer sur le bouton Ajouter pour ajouter un premier panneau:
Propriété Valeur
Name tailleO
Width 160
Text Taille originale:
● Cliquer de nouveau sur Ajouter pour un nouveau panneau:
Propriété Valeur
Name dureeO
Width 160
Text Durée originale:
Propriété Valeur
Name tailleF
Width 160
Text Taille finale:
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 OpenFileDialog et le nommer ouvrir,

● Ajouter un contrôle Timer et le nommer horloge, puis régler sa propriété Interval à 500 (ms).
LE CODE
LES ESPACES DE NOMS
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;
----------
● Puis à la suite, ajouter les déclarations de ces quelques variables publiques...:
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 Quitter 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.
● Double cliquer sur le bouton Parcourir et saisir son code comme suit:
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;
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:

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 calc_Taille() 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)
{
“ Mo.”;
}
else if (laTaille_Fichier > 1024)
{
“ 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 solution 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é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 Timer 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)
{
}
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 Debut 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;
milieu.Left = deb.Left + deb.Width;
Après avoir placé le premier marqueur, il faut pouvoir placer le marqueur de fin.
● Double cliquer sur le bouton Fin et saisir son code comme suit:
private void fin_Click(object sender, System.EventArgs e)

{
lafin.Visible = true;

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:
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;

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;
La taille résultante de la portion est ensuite affichée dans le StausBar.
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 TrackBar 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 Réinitialiser 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;
partitionner.Enabled = false;
deb.Visible = false;
milieu.Visible = false;
lafin.Visible = false;
progression.Visible = false;
}
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 Partitionner 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();
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);
}
else
{
try
{
monAudio.Dispose();
//Indispensable si l’on sort de la partition
monAudio = new Audio(sequence);
}
catch{}
selecteur.Value = 0;
}
}
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:

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.
}
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:
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();
}
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.

C Sharp Dotnet Partionner Les Fichiers Audios Pas À Pas Truc Astuce Dreamlive

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

C Sharp Dotnet Partionner Les Fichiers Audios Pas À Pas Truc Astuce Dreamlive

Hochgeladen von

Copyright:

Verfügbare Formate

DreamLive : www.dreamlive.

Comme le montre la capture ci-con-

♠ Exploitation de l’objet Microsoft.DirectX.AudioVideoPlayback.Audio; celui-ci permet d’écouter

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

● Insérer un contrôle GroupBox et régler ses propriétés comme suit:

● Puis insérer un contrôle Label à l’intérieur de ce GroupBox,

● Ajouter un premier contrôle Label:

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

● Ajouter un deuxième contrôle Label:

Ce label afﬁchera la portion de séquence à conserver.

● Ajouter enﬁn un dernier contrôle Label:

● Ajouter tout d’abord un contrôle GroupBox,

● Ajouter ensuite le premier bouton, à l’intérieur de ce GroupBox, comme suit:

● Puis, le bouton suivant:

● Puis, le bouton suivant:

● Puis, le bouton suivant:

● Puis, le bouton suivant:

● Puis, le bouton suivant:

● Puis, le bouton suivant:

● Ajouter un contrôle ProgressBar comme suit:

● Ajouter ensuite un contrôle StatusBar,

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

● Cliquer sur le bouton Ajouter pour ajouter un premier panneau:

● Cliquer de nouveau sur Ajouter pour un nouveau panneau:

● Cliquer de nouveau sur Ajouter pour un nouveau panneau:

● Cliquer de nouveau sur Ajouter pour un nouveau panneau:

● Ajouter un contrôle OpenFileDialog et le nommer ouvrir,

LES ESPACES DE NOMS

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

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

● Puis à la suite, ajouter les déclarations de ces quelques variables publiques...:

private string sequence;

sequence doit permettre de mémoriser le chemin et le nom de la séquence. duree_Totale doit

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

Nous mettons ainsi ﬁn à l‛application.

Le bouton Parcourir doit permettre à l‛utilisateur de sélectionner la séquence MP3, de charger le

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

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

On crée l‛instance de l‛objet DirectX pour pouvoir écouter et manipuler la séquence:

Avant de poursuivre, nous devons donc créer les deux fonctions.

- La seconde calc_Duree doit renvoyer le temps en minutes si la séquence dépasse 60s.

● Créer tout d’abord la fonction calc_Taille() comme suit:

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

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

return “Durée originale: “ +

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

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

L‛information est de même afﬁchée dans le StatusBar:

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

Nous afﬁchons le premier label (noir) indiquant la portion de piste ignorée:

private void ﬁn_Click(object sender, System.EventArgs e)

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

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

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

La taille résultante de la portion est ensuite afﬁchée dans le StausBar.

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

Si la lecture est en pause, nous la relançons:

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

On utilise cette position_Debut pour s‛y placer directement dans le ﬂux:

Nous libérons ensuite les ressources:

Nous réinitialisons ensuite les boutons:

Ensuite nous demandons à l‛utilisateur s‛il souhaite écouter la séquence résultante:

Cela signiﬁe que nous sommes en mesure d‛intercepter l‛événement du à la ﬁn de la séquence