Recherche avancée

Médias (1)

Mot : - Tags -/publier

Autres articles (70)

  • Amélioration de la version de base

    13 septembre 2013

    Jolie sélection multiple
    Le plugin Chosen permet d’améliorer l’ergonomie des champs de sélection multiple. Voir les deux images suivantes pour comparer.
    Il suffit pour cela d’activer le plugin Chosen (Configuration générale du site > Gestion des plugins), puis de configurer le plugin (Les squelettes > Chosen) en activant l’utilisation de Chosen dans le site public et en spécifiant les éléments de formulaires à améliorer, par exemple select[multiple] pour les listes à sélection multiple (...)

  • Emballe médias : à quoi cela sert ?

    4 février 2011, par

    Ce plugin vise à gérer des sites de mise en ligne de documents de tous types.
    Il crée des "médias", à savoir : un "média" est un article au sens SPIP créé automatiquement lors du téléversement d’un document qu’il soit audio, vidéo, image ou textuel ; un seul document ne peut être lié à un article dit "média" ;

  • Gestion de la ferme

    2 mars 2010, par

    La ferme est gérée dans son ensemble par des "super admins".
    Certains réglages peuvent être fais afin de réguler les besoins des différents canaux.
    Dans un premier temps il utilise le plugin "Gestion de mutualisation"

Sur d’autres sites (8184)

  • WASAPI resampling

    30 juin 2013, par magingax

    I am trying to play 24bit/48000 Hz audio on PC. my PC seems not support 32bit sample (event GetMixFormat return 32bit/44100Hz device)
    So I'm trying to convert 24bit/4800Hz audio into 16bit/44100Hz
    but It sound like noise.
    sample audio file 'titan.wav' is 24bit/48000Hz s32 format
    below is sample code

    #define WINVER 0x0600
    
#define _WIN32_WINNT 0x0600
    

    
#include 
    
#include <iostream>
    
#include "Mmdeviceapi.h"
    
#include "Audioclient.h"
    
#include "Endpointvolume.h"
    
using namespace std;
    

    
extern "C"
    
{
    
#include <libavformat></libavformat>avformat.h>
    
#include <libavcodec></libavcodec>avcodec.h>
    
#include <libswscale></libswscale>swscale.h>
    
#include <libavutil></libavutil>opt.h>
    
#include <libavutil></libavutil>channel_layout.h>
    
#include <libavutil></libavutil>samplefmt.h>
    
#include <libswresample></libswresample>swresample.h>
    
}
    

    
#define MAX_AUDIO_FRAME_SIZE    192000
    
#define REFTIMES_PER_SEC      10000000  // 1 sec   100ns
    
#define REFTIMES_PERMILLISEC     10000
    
const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
    
const IID   IID_IMMDeviceEnumerator  = __uuidof(IMMDeviceEnumerator);
    
const IID   IID_IAudioClient         = __uuidof(IAudioClient);
    
const IID   IID_IAudioRenderClient   = __uuidof(IAudioRenderClient);
    

    

    
int alloc_samples_array_and_data(uint8_t*** data, int *linesize, int nb_channels,int nb_samples, enum AVSampleFormat sample_fmt, int align)
    
{
    
    int nb_planes = av_sample_fmt_is_planar(sample_fmt) ? nb_channels : 1;
    
    *data = (uint8_t**)av_malloc(sizeof(*data) * nb_planes);
    
    return av_samples_alloc(*data, linesize, nb_channels,nb_samples, sample_fmt, align);
    
}
    

    

    

    
int main()
    
{
    
    HRESULT hr;
    
    REFERENCE_TIME       buf_duration_request = REFTIMES_PER_SEC;
    
    REFERENCE_TIME       buf_duration_actual;
    
    IMMDeviceEnumerator  *pEnumerator      = NULL;
    
    IMMDevice            *pDevice          = NULL;
    
    IAudioClient         *pAudioClient     = NULL;
    
    IAudioRenderClient   *pRenderClient    = NULL;
    
    IAudioEndpointVolume *endpoint_vol     = NULL;
    
    WAVEFORMATEX         *fmt              = NULL;
    
    UINT32               frame_total       = 0;   // total frames in buffer
    
    UINT32               frame_avail       = 0;   // available frame number in buffer
    
    UINT32               frame_fill        = 0;   // filled frames
    
    BYTE                 *pData            = NULL;
    
    FILE                 *file_audio       = NULL;
    
    BYTE                 *buf              = NULL;
    
    DWORD                flags             = 0;
    

    

    
    CoInitializeEx(NULL,COINIT_MULTITHREADED);
    
    CoCreateInstance (CLSID_MMDeviceEnumerator,NULL,CLSCTX_ALL,IID_IMMDeviceEnumerator, (void**)&amp;pEnumerator);
    
    pEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &amp;pDevice);
    
    pDevice->Activate(IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&amp;pAudioClient);
    
    pDevice->Activate(__uuidof(IAudioEndpointVolume),CLSCTX_ALL,NULL,(void**)&amp;endpoint_vol);
    
    pAudioClient->GetMixFormat((WAVEFORMATEX**)&amp;fmt);
    

    

    
    fmt->wFormatTag      = WAVE_FORMAT_PCM;
    
    fmt->nChannels       = 2 ; 
    
    fmt->nSamplesPerSec  = 44100;
    
    fmt->wBitsPerSample  = 16;
    
    fmt->nBlockAlign     = fmt->nChannels * (fmt->wBitsPerSample/8);
    
    fmt->nAvgBytesPerSec = fmt->nSamplesPerSec * fmt->nBlockAlign;  
    
    fmt->cbSize          = 0;
    

    
    WAVEFORMATEX* closest_format = NULL;
    
    hr = pAudioClient->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED, fmt ,&amp;closest_format);
    
    hr = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED, NULL ,buf_duration_request,0, fmt ,NULL);
    
    hr = pAudioClient->GetBufferSize(&amp;frame_total);
    
    hr = pAudioClient->GetService(IID_IAudioRenderClient,(void**)&amp;pRenderClient);
    

    
    int file_size = 0;  
    
    int buf_size  = 44100 * 4;  
    
    int read_ret  = 0;
    
    int read_acc  = 0;
    

    
    fopen_s(&amp;file_audio,"E:\\MOVIE\\titan.wav","rb"); 
    
    fseek (file_audio , 0 , SEEK_END);
    
    file_size = ftell (file_audio);
    
    rewind (file_audio);
    
    buf  = (BYTE*) malloc(buf_size);
    

    
    pRenderClient->GetBuffer(frame_total,&amp;pData);
    
    read_ret  = fread(buf,1,buf_size,file_audio);
    
    read_acc += read_ret;
    
    memcpy(pData,buf,buf_size); 
    
    pRenderClient->ReleaseBuffer(frame_total,flags);
    

    
    buf_duration_actual = (double) REFTIMES_PER_SEC * frame_total / fmt->nSamplesPerSec;
    
    pAudioClient->Start();
    

    

    
    //-- resample
    
    uint8_t** src_data;
    
    uint8_t** dst_data;
    
    int       src_bufsize        = 0;
    
    int       dst_bufsize        = 0;
    
    int       src_linesize       = 0;
    
    int       dst_linesize       = 0;
    
    int       src_nb_channels    = 0;
    
    int       dst_nb_channels    = 0;
    
    int       src_nb_samples     = 1024;
    
    int       dst_nb_samples     = 0;
    
    int       max_dst_nb_samples = 0;
    
    int       ret = 0;
    
    SwrContext* swr_ctx = NULL;
    
    swr_ctx = swr_alloc();
    
    av_opt_set_int        (swr_ctx,"in_channel_layout" , AV_CH_LAYOUT_MONO,   0);
    
    av_opt_set_int        (swr_ctx,"in_sample_rate"    , 48000,0);
    
    av_opt_set_sample_fmt (swr_ctx,"in_sample_fmt"     , AV_SAMPLE_FMT_S32,   0);
    
    av_opt_set_int        (swr_ctx,"out_channel_layout", AV_CH_LAYOUT_STEREO, 0);
    
    av_opt_set_int        (swr_ctx,"out_sample_rate"   , 44100,0);
    
    av_opt_set_sample_fmt (swr_ctx,"out_sample_fmt"    , AV_SAMPLE_FMT_S16, 0);
    
    ret = swr_init(swr_ctx);
    

    
    src_nb_channels    = av_get_channel_layout_nb_channels(AV_CH_LAYOUT_MONO);
    
    src_nb_samples     = src_nb_channels * 48000;
    
    dst_nb_samples     = av_rescale_rnd(src_nb_samples, 44100,48000,AV_ROUND_UP);
    
    max_dst_nb_samples = dst_nb_samples;
    
    alloc_samples_array_and_data(&amp;src_data,&amp;src_linesize,src_nb_channels,src_nb_samples, AV_SAMPLE_FMT_S32,0);  
    

    
    dst_nb_channels    = av_get_channel_layout_nb_channels(AV_CH_LAYOUT_STEREO);
    
    alloc_samples_array_and_data(&amp;dst_data,&amp;dst_linesize,dst_nb_channels,dst_nb_samples, AV_SAMPLE_FMT_S16,0);
    
    //-- end resample
    

    

    
    while (read_acc &lt; file_size) 
    
    {
    
    Sleep(buf_duration_actual/REFTIMES_PERMILLISEC/2);          
    
        pAudioClient->GetCurrentPadding(&amp;frame_fill);
    
        frame_avail    = frame_total - frame_fill;
    
        dst_nb_samples = frame_avail;       
    
        src_nb_samples = av_rescale_rnd(dst_nb_samples,48000,44100,AV_ROUND_UP);
    
        src_bufsize    = av_samples_get_buffer_size(&amp;src_linesize,src_nb_channels,src_nb_samples,AV_SAMPLE_FMT_S32,1);
    

    
        cout&lt;&lt;"FILLED:"&lt;GetBuffer(frame_avail, &amp;pData );    
    
        read_ret    = fread(src_data[0],1,src_bufsize,file_audio);
    
        read_acc   += read_ret;
    
        ret         = swr_convert(swr_ctx,dst_data,dst_nb_samples,(const uint8_t**)src_data,src_nb_samples);
    
        dst_bufsize = av_samples_get_buffer_size(&amp;dst_linesize,dst_nb_channels,ret,AV_SAMPLE_FMT_S16,1);
    
        memcpy(pData, dst_data[0], dst_bufsize);        
    
        hr = pRenderClient->ReleaseBuffer(frame_avail,flags);                   
    

    
    }
    

    

    
    pAudioClient->Stop();
    
    CoTaskMemFree(fmt);
    
    pEnumerator->Release();
    
    pDevice->Release();
    
    pAudioClient->Release();
    
    pRenderClient->Release();
    
    CoUninitialize();
    

    
    return 0;
    
}
    
</iostream>

  • Revision 28933 : on bouge

    31 mai 2009, par ben.spip@… — Log

    on bouge

  • Revision 30148 : On pousse encore un peu plus loin la conf (toujours pas utilisable dans ...

    24 juillet 2009, par kent1@… — Log

    On pousse encore un peu plus loin la conf (toujours pas utilisable dans l’état)

Navigation