Sortie d'Ardour 4

Posté par . Édité par Ontologia, palm123, Nils Ratusznik et yPhil. Modéré par tuiu pol. Licence CC by-sa
Tags :
58
15
juin
2015
Audiovisuel

Ardour est un logiciel libre (licence GPL2) pour station de travail audio-numérique. Plus précisément, il s'agit d'un séquenceur enregistreur multi-pistes audio et MIDI doté de la plupart des fonctionnalités présentes sur les équivalents propriétaires professionnels.

Logo Ardour

Sa version 4 a été publiée le 18 avril 2015. Elle apporte des améliorations techniques, de nouvelles fonctionnalités, et plus d'un millier de corrections de bogues.

Parmi les nouveautés :

  • Ardour est maintenant proposé pour Windows, en plus des plateformes Linux et OS/X déjà prises en charge ;
  • le serveur de son Jack devient optionnel, afin de simplifier la prise en main par de nouveaux utilisateurs ;
  • l'interface utilisateur a été complètement revue dans une optique de modernisation.

Sommaire

Ardour en fonctionnement

Prise en charge de Windows

La version Windows ne fait pour l'instant l'objet d'aucun support. Elle est fournie en nightly build. Elle est donc toujours considérée en test, et n'est pas recommandée en production.

La communauté actuelle n'est pas en capacité d'offrir un support jugé suffisant, et Ardour recherche quelques personnes pour constituer un groupe d'utilisateurs Windows prêt à offrir du support en échange d'une partie des revenus générés par les utilisateurs Windows.

Le code compile sous Windows avec mingw/gcc.

Ajouts et nouveautés

Ce chapitre est une tentative de traduction des notes de publications. Il peut contenir des contresens. En cas de doute, vous pouvez vous reporter au texte original (en anglais). Et suggérer des meilleures interprétations.

Améliorations générales importantes

La limite du nombre de fichiers ouverts par le système d'exploitation est maintenant correctement utilisée, ce qui évite des problèmes à la sauvegarde de grosses sessions.

La consommation mémoire a été largement réduite (-80% pour une session Ardour vide).

Interface utilisateur

La technologie utilisée pour dessiner les zones d'édition et une part croissante du reste de l'interface a été recréée de zéro à partir de systèmes puissants, modernes et multiplateformes tels que Cairo.

Le procédé de création de thèmes a été recréé pour faciliter la modification de la palette de couleur utilisée par le programme. Les thèmes customisés pour Ardour 3 ne sont plus utilisables, donc vous verrez les thèmes par défaut à l'utilisation d'Ardour 4.

La plupart des icônes ont été remplacées par des images vectorielles et la mise à l'échelle des polices (font-scaling) a été revue.

Les fenêtres popup d'erreur ont été remplacées par des boutons indicateurs.

Audio et entrées/sorties MIDI

Ardour a complètement abstrait l'audio et les entrées/sorties MIDI, ce qui rend JACK optionnel pour cette fonction.

Plusieurs backends sont maintenant proposés pour :

  • JACK (toutes les plateformes)
  • ALSA (Linux seulement)
  • ASIO (Windows seulement)
  • CoreAudio (OS/X seulement)

Pour les développeurs et testeurs, un backend factice permet de générer des signaux de test et ne requiert aucune interface audio.

Les backends peuvent être changés à la volée sans relancer Ardour.

MIDI

  • Mesure de la latence MIDI
  • Énormément d'améliorations à l'édition et à la manipulation de données MIDI
  • Gestion de plugins avec sorties MIDI
  • Flux de données mixtes (MIDI+Audio) sur l'intégralité d'une piste ou d'un bus
  • Le rendu MIDI (MIDI bounce) est maintenant fonctionnel
  • Nouveau modèle d'édition sans mode, avec des outils/modes spécifiques à la souris pour dessiner les données de note et de contrôleur ou éditer la matière existante
  • La boîte de dialogue de transformation permet de modifier les propriétés de note (telles que le temps, la longueur et la vitesse)
  • Nouvelle vitesse de note lorsque l'ajout à la souris est basé sur les notes adjacentes
  • Meilleure gestion des problèmes d'importation de divers fichiers SMF (Standard MIDI Format)
  • Les lignes de grille de niveau sous-barre reflètent le choix d'unité de la grille
  • Les valeurs de contrôleur MIDI 14 bits sont prises en charge correctement

Édition

  • Nouvelle option pour contrôler quelles régions sont sélectionnées après une opération de découpage (split)
  • Limitation du déplacement des axes (la touche Maj limite le déplacement dans la direction initiale (haut/bas ou gauche/droite)
  • Amélioration de l'édition des lignes d'automatisation
  • Zoom maximum limité à 3 jours @ 48 kHz sur un écran de 1600 pixels de large
  • Mode ripple : ce nouveau mode d'édition peut accélérer notablement l'édition. Dans ce mode, les régions audio bougent pour s'adapter à l'édition après une opération de déplacement ou de suppression
  • Outil de découpe à la souris (s'ajoute au raccourci "s" (split), plus rapide mais plus obscur, pour satisfaire les utilisateurs habitués aux autres logiciels)
  • Suppression du mode zoom (il faut maintenant sélectionner un intervalle ou des objets, puis zoomer)
  • Ajout d'une zone de dépose (drop zone) : les régions, sélections et fichiers qui sont déposés (par glisser-déposer) sous les autres pistes créent une nouvelle piste
  • La sélection d'une piste et d'une région sont maintenant mutuellement exclusives
  • Suppression du bouton "all group active" (pour opérer sur toutes les pistes, il faut les sélectionner toutes (Ctrl+t))
  • Suppression du surlignage des noms de région (accessible en tant qu'option utilisateur)
  • Possibilité de désactiver de l'automatisation
  • Le défilement vertical bouge par pistes entières
  • La création d'une nouvelle "sequence regions" enlève les espaces vides entre les régions

Prise en charge des greffons VST

  • Les greffons VST (greffons VST natifs sous Windows, greffons VST Linux sous Linux) ne sont plus scannés automatiquement au premier lancement de l'application (ceci évite un crash d'Ardour au premier lancement lorsque des greffons cassés sont déjà installés)
  • Un outil de scan externe est utilisé pour identifier et tester les greffons VST à la demande de l'utilisateur depuis Ardour
  • Les greffons qui ne passent pas les tests sont automatiquement placés en liste noire pour ne pas être chargés par Ardour sauf s'il sont écrasés manuellement pas l'utilisateur

Support de la plateforme OS X

Contrairement à Ardour 3.x, Ardour 4.x est officiellement distribué pour OS X. Les prochaines versions devraient connaître une amélioration du support d'OS X.

  • Les fenêtres splash et boîtes de dialogue n'interrompent plus le travail
  • Les fichiers MIDNAM sont maintenant inclus
  • La position à l'écran des interfaces graphiques AudioUnit est plus rationnel et cohérent
  • Possibilité de charger bien plus de greffons d'instruments AudioUnit ("soft synth")
  • Sélection automatique de la version stéréo des greffons d'instruments AudioUnit si elle existe
  • Correction du problème de focus de l'interface graphique de l'AudioUnit "Carbon"
  • Les greffons AudioUnit ne sont plus scannés automatiquement au premier lancement de l'application (ceci évite un crash d'Ardour au premier lancement lorsque des greffons cassés sont déjà installés)
  • Les greffons qui ne passent pas les tests sont automatiquement placés en liste noire pour ne pas être chargés par Ardour sauf s'il sont écrasés manuellement pas l'utilisateur

Transport et contrôle

  • Le bouclage (loop) peut maintenant être un mode au lieu d'une opération. En mode bouclage, appuyer sur Play (touche espace) initialise la boucle.
  • Possibilité de spécifier un tempo en entrant le rythme à la main (Tap tempo)
  • Les touches Q et W permettent de naviguer entre les marqueurs
  • Mise à jour des horloges et images vidéo à la fréquence image (frame rate) de la video de la session
  • La fenêtre d'horloge se met à l'échelle correctement sur toutes les plateformes

Contrôle Mackie

  • Prise en charge du contrôleur "QCon"
  • Prise en charge des équipements "Mackie Control" d'origine
  • Transmission correcte des textes UTF-8 aux équipements "Mackie Control"

Divers

  • Export vers Soundcloud
  • Correction de l'enregistrement des fichiers où le nombre d'échantillons dépasse la limite de 32 bits
  • Assignation des touches déplacée dans "Préférences"
  • Éditeur de thème déplacé dans "Préférences"
  • Rationalisation de l'assignation des touches
  • Le système de build fonctionne correctement avec Python 3
  • Amélioration du support des contrôles et pré-réglages LV2
  • Suppression de plusieurs bibliothèques anciennement maintenues au sein des sources d'Ardour

Nouveaux binding maps MIDI

  • Akai MPK61

Nouveaux MIDNAM pris en charge

  • E-Mu XL-1

Financement

Le développement à temps plein d'Ardour est possible grâce au support financier des utilisateurs.

Ceux-ci sont invités à faire un don ponctuel ou à souscrire à un abonnement (de 1$ à 50$ par mois). Le don donne droit au téléchargement du logiciel. L'abonnement donne droit aux mises à jour.

Ce système de vente est avant tout incitatif. Il est possible de compiler Ardour gratuitement depuis les sources, et les utilisateurs sous linux obtiennent en général Ardour via leur gestionnaire de paquets. Mais ce sont ces rentrées d'argent qui font vivre le logiciel.

L'objectif est d'atteindre 54 k$ de dons annuellement. Les 845 abonnés actuels fournissent 1875$ par mois (objectif 4500$).

  • # Les technos

    Posté par . Évalué à 5.

    Je n'ai pas pensé à le mentionner dans la dépêche. C'est précisé ici.

    C'est principalement du C++ / GTK, avec un peu de C et d'assembleur (et en même temps, Debian le propose pour plein d'architectures, donc peut-être que les parties en assembleur sont optionnelles ?).

    • [^] # Re: Les technos

      Posté par . Évalué à 6.

      Je serais assez curieux de savoir pourquoi il y a de l'assembleur ; dette technique, interaction bas-niveau avec le matériel, autre ?

      • [^] # Re: Les technos

        Posté par (page perso) . Évalué à 3. Dernière modification le 16/06/15 à 09:45.

        Après une petite recherche dans l'arbre des sources,

        % find . -name *.s
        ./libs/ardour/sse_functions_64bit_win.s
        ./libs/ardour/sse_functions.s
        ./libs/ardour/sse_functions_64bit.s

        On dirait des interactions avec le hardware pour les extensions SSE des processeurs.

  • # Je l'attendais.

    Posté par . Évalué à 6.

    J'attendais cette sortie avec impatience. Étant musicien(guitare, clavier, basse, lapsteel, etc) et sous linux, j'ai très vite découvert Ardour. J'ai aimer mon passage a Ardour3. Par contre même si la transition entre la version 3 et la 4 s'est fait facilement, le thème par défaut me déplais. On dirais qu'ils avaient avances avec la sortie de la version 3 niveau theme et tout, mais la c'est mort. Sinon, super sympa, mis-a-part le changement de theme, tout est parfait, il gobe moins de ressources, donc plus pour le traitement…

    • [^] # Re: Je l'attendais.

      Posté par (page perso) . Évalué à 1.

      Je suis content de voir que je ne suis pas le seul a trouver le nouveau theme moche et pas adapte a du travail pro. Des dégradés partout, des waves shapes blanches pures (mais pourquoi?…), plus de couleurs custom sur les pistes. Il y a clairement un pas en arrière la dessus. C'est dommage. L'interface d'origine était sobre et efficace.

      A cote de ça, le soft est vraiment bon. Il n'y a pas beaucoup de logiciels de son de cette qualité en libre et c'est a signaler. Je trouve le système de souscription base sur la compilation et le support vraiment intéressant.

  • # Plantage avec OS X Yosémite

    Posté par . Évalué à 1.

    Je travaillais avec la version 3 sans problème sous linux. J'ai changé pour un macbook pro sous Yosémite. Or Ardour 4 plante si l'on choisit CoreAudio comme driver audio. Il a l'air d'être plus stable avec Jack. Avez-vous eu les mêmes soucis ?

  • # je ne comprend pas cette phrase

    Posté par . Évalué à 2.

    Le don donne droit au téléchargement du logiciel. L'abonnement donne droit aux mises à jour.

    donc si je ne donnes pas, je ne peux pas telecharger/utiliser/mettre à jour le logiciel ?

    • [^] # je crois que GCompris

      Posté par . Évalué à 6.

      donc si je ne donnes pas, je ne peux pas telecharger/utiliser/mettre à jour le logiciel ?

      C'est bien ça.

      Mais comme je l'écris en dessous,

      Ce système de vente est avant tout incitatif. Il est possible de compiler Ardour gratuitement depuis les sources, et les utilisateurs sous linux obtiennent en général Ardour via leur gestionnaire de paquets.

      Tu peux aussi avoir un copain qui a acheté le binaire et te le donne légalement (je pense).

      Bref, c'est libre, mais pour faire rentrer de l'argent dans le projet, on demande aux gens qui téléchargent le binaire de mettre (modestement) la main à la poche.

      (Et ça vaut le coup de payer pas cher pour pas s'emmerder avec la compilation…)

      • [^] # Re: je crois que GCompris

        Posté par . Évalué à 4.

        à ce moment là ce n'est pas un DON, mais un ACHAT
        j'ACHETE la version compilée
        ou je compile moi meme à partir des sources.

        ce serait un don si la version compilée etait dispo gratuitement, et que la personne, appreciant le produit decide de DONner de l'argent pour le travail effectué.

    • [^] # Re: je ne comprend pas cette phrase

      Posté par (page perso) . Évalué à 1.

      Tu peux le compiler gratuitement.
      Tu peux aussi trouver des distributions qui l'intègre via des dépôts. Tango Studio l'avais intégré à l'époque de la sortie de Ardour 3.

      • [^] # Re: je ne comprend pas cette phrase

        Posté par (page perso) . Évalué à 2.

        pour mémoire il se compile très facilement sur une mageia, je l'ai installé récemment (sans avoir fait de don, honte à moi!!), pas pris encore le temps de le tester en profondeur, je reprochais à la version 3 d'être trop confuse par rapport à rosegarden, je dois maintenant me faire mon opinion avec cette version 4.

        http://www.funix.org mettez un manchot dans votre PC

  • # Financement

    Posté par . Évalué à 3. Dernière modification le 24/06/15 à 14:37.

    Financement
    Le développement à temps plein d'Ardour est possible grâce au support financier des utilisateurs.
    Ceux-ci sont invités à faire un don ponctuel ou à souscrire à un abonnement (de 1$ à 50$ par mois). Le don donne droit au téléchargement du logiciel. L'abonnement donne droit aux mises à jour.
    Ce système de vente est avant tout incitatif. Il est possible de compiler Ardour gratuitement depuis les sources, et les utilisateurs sous linux obtiennent en général Ardour via leur gestionnaire de paquets. Mais ce sont ces rentrées d'argent qui font vivre le logiciel.

    Je trouve ce système de financement très bien. Cela permet de faire payer à un prix libre un logiciel libre, et même d'assurer une rentrée continu d'argent.
    Également, cela ne bloque pas l'accès aux plus démunis (qui voudraient utiliser ce logiciel!) qui pourront compiler le logiciel si il le peuvent, sinon il est probable qu'un gentil mail a Ardour expliquant la situation permette d'avoir un binaire gratuitement (pure spéculation!).

    Sous gnu/linux, il est conseillé d'utiliser les gestionnaire de paquet, pour de meilleurs intégrations, des (dé/)installations plus propre, éviter des virus… Pleins de bonnes raisons.
    En passant par ce biais nous pouvons outrepasser le système mis en place par Ardour pour leur financement. D'ailleurs nous ne somme meme pas forcément au courant de ce programme (j'ai jeté un oeil dans la logithèque Ubuntu, aucune mention de ce financement n'est présent).

    Suis-je le seul à trouver que c'est dommage que ce soit dans le monde libre que ce financement ne soit pas proposé ?
    J'en viens a me demander les solutions de financement d'application libre autre que le don. Quelques idées plus ou moins bonne/acceptable : des dépôts payants ? proposer ardour dans les "Logiciels payant" de Ubuntu et des autres stores ? Une solution de paiement/verrou numérique intégrée à l'application ? La mise en place d'un programme dédié à ce genre de financement dans Ubuntu/autre. Une approche a la Gnu Pricing qui permette de payer en fonction de son usage ?

    • [^] # Commentaire supprimé

      Posté par . Évalué à -10.

      Ce commentaire a été supprimé par l'équipe de modération.

    • [^] # Re: Financement

      Posté par (page perso) . Évalué à 2.

      Donc la personne qui n'a ni les moyens, ni les compétences techniques, doit détailler sa situation pour avoir un binaire ?

      Compiler depuis les sources il faut bien comprendre que c'est loin d'être à la portée de toue le monde (ne serait-ce qu'en temps à y investir pour savoir comment faire).

      Bref, cette solution n'est pas parfaite.

      Il y a un vrai problème pour le financement des projets libres c'est pas nouveau, et même pour les médias alternatifs en général. À PSES j'ai eu l'occasion de discuter avec pas mal de monde, c'est vraiment une constante.

      • [^] # Re: Financement

        Posté par . Évalué à 0. Dernière modification le 25/06/15 à 21:21.

        Oui, tu as raison, ces solutions ne sont pas parfaites.

        D'autres solution pratiquée sont d'afficher une demande de don à l'ouverture du logiciel, ou de faire comme ardour, mais de laisser un lien planqué pour téléchargement gratuitement (après avoir été sensibilisé a l'importance du financement).

        L'approche à la gnu pricing mélangée à du flattr et à cette méthode de relance (si pas de don) serait vraiment intéressante je crois.

        Imaginons un programme (libre) intégré par défaut à des distributions.
        Si le user n'a pas fait de don, il s'affiche une fois par mois, avec un message de sensibilisation.
        Il tourne entièrement en local et fait des stat sur les logiciels utilisés, et les sites (libres) visités. On fixe un montant d’abonnement mensuel (je mettrais volontiers 30€ perso).
        En fin de mois on à un récap des logiciels qu'on à utilisé et une proposition de répartition des dons entre les différents programmes/site/service utilisés
        La proposition de répartition peut se faire
        - suivant l'utilisation effective du programme
        - en prenant en compte la taille du programme (plus gros = plus cher),
        - la régularité des mises à jour (on ne vas pas donner beaucoup d'argent pendant 10 ans à un outil de base du type grep alors qu'il n'est plus activement développé meme si il est très utilisé, juste un peu pour la maintenance) (notez bien que j'ai aucune idée si grep est encore activement développé ou juste maintenu).
        - enfin la répartition peut bien sur être customisée (à la humble bundle) avant envoi.

        Bien sur, il faut savoir comment on fait pour automatiser les don, maintenant qu'on sait combien on donne et à qui !

        Une fois qu'on a cette base, on peut même imaginer des "récompenses" a partir de certains seuils de don (comme les sites de crowd funding). Par exemple ou gagnerait le droit de voter pour la prochaine fonctionnalité du programme (sans que ca ai un caractère obligatoire pour le projet cible).

        Le user pourra se dire
        - sensibilisation—"A oui, j'utilise tout çà gratuitement, ça marche bien, ça serait cool d'aider."
        - Proposition de répartition—"J'utilise effectivement régulièrement ce logiciel, je suis sur que je ne fais pas un "achat inutile" en payant les gens qui le font".
        - Proposition de vote—Cool, il me faudrait cette fonctionnalité, je vais donner plus de x euros.
        - Paiement - ah c'est simple, juste a cliquer ici et la.

        Quels ont été les idées/solutions qui sont ressorties de tes discussions ?

        • [^] # Re: Financement

          Posté par (page perso) . Évalué à 2.

          Un logiciel qui espionne ce que tu utilises, je suis pas hyper fan non plus. Et puis le temps d'utilisation n'est pas forcément lié aux besoins de dév, ou à l'utilité: photorecord/testdisk m'ont déjà sacrément aidé, et pourtant c'est pas le genre de truc que t'utilises souvent (enfin il vaut mieux).

          Des discussions c'est surtout la constante du "il nous faut des sous" qui sort.

          Je pense qu'il faudrait déjà un site qui regroupe les logiciels libres et leurs besoins, ce qui a déjà été donné jusqu'ici, ce qu'il manque, à quoi servent le logiciel et les sous, etc. Un truc géré de façon indépendante. La question serait de savoir dans quel ordre présenter les logiciels: par popularité serait probablement une erreur (les petits n'auraient jamais de sous). Au hasard ? Ceux qui ont reçu le moins en premier ?

      • [^] # Re: Financement

        Posté par . Évalué à 4.

        Donc la personne qui n'a ni les moyens, ni les compétences techniques, doit détailler sa situation pour avoir un binaire ?

        En l'occurrence, le prix pour le binaire, c'est 1$ (un dollar américain). On parle d'utilisateurs qui ont un PC décent et probablement (je leur souhaite) une interface audio qui doit coûter facilement 50€ d'occasion (compter plutôt 100), sans parler des instruments de musique. Bref, 1$ c'est peanuts. C'est une somme symbolique.

        Ceux qui payent pas, c'est ceux qui ont les paquets de leur distro, qui ont la flemme, ou qui boycottent Paypal. C'est pas ceux qui n'ont pas les moyens.

        Et probablement que ceux qui font l'effort de sortir la carte et se taper l'interface Paypal, ils donnent un poil plus, tant qu'à y être.

        Compiler depuis les sources il faut bien comprendre que c'est loin d'être à la portée de toue le monde (ne serait-ce qu'en temps à y investir pour savoir comment faire).

        Oui et même si c'est probablement à ma portée, je préfèrerais largement sortir 1$ que m'emmerder à le faire. (Je dis ça au conditionnel parce qu'en tant qu'utilisateur Debian j'ai le confort du tout automatique.)

        • [^] # Re: Financement

          Posté par (page perso) . Évalué à 2.

          je parlais du principe en général, pas du cas particulier d'Ardour. Un ordinateur on peut aussi l'avoir eu gratuitement (don par exemple), ou s'en servir dans une bibliothèque/une association/je ne sais quoi.

          Je ne critique pas du tout ce que fait Ardour, ou GCompris qui fai(sai?)t la même chose avec Windows, je dis juste que le modèle n'est pas parfait, et qu'il ne me semblerait pas judicieux de le généraliser. En dehors de la somme, tout le monde n'a pas une carte de crédit non plus. Après sur Android il y a des cas de logiciels payants sur le dépôt google, et gratuit sur F-Droid, c'est pas forcément une mauvaise idée (là y'a plus d'histoire de compilation, c'est un dépôt libre à installer).

    • [^] # Re: Financement

      Posté par (page perso) . Évalué à 1.

      Ceux qui utilisent Ardour ont généralement aussi acheté du matériel audio qui coute beaucoup plus cher. Payer 1$ par mois doit être à la portée de ces gens-là ;-)

      « Un animal d'une atterrante stupidité : il est persuadé que si vous ne le voyez pas, il ne vous voit pas non plus » (H2G2)

  • # Erreur à l'installation (Mageia 5)

    Posté par . Évalué à 0.

    Bonjour,

    Je reçois le message :

    ligne 392: ./install.sh: Permission non accordée

    Que faire ?

    Merci.

    • [^] # Re: Erreur à l'installation (Mageia 5)

      Posté par . Évalué à 4.

      Peut être : chmod +x ./install.sh

      Please do not feed the trolls

    • [^] # Re: Erreur à l'installation (Mageia 5)

      Posté par (page perso) . Évalué à -3.

      Que faire ?

      Ouvrir un bouquin d'unix pour les nuls sans doute.

      http://www.funix.org mettez un manchot dans votre PC

      • [^] # Re: Erreur à l'installation (Mageia 5)

        Posté par . Évalué à -3. Dernière modification le 25/06/15 à 13:32.

        Salut superman !

        Comme tu as l'air de maîtriser un max au vu de ton super commentaire, je te liste ci-dessous la source du script de l'install. Tu ne devrais pas tarder à me donner la solution qui va bien ;-)
        Par avance; merci !

        !/bin/sh
        # This script was generated using Makeself 2.1.5
        
        CRCsum="4212772314"
        MD5="078df016acd8a6e1cff35ad5033d096c"
        TMPROOT=${TMPDIR:=/tmp}
        
        label="Ardour"
        script="./install.sh"
        scriptargs=""
        targetdir="Ardour_64bit-4.0.0"
        filesizes="53790720"
        keep=n
        
        print_cmd_arg=""
        if type printf > /dev/null; then
            print_cmd="printf"
        elif test -x /usr/ucb/echo; then
            print_cmd="/usr/ucb/echo"
        else
            print_cmd="echo"
        fi
        
        unset CDPATH
        
        MS_Printf()
        {
            $print_cmd $print_cmd_arg "$1"
        }
        
        MS_Progress()
        {
            while read a; do
            MS_Printf .
            done
        }
        
        MS_diskspace()
        {
            (
            if test -d /usr/xpg4/bin; then
                PATH=/usr/xpg4/bin:$PATH
            fi
            df -kP "$1" | tail -1 | awk '{print $4}'
            )
        }
        
        MS_dd()
        {
            blocks=`expr $3 / 1024`
            bytes=`expr $3 % 1024`
            dd if="$1" ibs=$2 skip=1 obs=1024 conv=sync 2> /dev/null | \
            { test $blocks -gt 0 && dd ibs=1024 obs=1024 count=$blocks ; \
              test $bytes  -gt 0 && dd ibs=1 obs=1024 count=$bytes ; } 2> /dev/null
        }
        
        MS_Help()
        {
            cat << EOH >&2
        Makeself version 2.1.5
         1) Getting help or info about $0 :
          $0 --help   Print this message
          $0 --info   Print embedded info : title, default target directory, embedded script ...
          $0 --lsm    Print embedded lsm entry (or no LSM)
          $0 --list   Print the list of files in the archive
          $0 --check  Checks integrity of the archive
        
         2) Running $0 :
          $0 [options] [--] [additional arguments to embedded script]
          with following options (in that order)
          --confirm             Ask before running embedded script
          --noexec              Do not run embedded script
          --keep                Do not erase target directory after running
                    the embedded script
          --nox11               Do not spawn an xterm
          --nochown             Do not give the extracted files to the current user
          --target NewDirectory Extract in NewDirectory
          --tar arg1 [arg2 ...] Access the contents of the archive through the tar command
          --                    Following arguments will be passed to the embedded script
        EOH
        }
        
        MS_Check()
        {
            OLD_PATH="$PATH"
            PATH=${GUESS_MD5_PATH:-"$OLD_PATH:/bin:/usr/bin:/sbin:/usr/local/ssl/bin:/usr/local/bin:/opt/openssl/bin"}
            MD5_ARG=""
            MD5_PATH=`exec <&- 2>&-; which md5sum || type md5sum`
            test -x "$MD5_PATH" || MD5_PATH=`exec <&- 2>&-; which md5 || type md5`
            test -x "$MD5_PATH" || MD5_PATH=`exec <&- 2>&-; which digest || type digest`
            PATH="$OLD_PATH"
        
            MS_Printf "Verifying archive integrity..."
            offset=`head -n 402 "$1" | wc -c | tr -d " "`
            verb=$2
            i=1
            for s in $filesizes
            do
                crc=`echo $CRCsum | cut -d" " -f$i`
                if test -x "$MD5_PATH"; then
                    if test `basename $MD5_PATH` = digest; then
                        MD5_ARG="-a md5"
                    fi
                    md5=`echo $MD5 | cut -d" " -f$i`
                    if test $md5 = "00000000000000000000000000000000"; then
                        test x$verb = xy && echo " $1 does not contain an embedded MD5 checksum." >&2
                    else
                        md5sum=`MS_dd "$1" $offset $s | eval "$MD5_PATH $MD5_ARG" | cut -b-32`;
                        if test "$md5sum" != "$md5"; then
                            echo "Error in MD5 checksums: $md5sum is different from $md5" >&2
                            exit 2
                        else
                            test x$verb = xy && MS_Printf " MD5 checksums are OK." >&2
                        fi
                        crc="0000000000"; verb=n
                    fi
                fi
                if test $crc = "0000000000"; then
                    test x$verb = xy && echo " $1 does not contain a CRC checksum." >&2
                else
                    sum1=`MS_dd "$1" $offset $s | CMD_ENV=xpg4 cksum | awk '{print $1}'`
                    if test "$sum1" = "$crc"; then
                        test x$verb = xy && MS_Printf " CRC checksums are OK." >&2
                    else
                        echo "Error in checksums: $sum1 is different from $crc"
                        exit 2;
                    fi
                fi
                i=`expr $i + 1`
                offset=`expr $offset + $s`
            done
            echo " All good."
        }
        
        UnTAR()
        {
            tar $1vf - 2>&1 || { echo Extraction failed. > /dev/tty; kill -15 $$; }
        }
        
        finish=true
        xterm_loop=
        nox11=n
        copy=none
        ownership=y
        verbose=n
        
        initargs="$@"
        
        while true
        do
            case "$1" in
            -h | --help)
            MS_Help
            exit 0
            ;;
            --info)
            echo Identification: "$label"
            echo Target directory: "$targetdir"
            echo Uncompressed size: 52540 KB
            echo Compression: none
            echo Date of packaging: Fri Apr 17 22:40:09 UTC 2015
            echo Built with Makeself version 2.1.5 on 
            echo Build command was: "/usr/bin/makeself \\
            \"--nocomp\" \\
            \"Ardour_64bit-4.0.0/\" \\
            \"Ardour_64bit-4.0.0.run\" \\
            \"Ardour\" \\
            \"./install.sh\""
            if test x$script != x; then
                echo Script run after extraction:
                echo "    " $script $scriptargs
            fi
            if test x"" = xcopy; then
                echo "Archive will copy itself to a temporary location"
            fi
            if test x"n" = xy; then
                echo "directory $targetdir is permanent"
            else
                echo "$targetdir will be removed after extraction"
            fi
            exit 0
            ;;
            --dumpconf)
            echo LABEL=\"$label\"
            echo SCRIPT=\"$script\"
            echo SCRIPTARGS=\"$scriptargs\"
            echo archdirname=\"Ardour_64bit-4.0.0\"
            echo KEEP=n
            echo COMPRESS=none
            echo filesizes=\"$filesizes\"
            echo CRCsum=\"$CRCsum\"
            echo MD5sum=\"$MD5\"
            echo OLDUSIZE=52540
            echo OLDSKIP=403
            exit 0
            ;;
            --lsm)
        cat << EOLSM
        No LSM.
        EOLSM
            exit 0
            ;;
            --list)
            echo Target directory: $targetdir
            offset=`head -n 402 "$0" | wc -c | tr -d " "`
            for s in $filesizes
            do
                MS_dd "$0" $offset $s | eval "cat" | UnTAR t
                offset=`expr $offset + $s`
            done
            exit 0
            ;;
            --tar)
            offset=`head -n 402 "$0" | wc -c | tr -d " "`
            arg1="$2"
            shift 2
            for s in $filesizes
            do
                MS_dd "$0" $offset $s | eval "cat" | tar "$arg1" - $*
                offset=`expr $offset + $s`
            done
            exit 0
            ;;
            --check)
            MS_Check "$0" y
            exit 0
            ;;
            --confirm)
            verbose=y
            shift
            ;;
            --noexec)
            script=""
            shift
            ;;
            --keep)
            keep=y
            shift
            ;;
            --target)
            keep=y
            targetdir=${2:-.}
            shift 2
            ;;
            --nox11)
            nox11=y
            shift
            ;;
            --nochown)
            ownership=n
            shift
            ;;
            --xwin)
            finish="echo Press Return to close this window...; read junk"
            xterm_loop=1
            shift
            ;;
            --phase2)
            copy=phase2
            shift
            ;;
            --)
            shift
            break ;;
            -*)
            echo Unrecognized flag : "$1" >&2
            MS_Help
            exit 1
            ;;
            *)
            break ;;
            esac
        done
        
        case "$copy" in
        copy)
            tmpdir=$TMPROOT/makeself.$RANDOM.`date +"%y%m%d%H%M%S"`.$$
            mkdir "$tmpdir" || {
            echo "Could not create temporary directory $tmpdir" >&2
            exit 1
            }
            SCRIPT_COPY="$tmpdir/makeself"
            echo "Copying to a temporary location..." >&2
            cp "$0" "$SCRIPT_COPY"
            chmod +x "$SCRIPT_COPY"
            cd "$TMPROOT"
            exec "$SCRIPT_COPY" --phase2 -- $initargs
            ;;
        phase2)
            finish="$finish ; rm -rf `dirname $0`"
            ;;
        esac
        
        if test "$nox11" = "n"; then
            if tty -s; then                 # Do we have a terminal?
            :
            else
                if test x"$DISPLAY" != x -a x"$xterm_loop" = x; then  # No, but do we have X?
                    if xset q > /dev/null 2>&1; then # Check for valid DISPLAY variable
                        GUESS_XTERMS="xterm rxvt dtterm eterm Eterm kvt konsole aterm"
                        for a in $GUESS_XTERMS; do
                            if type $a >/dev/null 2>&1; then
                                XTERM=$a
                                break
                            fi
                        done
                        chmod a+x $0 || echo Please add execution rights on $0
                        if test `echo "$0" | cut -c1` = "/"; then # Spawn a terminal!
                            exec $XTERM -title "$label" -e "$0" --xwin "$initargs"
                        else
                            exec $XTERM -title "$label" -e "./$0" --xwin "$initargs"
                        fi
                    fi
                fi
            fi
        fi
        
        if test "$targetdir" = "."; then
            tmpdir="."
        else
            if test "$keep" = y; then
            echo "Creating directory $targetdir" >&2
            tmpdir="$targetdir"
            dashp="-p"
            else
            tmpdir="$TMPROOT/selfgz$$$RANDOM"
            dashp=""
            fi
            mkdir $dashp $tmpdir || {
            echo 'Cannot create target directory' $tmpdir >&2
            echo 'You should try option --target OtherDirectory' >&2
            eval $finish
            exit 1
            }
        fi
        
        location="`pwd`"
        if test x$SETUP_NOCHECK != x1; then
            MS_Check "$0"
        fi
        offset=`head -n 402 "$0" | wc -c | tr -d " "`
        
        if test x"$verbose" = xy; then
            MS_Printf "About to extract 52540 KB in $tmpdir ... Proceed ? [Y/n] "
            read yn
            if test x"$yn" = xn; then
                eval $finish; exit 1
            fi
        fi
        
        MS_Printf "Uncompressing $label"
        res=3
        if test "$keep" = n; then
            trap 'echo Signal caught, cleaning up >&2; cd $TMPROOT; /bin/rm -rf $tmpdir; eval $finish; exit 15' 1 2 3 15
        fi
        
        leftspace=`MS_diskspace $tmpdir`
        if test $leftspace -lt 52540; then
            echo
            echo "Not enough space left in "`dirname $tmpdir`" ($leftspace KB) to decompress $0 (52540 KB)" >&2
            if test "$keep" = n; then
                echo "Consider setting TMPDIR to a directory with more free space."
           fi
            eval $finish; exit 1
        fi
        
        for s in $filesizes
        do
            if MS_dd "$0" $offset $s | eval "cat" | ( cd "$tmpdir"; UnTAR x ) | MS_Progress; then
                if test x"$ownership" = xy; then
                    (PATH=/usr/xpg4/bin:$PATH; cd "$tmpdir"; chown -R `id -u` .;  chgrp -R `id -g` .)
                fi
            else
                echo
                echo "Unable to decompress $0" >&2
                eval $finish; exit 1
            fi
            offset=`expr $offset + $s`
        done
        echo
        
        cd "$tmpdir"
        res=0
        if test x"$script" != x; then
            if test x"$verbose" = xy; then
                MS_Printf "OK to execute: $script $scriptargs $* ? [Y/n] "
                read yn
                if test x"$yn" = x -o x"$yn" = xy -o x"$yn" = xY; then
                    eval $script $scriptargs $*; res=$?;
                fi
            else
                eval $script $scriptargs $*; res=$?
            fi
            if test $res -ne 0; then
                test x"$verbose" = xy && echo "The program '$script' returned an error code ($res)" >&2
            fi
        fi
        if test "$keep" = n; then
            cd $TMPROOT
            /bin/rm -rf $tmpdir
        fi
        eval $finish; exit $res
        • [^] # Re: Erreur à l'installation (Mageia 5)

          Posté par (page perso) . Évalué à 4. Dernière modification le 25/06/15 à 13:39.

          Le code :

          script="./install.sh"
          scriptargs=""
          (...)
                  eval $script $scriptargs $*; res=$?

          Le test (avec un faux install.sh contenant juste un echo OK) :

          $ sh install.sh 
          OK
          $ script="./install.sh"
          $ scriptargs=""
          $ eval $script $scriptargs $*;
          bash: ./install.sh: Permission non accordée
          $ ./install.sh
          bash: ./install.sh: Permission non accordée
          $ chmod +x ./install.sh 
          $ eval $script $scriptargs $*;
          OK
          $ ./install.sh
          OK

          La réponse :

          $ chmod +x ./install.sh
    • [^] # Re: Erreur à l'installation (Mageia 5)

      Posté par . Évalué à 3.

      Est-ce que tu exécutes le script d'installation en tant que root (ou bien avec comme cible un répertoire sur lequel tu as les droits) ?

    • [^] # Commentaire supprimé

      Posté par . Évalué à -10.

      Ce commentaire a été supprimé par l'équipe de modération.

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.