OGMRip

Depuis la version 0.11, OGMRip dispose d'un système de greffons pour les conteneurs et les codecs vidéo, audio et sous-titres. Ce document présente par l'exemple comment écrire un nouveau greffon. Nous allons donc développer étape par étape un nouveau codec audio qui permet d'encoder au format AAC en utilisant le codec neroAac.

Généralités

Un plugin OGMRip est principalement composé d'un GObject, d'une description et d'une fonction permettant de la récupérer. Selon le greffon, le GObject implémente un type spécifique: un OGMRipContainer pour un conteneur, un OGMRipVideoCodec pour un codec vidéo, un OGMRipAudioCodec pour un codec audio ou un OGMRipSubpCodec pour un codec de sous-titres. La description est contenue dans une structure dépendant elle aussi du type de greffon: un OGMRipContainerPlugin pour un conteneur, un OGMRipVideoPlugin pour un codec vidéo, un OGMRipAudioPlugin pour un codec audio et un OGMRipSubpPlugin pour un codec de sous-titres.

OGMRipNeroAac

Nous allons donc, dans un premier temps, définir l'objet OGMRipNeroAac. Comme il s'agit d'un codec audio, il doit hériter de OGMRipAudioCodec:

typedef struct _OGMRipNeroAac      OGMRipNeroAac;
typedef struct _OGMRipNeroAacClass OGMRipNeroAacClass;

struct _OGMRipNeroAac
{
  OGMRipAudioCodec parent_instance;
};

struct _OGMRipNeroAacClass
{
  OGMRipAudioCodecClass parent_class;
};

G_DEFINE_TYPE (OGMRipNeroAac, ogmrip_nero_aac, OGMRIP_TYPE_AUDIO_CODEC)

Spécifier un type de cette manière impose de définir deux procédures au préalable, une pour initialiser la classe et une pour initialiser l'objet:

static void
ogmrip_nero_aac_class_init (OGMRipNeroAacClass *klass)
{
}

static void
ogmrip_nero_aac_init (OGMRipNeroAac *nouveau)
{
}

En l'état, le greffon est quasiment compilable; il lui manque seulement les entêtes:

  #include <ogmrip.h>
#include <ogmjob.h>

On peut maintenant compiler:

$ gcc -Wall -c ogmrip-nero-aac.c `pkg-config --cflags ogmrip`

Et même éditer les liens:

$ gcc -shared ogmrip-nero-aac.o -o libogmrip-nero-aac.so

Évidemment, le greffon ne fait pour l'instant absolument rien. Il faut y ajouter le code pour l'encodage proprement dit. Ainsi, il faut d'abord extraire la piste audio au format wave puis l'encoder en AAC. Heureusement, ces deux actions peuvent être effectuées en parallèle grâce à une fifo et un OGMJobPipeline.

Nous allons donc commencer par modifier le code pour créer la fifo et ajouter le pipeline:

static gint ogmrip_nero_aac_run (OGMJobSpawn *spawn);


static void
ogmrip_nero_aac_class_init (OGMRipAacClass *klass)
{
  OGMJobSpawnClass *spawn_class = OGMJOB_SPAWN_CLASS (klass);

  /*
   * Surcharge de la fonction run()
   */
  spawn_class->run = ogmrip_nero_aac_run;
}

static void
ogmrip_nero_aac_init (OGMRipNeroAac *nouveau)
{
}

G_DEFINE_TYPE (OGMRipNeroAac, ogmrip_nero_aac, OGMRIP_TYPE_AUDIO_CODEC)

static gint
ogmrip_nero_aac_run (OGMJobSpawn *spawn)
{
  OGMJobSpawn *pipeline;
  gchar *fifo;
  gint result;

  /*
   * Création de la fifo
   */
  fifo = ogmrip_fs_mkftemp ("fifo.XXXXXX", NULL);

  /*
   * Création du pipeline
   */
  pipeline = ogmjob_pipeline_new ();

  /*
   * Ajout du pipeline dans le conteneur
   */
  ogmjob_container_add (OGMJOB_CONTAINER (spawn), pipeline);

  /*
   * Déréférencement du pipeline
   */
  g_object_unref (pipeline);

  /*
   * Appel de la fonction run() de l'object parent. Il s'agit d'une
   * éxécution bloquante.
   */
  result = OGMJOB_SPAWN_CLASS (ogmrip_nero_aac_parent_class)->run (spawn);

  /*
   * Après l'encodage, suppression du pipeline du conteneur
   */
  ogmjob_container_remove (OGMJOB_CONTAINER (spawn), pipeline);

  /*
   * Suppression de la fifo
   */
  ogmrip_fs_unref (fifo, TRUE);

  return result;
}

Là encore, notre greffon ne fait pas grand chose, mais l'infrastructure est complètement en place, prête à recevoir les processus pour l'encodage. Pour cela, nous allons définir deux fonctions, l'une pour constuire la ligne de commande d'extraction du wave, l'autre pour l'encodage en AAC.

static gchar **
ogmrip_wav_command (OGMRipAudioCodec *audio, const gchar *output)
{
  GPtrArray *argv;

  /*
   * Une fonction de création de ligne de commande wav/pcm est disponible
   * dans la libogmrip-mplayer
   */
  argv = ogmrip_mplayer_wav_command (audio, TRUE, NULL, output);

  return (gchar **) g_ptr_array_free (argv, FALSE);
}

static gchar **
ogmrip_aac_command (OGMRipAudioCodec *audio, const gchar *input)
{
  GPtrArray *argv;
  const gchar *output;
  gint quality;

  /*
   * Pour OGMRip, la qualité est comprise entre 0 et 10
   */
  quality = ogmrip_audio_codec_get_quality (audio);

  argv = g_ptr_array_new ();

  /*
   * Le nom de l'encodeur
   */
  g_ptr_array_add (argv, g_strdup ("neroAacEnc"));

  /*
   * La qualité est un nombre flottant compris entre 0 et 1
   */
  g_ptr_array_add (argv, g_strdup ("-q"));
  g_ptr_array_add (argv,
      g_strdup_printf ("%d.%d", quality / 10, quality % 10));

  /*
   * Le fichier d'entrée; il s'agit en fait de la fifo
   */
  g_ptr_array_add (argv, g_strdup ("-if"));
  g_ptr_array_add (argv, g_strdup (input));

  /*
   * Le fichier de sortie
   */
  g_ptr_array_add (argv, g_strdup ("-of"));
  output = ogmrip_codec_get_output (OGMRIP_CODEC (audio));
  g_ptr_array_add (argv, g_strdup (output));

  g_ptr_array_add (argv, NULL);

  return (gchar **) g_ptr_array_free (argv, FALSE);
}

Comme nous utilisons des fonctions de la libogmrip-mplayer, il ne faut pas oublier d'ajouter l'entête qui va avec:

#include <ogmrip-mplayer.h>

Modifions maintenant la fonction run() pour ajouter des processus dans le pipeline qui invoqueront les procédures définies au-dessus.

static gint
ogmrip_nero_aac_run (OGMJobSpawn *spawn)
{
  OGMJobSpawn *pipeline;
  OGMJobSpawn *child;

  gchar *fifo, **argv;
  gint result = OGMJOB_RESULT_ERROR;

  /*
   * Création de la fifo
   */
  fifo = ogmrip_fs_mkftemp ("fifo.XXXXXX", NULL);

  /*
   * Création du pipeline
   */
  pipeline = ogmjob_pipeline_new ();

  /*
   * Ajout du pipeline dans le conteneur
   */
  ogmjob_container_add (OGMJOB_CONTAINER (spawn), pipeline);

  /*
   * Déréférencement du pipeline
   */
  g_object_unref (pipeline);

  /*
   * Création de la ligne de commande pour l'extraction en wave
   */
  argv = ogmrip_wav_command (OGMRIP_AUDIO_CODEC (spawn), fifo);
  if (argv)
  {
    /*
     * Création du processus associé
     */
    child = ogmjob_exec_newv (argv);

    /*
     * Ajout d'une fonction pour analyser la sortie standard du processus.
     * Cette fonction est définie dans la libogmrip-mplayer
     */
    ogmjob_exec_add_watch_full (OGMJOB_EXEC (child),
        (OGMJobWatch) ogmrip_mplayer_wav_watch, spawn, TRUE, FALSE, FALSE);

    /*
     * Ajout du processus dans le conteneur
     */
    ogmjob_container_add (OGMJOB_CONTAINER (pipeline), child);

    /*
     * Déréférencement du processus
     */
    g_object_unref (child);

    /*
     * Création de la ligne de commande pour la conversion en AAC
     */
    argv = ogmrip_aac_command (OGMRIP_AUDIO_CODEC (spawn), fifo);
    if (argv)
    {
      /*
       * Création du processus associé
       */
      child = ogmjob_exec_newv (argv);

      /*
       * Ajout du processus dans le conteneur
       */
      ogmjob_container_add (OGMJOB_CONTAINER (pipeline), child);

      /*
       * Déréférencement du processus
       */
      g_object_unref (child);

      /*
       * Appel de la fonction run() de l'object parent. Il s'agit d'une
       * exécution bloquante.
       */
      result =
        OGMJOB_SPAWN_CLASS (ogmrip_nero_aac_parent_class)->run (spawn);
    }
  }

  /*
   * Après l'encodage, suppression du pipeline du conteneur
   */
  ogmjob_container_remove (OGMJOB_CONTAINER (spawn), pipeline);

  /*
   * Suppression de la fifo
   */
  ogmrip_fs_unref (fifo, TRUE);

  return result;
}

Description

Maintenant que le l'objet est complètement spécifié, il faut remplir la structure décrivant le plugin et définir la fonction permettant de la récupérer.

La structure de description requiert:

• une référence vers le module qui doit être initialisée à NULL;
• un type qui doit être initialisé en appelant la fonction ogmrip_nero_aac_get_type;
• le nom du module;
• une description du module;
• le format du fichier créé par le module. OGMRip supporte autant de format que MPlayer, il sont tous définis dans le type énuméré OGMRipFormatType.

La fonction doit obligatoirement s'appeler ogmrip_init_plugin et retourne un pointeur vers la structure de description. On profite également de cette fonction pour tester les prérequis, en l'occurrence si mplayer et neroAacEnc sont installés.

static OGMRipAudioPlugin nero_aac_plugin =
{
  NULL,
  G_TYPE_NONE,
  "nero-aac",
  "Nero AAC",
  OGMRIP_FORMAT_AAC
};

OGMRipPluginAudioCodec *
ogmrip_init_plugin (void)
{
  gchar *fullname;

  /*
   * Vérifier si mplayer est installé
   */
  if (!ogmrip_check_mplayer ())
    return NULL;

  /*
   * Vérifier si neroAacEnc est installé
   */
  fullname = g_find_program_in_path ("neroAacEnc");
  if (!fullname)
    return NULL;
  g_free (fullname);

  nero_aac_plugin.type = ogmrip_nero_aac_get_type ();

  return &nero_aac_plugin;
}

Il ne reste plus qu'à copier le plugin dans le répertoire dans lequel OGMRip cherche les greffons audio. Il s'agira probablement de /usr/lib/ogmrip/audio-codecs, /usr/local/lib/ogmrip/audio-codecs ou encore $HOME/lib/ogmrip/audio-codecs. Les codecs video, de sous-titres et les conteneurs doivent être installés dans les répertoires video-codecs, subp-codecs et containers, respectivement.

Et si tout s'est bien passé, le greffon apparaitra automatiquement dans la section appropriée de la fenêtre de préférences d'OGMRip ou dans une des listes de codecs ou de conteneurs de shRip.

Conclusion

Nous venons donc de voir comment créer un nouveau greffon pour OGMRip permettant d'encoder des pistes audio au format AAC en utilisant neroAAC. La création de greffon vidéo ou de sous-titres est quasiment similaire hormis quelques spécificités de la structure de description.

Ainsi, un greffon pour un codec vidéo nécessite de connaître le nombre de passes et le nombre de threads qu'il supporte; pour un codec de sous-titres, il faut spécifier s'ils sont au format texte.

La structure de description d'un conteneur diffère un peu plus en cela qu'elle doit spécifier s'il supporte les B-frames, le nombre maximum de flux audio et de sous-titres qu'il peut comporter et une liste de tous les formats qu'il peut contenir. Pour plus d'informations à ce sujet, vous pouvez vous référer au code du conteneur Matroska.

Enfin, vous pouvez récupérer l'archive complète du codec audio neroAac et vous en servir comme base pour d'autres greffons.