Recherche avancée
Médias (1)
-
La conservation du net art au musée. Les stratégies à l’œuvre
26 mai 2011
Mis à jour : Juillet 2013
Langue : français
Type : Texte
Autres articles (73)
-
Amélioration de la version de base
13 septembre 2013Jolie 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 (...) -
Le profil des utilisateurs
12 avril 2011, parChaque utilisateur dispose d’une page de profil lui permettant de modifier ses informations personnelle. Dans le menu de haut de page par défaut, un élément de menu est automatiquement créé à l’initialisation de MediaSPIP, visible uniquement si le visiteur est identifié sur le site.
L’utilisateur a accès à la modification de profil depuis sa page auteur, un lien dans la navigation "Modifier votre profil" est (...) -
Configurer la prise en compte des langues
15 novembre 2010, parAccéder à la configuration et ajouter des langues prises en compte
Afin de configurer la prise en compte de nouvelles langues, il est nécessaire de se rendre dans la partie "Administrer" du site.
De là, dans le menu de navigation, vous pouvez accéder à une partie "Gestion des langues" permettant d’activer la prise en compte de nouvelles langues.
Chaque nouvelle langue ajoutée reste désactivable tant qu’aucun objet n’est créé dans cette langue. Dans ce cas, elle devient grisée dans la configuration et (...)
Sur d’autres sites (7771)
-
Stuttering rendering using ffmpeg and sdl2
22 décembre 2020, par Wiesen_WalleWith the following Code I get a stuttering rendering of the movie file. Interesstingly, when dumping information with ffmpeg it says it has 25 fps and a duration of 00:01:32.90 ; however when counting the frames and time it runs by myself it gives a time of about 252 seconds, I guess the code receiving the frames and sending the package (int cap(vid v)) draws the same frame multiple of times. But I cannot see what's wrong ?


//PKG_CONFIG_PATH=/usr/local/lib/pkgconfig/:/usr/lib64/pkgconfig/ --> add path to PKF_Config search path
//export PKG_CONFIG_PATH --> export PKG_Config search path to become visible for gcc
//gcc ffmpeg_capture_fl.c -Wall -pedantic -fPIC `pkg-config --cflags --libs libavdevice libavformat libavcodec libavutil libavdevice libavfilter libswscale libswresample sdl2`


#include <libavdevice></libavdevice>avdevice.h>
#include <libavutil></libavutil>opt.h>
#include <libavformat></libavformat>avformat.h>
#include <libavcodec></libavcodec>avcodec.h>
#include <libswscale></libswscale>swscale.h>
#include <libavutil></libavutil>imgutils.h>
#include 
#include 
#include <libavutil></libavutil>rational.h>
#include <sys></sys>time.h>
#include 


typedef struct vid{
AVFormatContext *inc;
AVInputFormat *iformat;
AVCodecContext *pCodecCtx;
AVCodec *pCodec;
AVFrame *pFrame;
int videoStream;} vid;

typedef struct sws{
struct SwsContext *ctx;
uint8_t **buffer;
int *linesize;
} sws;


vid cap_init_fl(char *fl);
int cap(vid v);
void cap_close(vid v);

sws init_swsctx(int width, int height, enum AVPixelFormat pix_fmt, int new_width, int new_height, enum AVPixelFormat new_pxf);
void conv_pxlformat(sws scale, uint8_t **src_data, int *src_linesize, int height);
void free_sws(sws inp);

#include <sdl2></sdl2>SDL.h>

typedef struct sdl_window{
 SDL_Window *window;
 SDL_Renderer *renderer;
 SDL_Texture *texture;
 SDL_Event *event;
 int width;
 int height;
 int pitch;
 uint32_t sdl_pxl_frmt;
 }sdl_window;

sdl_window init_windowBGR24_ffmpg(int width, int height);
int render_on_texture_update(sdl_window wow, uint8_t *data);
void close_window(sdl_window wow);


vid cap_init_fl(char *fl){
 vid v = {NULL, NULL, NULL, NULL, NULL, -1};
 int i;
 
 av_register_all();
 avdevice_register_all();

 if( 0 > avformat_open_input( &(v.inc), fl , v.iformat, NULL)) {
 printf("Input device could not been opened\n");
 cap_close(v);
 exit(1);
 }

 if(avformat_find_stream_info(v.inc, NULL)<0){
 printf("Stream information could not been found.\n");
 cap_close(v);
 exit(2);
 }

 // Dump information about file onto standard error
 av_dump_format(v.inc, 0, fl, 0);

 // Find the first video stream
 v.videoStream=-1;
 for(i=0; inb_streams; i++){
 if(v.inc->streams[i]->codecpar->codec_type==AVMEDIA_TYPE_VIDEO) {
 v.videoStream=i;
 break;
 }}

 if(v.videoStream==-1){
 printf("Could not find video stream.\n");
 cap_close(v);
 exit(3);
 }

 // Find the decoder for the video stream
 v.pCodec=avcodec_find_decoder(v.inc->streams[v.videoStream]->codecpar->codec_id);
 if(v.pCodec==NULL) {
 printf("Unsupported codec!\n");
 cap_close(v);
 exit(4);
 // Codec not found
 }

 

 // Get a pointer to the codec context for the video stream
 
 if((v.pCodecCtx=avcodec_alloc_context3(NULL)) == NULL){
 printf("Could not allocate codec context\n");
 cap_close(v);
 exit(10);}

 avcodec_parameters_to_context (v.pCodecCtx, v.inc->streams[v.videoStream]->codecpar); 
 
 // Open codec
 if(avcodec_open2(v.pCodecCtx, v.pCodec, NULL)<0){
 printf("Could not open codec");
 cap_close(v);
 exit(5);
 }
 
 
 // Allocate video frame
 v.pFrame=av_frame_alloc();
 if(v.pFrame==NULL){
 printf("Could not allocate AVframe");
 cap_close(v);
 exit(6);}

 
 return v;
}



int cap(vid v){
 int errorCodeRF, errorCodeSP, errorCodeRecFR;
 AVPacket pkt;
 
 if((errorCodeRF = av_read_frame(v.inc, &pkt)) >= 0){
 
 if (pkt.stream_index == v.videoStream) {
 
 errorCodeSP = avcodec_send_packet(v.pCodecCtx, &pkt);
 
 if (errorCodeSP >= 0 || errorCodeSP == AVERROR(EAGAIN)){
 
 errorCodeRecFR = avcodec_receive_frame(v.pCodecCtx, v.pFrame);
 
 if (errorCodeRecFR < 0){ 
 av_packet_unref(&pkt);
 return errorCodeRecFR;
 }
 else{
 av_packet_unref(&pkt);
 return 0;
 }
 
 }
 else{
 av_packet_unref(&pkt);
 return errorCodeSP;}
 
 }}
 
 else{
 return errorCodeRF;}
 return 1;
 }
 
 

void cap_close(vid v){
 if(v.pFrame != NULL) av_free(v.pFrame);
 avcodec_close(v.pCodecCtx);
 avformat_close_input(&(v.inc));
 if(v.inc != NULL) avformat_free_context(v.inc);
 
 v.inc = NULL;
 v.iformat = NULL;
 v.pCodecCtx = NULL;
 v.pCodec = NULL;
 v.pFrame = NULL;
 v.videoStream=-1;}



sws init_swsctx(int width, int height, enum AVPixelFormat pix_fmt, int new_width, int new_height, enum AVPixelFormat new_pxf){

int nwidth, nheight;
sws scale;

scale.buffer = (uint8_t **) malloc(4 * sizeof(uint8_t *));
scale.linesize = (int *) malloc(4 * sizeof(int));


nwidth = (new_width <= 0) ? width : new_width;
nheight = (new_height <= 0) ? height : new_height;

av_image_alloc(scale.buffer, scale.linesize, nwidth, nheight, new_pxf, 1);
scale.ctx = sws_getContext(width, height, pix_fmt, nwidth, nheight, new_pxf, SWS_BILINEAR, NULL, NULL, NULL);

if(scale.ctx==NULL){
 printf("Could not allocate SWS-Context\n");
 av_freep(&(scale.buffer)[0]);
 free(scale.buffer);
 free(scale.linesize);
 exit(12);
 }
 
return scale;}


void conv_pxlformat(sws scale, uint8_t **src_data, int *src_linesize, int height){ 
 sws_scale(scale.ctx, (const uint8_t **) src_data, src_linesize, 0, height, scale.buffer, scale.linesize);
 }


void free_sws(sws inp){
 av_freep(&(inp.buffer)[0]);
 free(inp.buffer);
 free(inp.linesize); 
}


sdl_window init_windowBGR24_ffmpg(int width, int height){

 sdl_window wow;
 
 if (SDL_Init(SDL_INIT_VIDEO) < 0) {
 printf("Couldn't initialize SDL in function: create_sdl_window(...)\n");
 exit(7);}
 
 wow.window = SDL_CreateWindow("SDL_CreateTexture",
 SDL_WINDOWPOS_UNDEFINED,
 SDL_WINDOWPOS_UNDEFINED,
 width, height,
 SDL_WINDOW_RESIZABLE);

 wow.renderer = SDL_CreateRenderer(wow.window, -1, SDL_RENDERER_ACCELERATED);
 wow.texture = SDL_CreateTexture(wow.renderer, SDL_PIXELFORMAT_BGR24, SDL_TEXTUREACCESS_STREAMING, width, height);
 wow.width = width;
 wow.height = height;
 wow.pitch = width * 3; //only true for 3 byte / 24bit packed formats like bgr24
 wow.sdl_pxl_frmt = SDL_PIXELFORMAT_BGR24;
 SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear"); 
 SDL_SetHint(SDL_HINT_RENDER_VSYNC, "enable"); 
 SDL_RenderSetLogicalSize(wow.renderer, wow.width, wow.height);
 return wow;
}


int render_on_texture_update(sdl_window wow, uint8_t *data){
 
 if (SDL_UpdateTexture(wow.texture, NULL, data, wow.pitch)< 0){
 printf("SDL_render_on_texture_update_failed: %s\n", SDL_GetError());
 return -1;
 }
 SDL_RenderClear(wow.renderer);
 SDL_RenderCopy(wow.renderer, wow.texture, NULL, NULL);
 SDL_RenderPresent(wow.renderer);

 return 0; 
}


void close_window(sdl_window wow){
 SDL_DestroyRenderer(wow.renderer);
 SDL_Quit();
}




int main(){
 int n, vid_error;
 long int time_per_frame_usec, duration_usec;
 vid v;
 sdl_window wow;
 struct timeval tval_start, tval_start1, tval_end, tval_duration;
 sws scale;
 SDL_Event event;
 
 vid_error = AVERROR(EAGAIN);
 v = cap_init_fl("mw_maze_test.mp4"); 
 
 while(vid_error == AVERROR(EAGAIN)){
 vid_error =cap(v);}
 
 if(vid_error < 0){
 printf("Could not read from Capture\n");
 cap_close(v);
 return 0;
 }

 wow = init_windowBGR24_ffmpg((v.pCodecCtx)->width, (v.pCodecCtx)->height);
 scale = init_swsctx((v.pCodecCtx)->width, (v.pCodecCtx)->height, (v.pCodecCtx)->pix_fmt, 0, 0, AV_PIX_FMT_BGR24);
 
 time_per_frame_usec = ((long int)((v.inc)->streams[v.videoStream]->avg_frame_rate.den) * 1000000 / (long int) ((v.inc)->streams[v.videoStream]->avg_frame_rate.num));
 
 printf("Time per frame: %ld\n", time_per_frame_usec);
 n = 0;
 
 gettimeofday(&tval_start, NULL);
 gettimeofday(&tval_start1, NULL);
 
 while ((vid_error =cap(v)) >= 0) {
 
 if (SDL_PollEvent(&event) != 0) {
 if (event.type == SDL_QUIT)
 break;}
 
 conv_pxlformat(scale, (v.pFrame)->data, (v.pFrame)->linesize, (v.pCodecCtx)->height);
 gettimeofday(&tval_end, NULL);
 timersub(&tval_end, &tval_start, &tval_duration);
 duration_usec = (long int)tval_duration.tv_sec * 1000000 + (long int)tval_duration.tv_usec;
 
 while(duration_usec < time_per_frame_usec) {
 gettimeofday(&tval_end, NULL);
 timersub(&tval_end, &tval_start, &tval_duration);
 duration_usec = (long int)tval_duration.tv_sec * 1000000 + (long int)tval_duration.tv_usec;
 }
 
 gettimeofday(&tval_start, NULL);
 render_on_texture_update(wow, *(scale.buffer)); 
 n++;
 }
 
 gettimeofday(&tval_end, NULL);
 timersub(&tval_end, &tval_start1, &tval_duration);
 duration_usec = (long int)tval_duration.tv_sec * 1000000 + (long int)tval_duration.tv_usec;
 
 printf("Total time and frames; %ld %i\n", duration_usec, n);
 
 if(vid_error == AVERROR(EAGAIN)){
 printf("AVERROR(EAGAIN) occured\n)");
 } 
 
 
 sws_freeContext(scale.ctx);
 free_sws(scale);
 close_window(wow);
 cap_close(v); 
 return 0; 
}



the output is:

Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'mw_maze_test.mp4':
 Metadata:
 major_brand : mp42
 minor_version : 0
 compatible_brands: isommp42
 creation_time : 2014-02-14T21:09:52.000000Z
 Duration: 00:01:32.90, start: 0.000000, bitrate: 347 kb/s
 Stream #0:0(und): Video: h264 (Constrained Baseline) (avc1 / 0x31637661), yuv420p, 384x288 [SAR 1:1 DAR 4:3], 249 kb/s, 25 fps, 25 tbr, 25 tbn, 50 tbc (default)
 Metadata:
 handler_name : VideoHandler
 Stream #0:1(und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 96 kb/s (default)
 Metadata:
 creation_time : 2014-02-14T21:09:53.000000Z
 handler_name : IsoMedia File Produced by Google, 5-11-2011
Time per frame: 40000
Total time and frames; 252881576 6322




-
add username as random position watermark to video using PHP [duplicate]
12 novembre 2020, par mohamed.nabilIam working on video learning courses website


I want to put a dynamic watermark appears in random positions on top of video with username or email of the logedin user.


is it possible to do this example by using ffmpeg or require Ai ?, website is php wordpress site.


This link provide an example of What I mean from vdocipher website
https://www.vdocipher.com/blog/2014/12/add-text-to-videos-with-watermark/


-
Resampling audio using libswresample, leaves small amount of noise after resampling
20 juillet 2020, par MiloI'm trying to resample audio from 44Khz to 48Khz and I'm getting s small light noise after resampling. As if someone is gently ticking the mic. This happens both ways. From 48Khz to 44Khz and vice versa.


I've read that this can happen because swrContext still has some data left and that I shoudl flush the context before resampling next frame. And although this helps a little (less noticeable noise), it's still present.


I've tried using FFmpeg resample filter instead, but the output is just loud incoherent noise. I'm pretty sure that libswresample should not output any noise on resampling which means that I just don't know how to use it well and I'm missing some options.


This is the code for resampler.


int ResampleFrame(VideoState * videoState, AVFrame *decoded_audio_frame, enum AVSampleFormat out_sample_fmt, uint8_t * out_buf)
{
 int in_sample_rate = videoState->audio->ptrAudioCodecCtx_->sample_rate;
 int out_sample_rate = SAMPLE_RATE;

// get an instance of the AudioResamplingState struct, create if NULL
AudioResamplingState* arState = getAudioResampling(videoState->audio->ptrAudioCodecCtx_->channel_layout);

if (!arState->swr_ctx)
{
 printf("swr_alloc error.\n");
 return -1;
}

// get input audio channels
arState->in_channel_layout = (videoState->audio->ptrAudioCodecCtx_->channels ==
 av_get_channel_layout_nb_channels(videoState->audio->ptrAudioCodecCtx_->channel_layout)) ?
 videoState->audio->ptrAudioCodecCtx_->channel_layout :
 av_get_default_channel_layout(videoState->audio->ptrAudioCodecCtx_->channels);


// check input audio channels correctly retrieved
if (arState->in_channel_layout <= 0)
{
 printf("in_channel_layout error.\n");
 return -1;
}


arState->out_channel_layout = AV_CH_LAYOUT_STEREO;

// retrieve number of audio samples (per channel)
arState->in_nb_samples = decoded_audio_frame->nb_samples;
if (arState->in_nb_samples <= 0)
{
 printf("in_nb_samples error.\n");
 return -1;
}

// Set SwrContext parameters for resampling
av_opt_set_int(arState->swr_ctx, "in_channel_layout", arState->in_channel_layout, 0);
av_opt_set_int(arState->swr_ctx, "in_sample_rate", in_sample_rate, 0);
av_opt_set_sample_fmt(arState->swr_ctx, "in_sample_fmt", videoState->audio->ptrAudioCodecCtx_->sample_fmt, 0);


// Set SwrContext parameters for resampling
av_opt_set_int(arState->swr_ctx, "out_channel_layout", arState->out_channel_layout, 0);
av_opt_set_int(arState->swr_ctx, "out_sample_rate", out_sample_rate, 0);
av_opt_set_sample_fmt(arState->swr_ctx, "out_sample_fmt", out_sample_fmt, 0);


// initialize SWR context after user parameters have been set
int ret = swr_init(arState->swr_ctx);
if (ret < 0)
 {
 printf("Failed to initialize the resampling context.\n");
 return -1;
 }


 // retrieve output samples number taking into account the progressive delay
int64_t delay = swr_get_delay(arState->swr_ctx, videoState->audio->ptrAudioCodecCtx_->sample_rate) + arState->in_nb_samples;
arState->out_nb_samples = av_rescale_rnd(delay, out_sample_rate, in_sample_rate, AV_ROUND_UP );

// check output samples number was correctly rescaled
if (arState->out_nb_samples <= 0)
{
 printf("av_rescale_rnd error\n");
 return -1;
}

// get number of output audio channels
arState->out_nb_channels = av_get_channel_layout_nb_channels(arState->out_channel_layout);

// allocate data pointers array for arState->resampled_data and fill data
// pointers and linesize accordingly
// check memory allocation for the resampled data was successful
ret = av_samples_alloc_array_and_samples(&arState->resampled_data, &arState->out_linesize, arState->out_nb_channels, arState->out_nb_samples, out_sample_fmt, 0);
if (ret < 0)
 {
 printf("av_samples_alloc_array_and_samples() error: Could not allocate destination samples.\n");
 return -1;
 }


if (arState->swr_ctx)
 {
 // do the actual audio data resampling
 // check audio conversion was successful
 int ret_num_samples = swr_convert(arState->swr_ctx,arState->resampled_data,arState->out_nb_samples,(const uint8_t**)decoded_audio_frame->data, decoded_audio_frame->nb_samples);
 //int ret_num_samples = swr_convert_frame(arState->swr_ctx,arState->resampled_data,arState->out_nb_samples,(const uint8_t**)decoded_audio_frame->data, decoded_audio_frame->nb_samples);

 if (ret_num_samples < 0)
 {
 printf("swr_convert_error.\n");
 return -1;
 }


 // get the required buffer size for the given audio parameters
 // check audio buffer size
 arState->resampled_data_size = av_samples_get_buffer_size(&arState->out_linesize, arState->out_nb_channels,ret_num_samples,out_sample_fmt,1);

 if (arState->resampled_data_size < 0)
 {
 printf("av_samples_get_buffer_size error.\n");
 return -1;
 }
 } else {
 printf("swr_ctx null error.\n");
 return -1;
 }



// copy the resampled data to the output buffer
memcpy(out_buf, arState->resampled_data[0], arState->resampled_data_size);


// flush the swr context
int delayed = swr_convert(arState->swr_ctx,arState->resampled_data,arState->out_nb_samples,NULL,0);



if (arState->resampled_data)
 {
 av_freep(&arState->resampled_data[0]);
 }

av_freep(&arState->resampled_data);
arState->resampled_data = NULL;

int ret_data_size = arState->resampled_data_size;



return ret_data_size;
}


I also tries using the filter as shown here but my output is just noise.


This is my filter code


int ResampleFrame(AVFrame *frame, uint8_t *out_buf)
{
 /* Push the decoded frame into the filtergraph */
 qint32 ret;
 ret = av_buffersrc_add_frame_flags(buffersrc_ctx1, frame, AV_BUFFERSRC_FLAG_KEEP_REF);
 if (ret < 0) 
 {
 printf("ResampleFrame: Error adding frame to buffer\n");
 // Delete input frame and return null
 av_frame_unref(frame);
 return 0;
 }


 //printf("resampling\n");
 AVFrame *resampled_frame = av_frame_alloc();


 /* Pull filtered frames from the filtergraph */
 ret = av_buffersink_get_frame(buffersink_ctx1, resampled_frame);

 /* Set the timestamp on the resampled frame */
 resampled_frame->best_effort_timestamp = resampled_frame->pts;

 if (ret < 0) 
 {
 av_frame_unref(frame);
 av_frame_unref(resampled_frame);
 return 0;
 }


 int buffer_size = av_samples_get_buffer_size(NULL, 2,resampled_frame->nb_samples,AV_SAMPLE_FMT_S16,1);

 memcpy(out_buf,resampled_frame->data,buffer_size);

 //av_frame_unref(frame);
 av_frame_unref(resampled_frame);
 return buffer_size;
}





QString filter_description1 = "aresample=48000,aformat=sample_fmts=s16:channel_layouts=stereo,asetnsamples=n=1024:p=0";

int InitAudioFilter(AVStream *inputStream) 
{

 char args[512];
 int ret;
 const AVFilter *buffersrc = avfilter_get_by_name("abuffer");
 const AVFilter *buffersink = avfilter_get_by_name("abuffersink");
 AVFilterInOut *outputs = avfilter_inout_alloc();
 AVFilterInOut *inputs = avfilter_inout_alloc();
 filter_graph = avfilter_graph_alloc();


 const enum AVSampleFormat out_sample_fmts[] = {AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE};
 const int64_t out_channel_layouts[] = {AV_CH_LAYOUT_STEREO, -1};
 const int out_sample_rates[] = {48000, -1};

 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%" PRIx64,
 inputStream->codec->time_base.num, inputStream->codec->time_base.den,
 inputStream->codec->sample_rate,
 av_get_sample_fmt_name(inputStream->codec->sample_fmt),
 inputStream->codec->channel_layout);


 ret = avfilter_graph_create_filter(&buffersrc_ctx1, buffersrc, "in", args, NULL, filter_graph);

 if (ret < 0) 
 {
 printf("InitAudioFilter: Unable to create buffersrc\n");
 return -1;
 }

 ret = avfilter_graph_create_filter(&buffersink_ctx1, buffersink, "out", NULL, NULL, filter_graph);

 if (ret < 0) 
 {
 printf("InitAudioFilter: Unable to create buffersink\n");
 return ret;
 }

 // set opt SAMPLE FORMATS
 ret = av_opt_set_int_list(buffersink_ctx1, "sample_fmts", out_sample_fmts, -1, AV_OPT_SEARCH_CHILDREN);

 if (ret < 0) 
 {
 printf("InitAudioFilter: Cannot set output sample format\n");
 return ret;
 }

 // set opt CHANNEL LAYOUTS
 ret = av_opt_set_int_list(buffersink_ctx1, "channel_layouts", out_channel_layouts, -1, AV_OPT_SEARCH_CHILDREN);

 if (ret < 0) {
 printf("InitAudioFilter: Cannot set output channel layout\n");
 return ret;
 }

 // set opt OUT SAMPLE RATES
 ret = av_opt_set_int_list(buffersink_ctx1, "sample_rates", out_sample_rates, -1, AV_OPT_SEARCH_CHILDREN);

 if (ret < 0) 
 {
 printf("InitAudioFilter: Cannot set output sample rate\n");
 return ret;
 }

 /* Endpoints for the filter graph. */
 outputs -> name = av_strdup("in");
 outputs -> filter_ctx = buffersrc_ctx1;
 outputs -> pad_idx = 0;
 outputs -> next = NULL;

 /* Endpoints for the filter graph. */
 inputs -> name = av_strdup("out");
 inputs -> filter_ctx = buffersink_ctx1;
 inputs -> pad_idx = 0;
 inputs -> next = NULL;


 if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_description1.toStdString().c_str(), &inputs, &outputs, NULL)) < 0) 
 {
 printf("InitAudioFilter: Could not add the filter to graph\n");
 }


 if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0) 
 {
 printf("InitAudioFilter: Could not configure the graph\n");
 }

 /* Print summary of the sink buffer
 * Note: args buffer is reused to store channel layout string */
 AVFilterLink *outlink = buffersink_ctx1->inputs[0];
 av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout);

 QString str = args;
 printf("Output: srate:%dHz fmt:%s chlayout: %s\n", (int) outlink->sample_rate, 
 av_get_sample_fmt_name((AVSampleFormat) outlink->format),
 str.toStdString().c_str());


 filterGraphInitialized_ = true; 
}


And since I don't have much experience with filters or audio for that matter, I'm also probably missing something here. But Can't figure out what.


Thanks


Syndiquer tout le site
