Recherche avancée

Médias (0)

Mot : - Tags -/gis

Aucun média correspondant à vos critères n’est disponible sur le site.

Autres articles (87)

  • Organiser par catégorie

    17 mai 2013, par

    Dans MédiaSPIP, une rubrique a 2 noms : catégorie et rubrique.
    Les différents documents stockés dans MédiaSPIP peuvent être rangés dans différentes catégories. On peut créer une catégorie en cliquant sur "publier une catégorie" dans le menu publier en haut à droite ( après authentification ). Une catégorie peut être rangée dans une autre catégorie aussi ce qui fait qu’on peut construire une arborescence de catégories.
    Lors de la publication prochaine d’un document, la nouvelle catégorie créée sera proposée (...)

  • Récupération d’informations sur le site maître à l’installation d’une instance

    26 novembre 2010, par

    Utilité
    Sur le site principal, une instance de mutualisation est définie par plusieurs choses : Les données dans la table spip_mutus ; Son logo ; Son auteur principal (id_admin dans la table spip_mutus correspondant à un id_auteur de la table spip_auteurs)qui sera le seul à pouvoir créer définitivement l’instance de mutualisation ;
    Il peut donc être tout à fait judicieux de vouloir récupérer certaines de ces informations afin de compléter l’installation d’une instance pour, par exemple : récupérer le (...)

  • Publier sur MédiaSpip

    13 juin 2013

    Puis-je poster des contenus à partir d’une tablette Ipad ?
    Oui, si votre Médiaspip installé est à la version 0.2 ou supérieure. Contacter au besoin l’administrateur de votre MédiaSpip pour le savoir

Sur d’autres sites (9047)

  • 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