// Programme processing
// généré avec le générateur de code Processing
// du site www.mon-club-elec.fr
// par X. HINAULT – tous droits réservés

// Programme écrit le : 15/9/2011.

// ——- Licence du code de ce programme : GPL v3—–
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

/////////////// Description du programme ////////////
// Utilise le clavier
// Utilise la librairie GSVideo de capture et lecture vidéo

/*
> ce programme affiche un flux vidéo capturé par la librairie GSVideo
> l’appui sur la touche ‘e’ enregistre le flux vidéo dans un fichier
(Attention : efface l’enregistrement précédent)
> l’appui sur la touche ‘s’ stoppe l’enregistrement

> la lecture du fichier vidéo se fera ensuite par double clic sur le nom du fichier

*/

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import codeanticode.gsvideo.*; // importe la librairie vidéo GSVideo qui implémente GStreamer pour Processing (compatible Linux)
// librairie comparable à la librairie native vidéo de Processing (qui implémente QuickTime..)- Voir Reference librairie Video Processing
// cette librairie doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// voir ici : http://gsvideo.sourceforge.net/
// et ici : http://codeanticode.wordpress.com/2011/05/16/gsvideo-09-release

// déclaration objets

GSCapture cam1; // déclare un objet GSCapture représentant une webcam
// L’objet GSCapture étend PImage – se comporte comme un conteneur des frames issues de la webcam

GSMovieMaker maVideo; // crée un objet moviemaker pour créer la vidéo

// déclaration variables globales

PImage imgDest;

String cheminFichier=« /home/glapbox/Bureau/trans/ »; // chemin absolu du fichier
String nomFichier=« mavideo.avi »; // nom de la vidéo

//—— déclaration des variables de couleur utiles —-
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);

// variable pour la taille de la capture video
int widthCapture=640/2; // largeur capture
int heightCapture=480/2; // hauteur capture
// plus la taille est grande et plus le fichier vidéo sera gros

int fpsCapture=30; // framerate (image/secondes) pour la capture video
// — plus le framerate est élevé et plus le fichier vidéo sera gros

boolean flagRecord=false; // drapeau pour activation enregistrement – true pour actif et false pour inactif

boolean debug=true; // true si message debogage, false sinon

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage

        // —- initialisation paramètres graphiques utilisés
        colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc…
        fill(0,0,255); // couleur remplissage RGB – noFill() si pas de remplissage
        stroke (0,0,0); // couleur pourtour RGB – noStroke() si pas de pourtour
        rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
        imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
        ellipseMode(CENTER); // origine cercles / ellipses : CENTER : centre (autres : RADIUS, CORNERS, CORNER
        //strokeWeight(0); // largeur pourtour
        frameRate(fpsCapture);// Images par seconde – The default rate is 60 frames per second

        // — initialisation fenêtre de base —
        size(widthCapture, heightCapture); // ouvre une fenêtre xpixels  x ypixels
        background(0,0,0); // couleur fond fenetre

// — initialisation des objets et fonctionnalités utilisées —

        //======== Initialisation Objets GSVideo (capture et/ou lecture video =========

        // GSCapture(this, int requestWidth, int requestHeight, [int frameRate], [String sourceName], [String cameraName])
        cam1 = new GSCapture(this, widthCapture, heightCapture,fpsCapture,« v4l2src »,« /dev/video0 »); // Initialise objet GSCapture désignant webcam
        // largeur et hauteur doivent être compatible avec la webcam – typiquement 160×120 ou 320×240 ou 640×480…
        // Meilleurs résultats avec framerate webcam entre 20 et 30 et frameRate programme idem ou multiple plus grand (40 pour 20 par ex)
        // la liste des webcam installées sous Ubuntu (Gnu/Linux) est donnée par la commande : ls /dev/video*

        // cam1.play();  // démarre objet GSCapture = la webcam – version GSVideo avant 0.9
        cam1.start();  // démarre objet GSCapture = la webcam – version GSVideo après 0.9

        //—— initialisation objet GSMovieMaker pour enregistrement vidéo —

          //GSMovieMaker(processing.core.PApplet parent, int requestWidth, int requestHeight, java.lang.String filename, int codecType, int codecQuality, int ifps)
          // IMPORTANT : le frameRate et ifps doivent être égaux !

          //—– initialisation de l’objet GSMovieMaker —
          maVideo = new GSMovieMaker(this, widthCapture, heightCapture, cheminFichier+nomFichier, GSMovieMaker.MJPEG, GSMovieMaker.MEDIUM, fpsCapture);
          // ici enregistrement dans fichier.avi (cf nom fichier) avec encodage MJPEG et qualité MEDIUM

          // all quality settings are WORST, LOW,MEDIUM, HIGH and BEST

          // Available codecs are:
          // THEORA
          // XVID
          // X264
          // DIRAC
          // MJPEG
          // MJPEG2K
          // As for the file formats, the following are autodetected from the filename extension:
          // .ogg: OGG
          // .avi: Microsoft’s AVI
          // .mov: Quicktime’s MOV
          // .flv: Flash Video
          // .mkv: Matroska container
          // .mp4: MPEG-4
          // .3gp: 3GGP video
          // .mpg: MPEG-1
          // .mj2: Motion JPEG 2000
          // Please note that some of the codecs/containers might not work as expected, depending
          // on which gstreamer plugins are installed. Also, some codec/container combinations
          // don’t seem to be compatible, for example THEORA+AVI or X264+OGG.

          //setQueueSize(int npre,int nenc)
          maVideo.setQueueSize(0, 10); // fixe le nombre de frame maxi en attente en pré-encodage (java- 0 si pas de limite) et en post-encodage (gstreamer)

          // Sets the maximum size of the pre-encoding and encoding queues. When the encoding queue is full, the frames start to be accumulated in the pre-encoding queue.
          // By setting the size of the pre-encoding queue to zero, it can grow arbitrarily large.    

} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

// Code type capture GSVideo – utilisation possible aussi de captureEvent()

  if (cam1.available() == true) { // si une nouvelle frame est disponible sur la webcam
    cam1.read(); // acquisition d’un frame
    image(cam1, 0, 0); // affiche image
    //set(0, 0, cam); // affiche image – plus rapide

    imgDest=cam1.get(); // récupère l’image GS video dans Pimage

    //— si l’enregistrement est activé —-
    if (flagRecord==true) {

        //— trace cercle rouge dans coin sup droit
        fill(rouge);
        stroke(rouge);
        ellipse (widthCapture–30,30,20,20);

        //—– enregistrement des images —    
        imgDest.loadPixels(); // charge les pixels en mémoire
        maVideo.addFrame(imgDest.pixels); // ajoute les pixels de l’image à la vidéo – attention ajoute les pixels et pas l’image…
        if (debug) println(« Nombre de frames en attente : «  + maVideo.getQueuedFrames());
        if (debug) println(« Nombre de frame abandonnés : «  + maVideo.getDroppedFrames());

    } // fin if flagRecord

  } // fin if available

        // while(true); // stoppe boucle draw

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

//———— gestion évènement clavier ———

void keyPressed() { // si une touche est appuyée

         if(key==‘e’) { // si touche ee enfoncee

           maVideo.start(); // lance l’objet GSMovieMaker
          println(« Enregistrement démarré »);
          flagRecord=true;

        }

        if(key==‘s’) { // si touche s enfoncee

          maVideo.finish(); // ferme l’objet MovieMaker
          println(« Enregistrement stoppé »);
          flagRecord=false;

        }

} //— fin si touche enfoncee

//— évènement capture vidéo avec librairie GSVideo—
//void captureEvent(GSCapture cam) { // est appelée lorsqu’une capture (nouvelle frame) survient – cam quelconque
// cf doc librairie Video Processing – cf exemple Capture LivePocky
// bloque pour plusieurs webcams

   // cette fonction est appelée à chaque fois qu’une nouvelle frame est disponible, quelque soit la caméra
   // utiliser des conditions pour tester la caméra disponible

  //if (cam1.available() == true) cam1.read(); // acquisition d’une nouvelle frame

//  } // fin fonction évènement captureEvent()

//————- Fonction d’arret de Processing —-

public void stop(){ // fonction d’arrêt de Processing

        cam1.delete(); // efface l’objet GScapture

        super.stop(); // obligatoire

} // fin fonction stop()

//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX