Recherche avancée

Médias (1)

Mot : - Tags -/musée

Autres articles (86)

  • Installation en mode ferme

    4 février 2011, par

    Le mode ferme permet d’héberger plusieurs sites de type MediaSPIP en n’installant qu’une seule fois son noyau fonctionnel.
    C’est la méthode que nous utilisons sur cette même plateforme.
    L’utilisation en mode ferme nécessite de connaïtre un peu le mécanisme de SPIP contrairement à la version standalone qui ne nécessite pas réellement de connaissances spécifique puisque l’espace privé habituel de SPIP n’est plus utilisé.
    Dans un premier temps, vous devez avoir installé les mêmes fichiers que l’installation (...)

  • Formulaire personnalisable

    21 juin 2013, par

    Cette page présente les champs disponibles dans le formulaire de publication d’un média et il indique les différents champs qu’on peut ajouter. Formulaire de création d’un Media
    Dans le cas d’un document de type média, les champs proposés par défaut sont : Texte Activer/Désactiver le forum ( on peut désactiver l’invite au commentaire pour chaque article ) Licence Ajout/suppression d’auteurs Tags
    On peut modifier ce formulaire dans la partie :
    Administration > Configuration des masques de formulaire. (...)

  • HTML5 audio and video support

    13 avril 2011, par

    MediaSPIP uses HTML5 video and audio tags to play multimedia files, taking advantage of the latest W3C innovations supported by modern browsers.
    The MediaSPIP player used has been created specifically for MediaSPIP and can be easily adapted to fit in with a specific theme.
    For older browsers the Flowplayer flash fallback is used.
    MediaSPIP allows for media playback on major mobile platforms with the above (...)

Sur d’autres sites (8438)

  • Evolution #4471 : singulier_ou_pluriel pour l’arabe

    1er juin 2020, par George Kandalaft

    Correction :

    1. <span class="CodeRay"><span class="comment">/**
      2. 

    2.  * Afficher un message "un truc"/("deux trucs" pour l'arabe)/"N trucs" 
      3. 

    3.  * Les items sont à indiquer comme pour la fonction _T() sous la forme :
      4. 

    4.  * "module:chaine" 
      5. 

    5.  *
      6. 

    6.  * @param int $nb : le nombre
      7. 

    7.  * @param string $chaine_un : l'item de langue si $nb vaut un (ou $nb > 10 pour l'arabe)
      8. 

    8.  * @param string $chaine_plusieurs : l'item de lanque si $nb > 1 ($nb est compris entre 3 et 10 pour l'arabe)
      9. 

    9.  * @param string $var : La variable à remplacer par $nb dans l'item de langue (facultatif, défaut "nb")
      10. 

    10.  * @param array $vars : Les autres variables nécessaires aux chaines de langues (facultatif)
      11. 

    11.  * @return string : la chaine de langue finale en utilisant la fonction _T()
      12. 

    12.  */</span>
      13. 

    13. <span class="keyword">function</span> <span class="function">ar_singulier_ou_pluriel</span>(<span class="local-variable">$nb</span>, <span class="local-variable">$chaine_un</span>, <span class="local-variable">$chaine_plusieurs</span>, <span class="local-variable">$var</span> = <span class="string"><span class="delimiter">'</span><span class="content">nb</span><span class="delimiter">'</span></span>, <span class="local-variable">$vars</span> = <span class="predefined">array</span>()) {
      14. 

    14.     <span class="keyword">if</span> (!<span class="local-variable">$nb</span> = <span class="predefined">intval</span>(<span class="local-variable">$nb</span>)) {
      15. 

    15.         <span class="keyword">return</span> <span class="string"><span class="delimiter">'</span><span class="delimiter">'</span></span>;
      16. 

    16.     }
      17. 

    17.     <span class="keyword">if</span> (!<span class="predefined">is_array</span>(<span class="local-variable">$vars</span>)) {
      18. 

    18.         <span class="keyword">return</span> <span class="string"><span class="delimiter">'</span><span class="delimiter">'</span></span>;
      19. 

    19.     }
      20. 

    20.     <span class="local-variable">$vars</span>[<span class="local-variable">$var</span>] = <span class="local-variable">$nb</span>;
      21. 

    21.  
      22. 

    22.     <span class="keyword">if</span> (<span class="predefined">$GLOBALS</span>[<span class="string"><span class="delimiter">'</span><span class="content">spip_lang</span><span class="delimiter">'</span></span>] == <span class="string"><span class="delimiter">'</span><span class="content">ar</span><span class="delimiter">'</span></span>) {
      23. 

    23.         <span class="local-variable">$fem</span> = <span class="predefined">substr</span>(_T(<span class="local-variable">$chaine_un</span>), -<span class="integer">2</span>);
      24. 

    24.         <span class="keyword">switch</span> (<span class="predefined-constant">true</span>) {
      25. 

    25.             <span class="keyword">case</span> (<span class="local-variable">$nb</span> == <span class="integer">1</span>):
      26. 

    26.                 <span class="keyword">if</span> (<span class="local-variable">$fem</span> == <span class="string"><span class="delimiter">'</span><span class="content">ة</span><span class="delimiter">'</span></span>) {
      27. 

    27.                     <span class="local-variable">$un</span> = _T(<span class="local-variable">$chaine_un</span>) . <span class="string"><span class="delimiter">'</span><span class="content"> واحدة</span><span class="delimiter">'</span></span>;
      28. 

    28.                 } <span class="keyword">else</span> {
      29. 

    29.                     <span class="local-variable">$un</span> = _T(<span class="local-variable">$chaine_un</span>) . <span class="string"><span class="delimiter">'</span><span class="content"> واحد</span><span class="delimiter">'</span></span>;
      30. 

    30.                 }
      31. 

    31.                 <span class="keyword">return</span> <span class="local-variable">$un</span>;
      32. 

    32.                 <span class="keyword">break</span>;
      33. 

    33.             <span class="keyword">case</span> (<span class="local-variable">$nb</span> == <span class="integer">2</span>):
      34. 

    34.                 <span class="keyword">if</span> (<span class="local-variable">$fem</span> == <span class="string"><span class="delimiter">'</span><span class="content">ة</span><span class="delimiter">'</span></span>) {
      35. 

    35.                     <span class="local-variable">$deux</span> = <span class="predefined">rtrim</span>(_T(<span class="local-variable">$chaine_un</span>), <span class="local-variable">$fem</span>) . <span class="string"><span class="delimiter">'</span><span class="content">تان</span><span class="delimiter">'</span></span>;
      36. 

    36.                 } <span class="keyword">else</span> {
      37. 

    37.                     <span class="local-variable">$deux</span> = _T(<span class="local-variable">$chaine_un</span>) . <span class="string"><span class="delimiter">'</span><span class="content">ان</span><span class="delimiter">'</span></span>;
      38. 

    38.                 }
      39. 

    39.                 <span class="keyword">return</span> <span class="local-variable">$deux</span>;
      40. 

    40.                 <span class="keyword">break</span>;
      41. 

    41.             <span class="keyword">case</span> (<span class="local-variable">$nb</span> ><span class="integer">2</span> &#38;&#38; <span class="local-variable">$nb</span> &lt; <span class="integer">11</span>):
      42. 

    42.                 <span class="keyword">return</span> _T(<span class="local-variable">$chaine_plusieurs</span>, <span class="local-variable">$vars</span>);
      43. 

    43.                 <span class="keyword">break</span>;
      44. 

    44.             <span class="keyword">default</span>:
      45. 

    45.                 <span class="local-variable">$chaine_un</span> = <span class="local-variable">$nb</span> . <span class="string"><span class="delimiter">'</span><span class="content"> </span><span class="delimiter">'</span></span> . <span class="local-variable">$chaine_un</span>;
      46. 

    46.                 <span class="keyword">return</span> _T(<span class="local-variable">$chaine_un</span>, <span class="local-variable">$vars</span>);
      47. 

    47.         }
      48. 

    48.     } <span class="keyword">else</span> {
      49. 

    49.         <span class="keyword">if</span> (<span class="local-variable">$nb</span> > <span class="integer">1</span>) {
      50. 

    50.             <span class="keyword">return</span> _T(<span class="local-variable">$chaine_plusieurs</span>, <span class="local-variable">$vars</span>);
      51. 

    51.         } <span class="keyword">else</span> {
      52. 

    52.             <span class="keyword">return</span> _T(<span class="local-variable">$chaine_un</span>, <span class="local-variable">$vars</span>);
      53. 

    53.         }
      54. 

    54.     }
      55. 

    55. }
      56. 

    56. </span>
      57. 

    Télécharger

  • Faire un plugin de signalement

    24 septembre 2012

    Faire un plugin de signalement (qui sera utile à la fois pour MediaSPIP et géodiversité)

    Fonctionnement du plugin :

    Un bouton sur une page d’objet X ou Y "signaler ce contenu".

    Au click sur ce bouton, affichage d’un formulaire (configurable dans la partie privé du site) avec :

    • un sélecteur de motifs de signalement ;
    • un textarea permettant de laisser un message personnalisé ;
    • un bouton valider

    Lors d’un signalement :

    • notification aux admins qu’un signalement a été fait ;
    • notification à l’auteur de l’objet signalé pour le prévenir du signalement également ;
    • au bout d’un certain nombre de signalements sur le même contenu (5 est la valeur par défaut), le contenu est dépublié automatiquement, seul un administrateur peut le soumettre à nouveau ;

    Éléments configurables

    • les motifs de signalement qui peuvent ne pas être utilisé du tout ;
    • le motif de signalement par défaut ;
    • le textarea libre mais à ce moment là le motif est obligatoire ;
    • le statut minimum des personnes pouvant signaler un contenu ;

    Les statuts des signalements

    Les signalements ont trois statuts possibles :

    • publie (validé) ;
    • poubelle (supprimé) ;
    • refuse (invalidé) ;

    Lorsqu’un utilisateur signale un contenu, le statut est directement publie. Le signalement est considéré comme valide, l’utilisateur ne peut signale à nouveau ce contenu.

    Lorsque ce même utilisateur et uniquement lui, retire son signalement, son statut est alors poubelle, le signalement est invalidé et l’utilisateur peut signaler à nouveau le même contenu.

    Lorsqu’un administrateur modère un signalement, son statut est alors refuse, l’utilisateur l’ayant soumis le voit toujours en tant que soumis (et ne peut donc soumettre un nouveau signalement), par contre, il ne rentre plus dans le compte des signalements positifs.

    La modération des signalements par les admins

    La modération des signalements se passe dans l’espace privé.

    L’interface est sur le même modèle que celle des forums.

    A faire

    • création du plugin lui-même ;
    • insertion de sa conf et de sa modération dans mediaspip_config ;
    • insertion de son formulaire dans mediaspip_core ;

  • Duplicate a signal with FFmpeg library [on hold]

    22 septembre 2016, par Meugiwara

    I’m using the FFmpeg library to develop a program in C/C++. At this time, my aim is to duplicate the signal when I open an audio file. My scheme is the next : read an audio file, transform the stereo signal in mono signal and duplicate this mono signal to get two mono signal exactly the same.

    I watched in the Doxygen documentation on the official website, but I don’t find something interesting. Do someone know a good way to do this ?

    Here’s what I have so far :

    #include 
    
#include 
    
#include 
    

    
#define __STDC_CONSTANT_MACROS
    

    
#ifdef _WIN32
    

    
extern "C" /* Windows */
    
{
    
    #include "libswresample/swresample.h"
    
    #include "libavformat/avformat.h"
    
    #include "libavcodec/avcodec.h"
    
    #include "SDL2/SDL.h"
    
};
    

    
#else
    

    
#ifdef __cplusplus
    

    
extern "C" /* Linux */
    
{
    
    #endif /* __cplusplus */
    
    #include <libswresample></libswresample>swresample.h>
    
    #include <libavformat></libavformat>avformat.h>
    
    #include <libavcodec></libavcodec>avcodec.h>
    
    #include <sdl2></sdl2>SDL.H>
    
    #ifdef __cplusplus
    
};
    

    
#endif /* __cplusplus */
    

    
#endif /* _WIN32 */
    

    
#define MAX_AUDIO_FRAME_SIZE 192000 /* 1 second of 48 kHz 32 bits audio*/
    
#define OUTPUT_PCM 1 /* Output PCM */
    
#define USE_SDL 1 /* Use SDL */
    

    
/* Les incrémentations */
    
static Uint32 audio_len;
    
static Uint8 *audio_chunk;
    
static Uint8 *audio_pos;
    

    
void    fill_audio(void *udata, Uint8 *stream, int len)
    
{
    
    SDL_memset(stream, 0, len); /* SDL 2.0 */
    
    if (audio_len == 0)
    
        return;
    
    len = (len > audio_len ? audio_len : len);
    
    SDL_MixAudio(stream, audio_pos, len, SDL_MIX_MAXVOLUME);
    
    audio_pos = audio_pos + len;
    
    audio_len = audio_len - len;
    
}
    

    
int     reading_sound(char *str)
    
{
    
    SDL_AudioSpec       wanted_spec;
    
    AVFormatContext     *pFormatCtx;
    
    AVCodecContext      *pCodecCtx;
    
    AVSampleFormat      out_sample_fmt;
    
    AVPacket            *packet;
    
    AVFrame             *pFrame;
    
    AVCodec             *pCodec;
    
    uint64_t            out_channel_layout;
    
    uint8_t             *out_buffer;
    
    int64_t             in_channel_layout;
    
    struct SwrContext   *au_convert_ctx;
    
    int                 out_sample_rate;
    
    int                 out_buffer_size;
    
    int                 out_nb_samples;
    
    int                 out_channels;
    
    int                 audioStream;
    
    int                 got_picture;
    
    int                 index = 0;
    
    int                 ret;
    
    int                 i;
    
    FILE                *pFile = NULL;
    
    /*
    
    //char              *sound = "WavinFlag.aac";
    
    */
    

    
    av_register_all();
    
    avformat_network_init();
    
    pFormatCtx = avformat_alloc_context();
    
    if (avformat_open_input(&amp;pFormatCtx, str, NULL, NULL) != 0) /* Ouverture du fichier */
    
    {
    
        fprintf(stderr, "%s\n", "Couldn't open input stream");
    
        return (-1);
    
    }
    
    if (avformat_find_stream_info(pFormatCtx, NULL) &lt; 0) /* Récupérer les informations */
    
    {
    
        fprintf(stderr, "Couldn't find stream information\n");
    
        return (-1);
    
    }
    
    av_dump_format(pFormatCtx, 0, str, false); /* Envoyer les informations utiles sur la sortie d'erreur */
    
    audioStream = -1;
    
    for (i = 0; i &lt; pFormatCtx->nb_streams; i++) /* Trouver le début du son */
    
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
    
        {
    
            audioStream = i;
    
            break;
    
        }
    
    if (audioStream == -1)
    
    {
    
        fprintf(stderr, "%s\n", "Didn't find an audio stream");
    
        return (-1);
    
    }
    
    pCodecCtx = pFormatCtx->streams[audioStream]->codec;
    
    pCodec = avcodec_find_decoder(pCodecCtx->codec_id); /* Trouver le décodeur du fichier (.aac, .mp3, ...) */
    
    if (pCodec == NULL)
    
    {
    
        fprintf(stderr, "%s\n", "Codec not found");
    
        return (-1);
    
    }
    
    if (avcodec_open2(pCodecCtx, pCodec, NULL) &lt; 0) /* Ouvrir le décodeur du fichier */
    
    {
    
        fprintf(stderr, "%s\n", "Couldn't open codec");
    
        return (-1);
    
    }
    

    
    #if OUTPUT_PCM
    

    
        pFile = fopen("output.pcm", "wb"); /* Créer et écrire tout ce qui se passe dans ce fichier */
    

    
    #endif /* OUTPUT_PCM */
    

    
    packet = (AVPacket *)av_malloc(sizeof(AVPacket)); /* Allouer taille */
    
    av_init_packet(packet);
    
    out_channel_layout = AV_CH_LAYOUT_MONO; /* Canaux de sortie */
    
    out_nb_samples = pCodecCtx->frame_size; /* L'échantillonnage - Le nombre de samples*/
    
    out_sample_fmt = AV_SAMPLE_FMT_S16; /* Format */
    
    out_sample_rate = 44100; /* Fréquence */
    
    out_channels = av_get_channel_layout_nb_channels(out_channel_layout); /* Récupérer le nombre de canaux */
    
    /*
    
    // printf("%d\n", out_channels);
    
    // system("PAUSE");
    
    */
    
    out_buffer_size = av_samples_get_buffer_size(NULL, out_channels, out_nb_samples, out_sample_fmt, 1); /* Taille du buffer */
    
    out_buffer = (uint8_t *)av_malloc(MAX_AUDIO_FRAME_SIZE * 2); /* Allouer taille */
    
    pFrame = av_frame_alloc(); /* Allouer taille */
    

    
    #if USE_SDL
    

    
        if (SDL_Init(SDL_INIT_VIDEO |SDL_INIT_AUDIO | SDL_INIT_TIMER)) /* Initialiser SDL */
    
        {
    
            fprintf(stderr, "%s - %s\n", "Couldn't initialize SDL", SDL_GetError());
    
            return (-1);
    
        }
    
        /*
    
        // Attribution des valeurs avec les variables au-dessus
    
        */
    
        wanted_spec.freq = out_sample_rate;
    
        wanted_spec.format = AUDIO_S16SYS;
    
        wanted_spec.channels = out_channels;
    
        wanted_spec.silence = 0;
    
        wanted_spec.samples = out_nb_samples;
    
        wanted_spec.callback = fill_audio;
    
        wanted_spec.userdata = pCodecCtx;
    
        if (SDL_OpenAudio(&amp;wanted_spec, NULL) &lt; 0)
    
        {
    
            fprintf(stderr, "%s\n", "Can't open audio");
    
            return (-1);
    
        }
    

    
    #endif /* USE_SDL */
    

    
    in_channel_layout = av_get_default_channel_layout(pCodecCtx->channels);
    
    au_convert_ctx = swr_alloc();
    
    au_convert_ctx = swr_alloc_set_opts(au_convert_ctx, out_channel_layout, out_sample_fmt, out_sample_rate,
    
    in_channel_layout, pCodecCtx->sample_fmt, pCodecCtx->sample_rate, 0, NULL);
    
    swr_init(au_convert_ctx);
    
    while (av_read_frame(pFormatCtx, packet) >= 0) /* Lecture du fichier */
    
    {
    
        if (packet->stream_index == audioStream)
    
        {
    
            ret = avcodec_decode_audio4(pCodecCtx, pFrame, &amp;got_picture, packet); /* Décoder les packets */
    
            if (ret &lt; 0)
    
            {
    
                fprintf(stderr, "%s\n", "Error in decoding audio frame");
    
                return (-1);
    
            }
    
            if (got_picture > 0)
    
            {
    
                swr_convert(au_convert_ctx, &amp;out_buffer, MAX_AUDIO_FRAME_SIZE, (const uint8_t **)pFrame->data, pFrame->nb_samples);
    

    
    #if 1
    

    
                printf("Index : %5d\t Points : %lld\t Packet size : %d\n", index, packet->pts, packet->size); /* Affichage des informations sur la console */
    

    
    #endif /* 1 */
    

    
    #if OUTPUT_PCM
    

    
                fwrite(out_buffer, 1, out_buffer_size, pFile); /* Faire l'écriture dans le fichier */
    

    
    #endif /* OUTPUT_PCM */
    

    
                index = index + 1;
    
            }
    

    
    #if USE_SDL
    

    
            while (audio_len > 0)
    
                SDL_Delay(1);
    
            audio_chunk = (Uint8 *)out_buffer;
    
            audio_len = out_buffer_size;
    
            audio_pos = audio_chunk;
    
            SDL_PauseAudio(0);
    

    
    #endif /* USE_SDL */
    

    
        }
    
        av_free_packet(packet); /* Libérer les packets */
    
    }
    
    swr_free(&amp;au_convert_ctx); /* Libérer la taille de conversion */
    

    
    #if USE_SDL
    

    
    SDL_CloseAudio(); /* Arrêter le son dans SDL */
    
    SDL_Quit(); /* Quitter SDL */
    

    
    #endif /* USE_SDL */
    

    
    #if OUTPUT_PCM
    

    
    fclose(pFile); /* Fermer le fichier d'écriture */
    

    
    #endif /* OUTPUT_PCM */
    

    
    av_free(out_buffer);
    
    avcodec_close(pCodecCtx); /* Fermer le décodeur */
    
    avformat_close_input(&amp;pFormatCtx); /* Fermer le fichier lu */
    
    return (0);
    
}
    

    
int     main(int argc, char **argv)
    
{
    

    
    if (argc != 2)
    
    {
    
        fprintf(stderr, "%s\n", "Usage : ./BASELFI [File]");
    
        system("PAUSE");
    
        return (-1);
    
    }
    
    else
    
    {
    
        reading_sound(argv[1]);
    
        return (0);
    
    }
    
    return (0);
    
}

Navigation