Recherche avancée
Médias (1)
-
Video d’abeille en portrait
14 mai 2011, par
Mis à jour : Février 2012
Langue : français
Type : Video
Autres articles (104)
-
Encoding and processing into web-friendly formats
13 avril 2011, parMediaSPIP automatically converts uploaded files to internet-compatible formats.
Video files are encoded in MP4, Ogv and WebM (supported by HTML5) and MP4 (supported by Flash).
Audio files are encoded in MP3 and Ogg (supported by HTML5) and MP3 (supported by Flash).
Where possible, text is analyzed in order to retrieve the data needed for search engine detection, and then exported as a series of image files.
All uploaded files are stored online in their original format, so you can (...) -
Ajouter des informations spécifiques aux utilisateurs et autres modifications de comportement liées aux auteurs
12 avril 2011, parLa manière la plus simple d’ajouter des informations aux auteurs est d’installer le plugin Inscription3. Il permet également de modifier certains comportements liés aux utilisateurs (référez-vous à sa documentation pour plus d’informations).
Il est également possible d’ajouter des champs aux auteurs en installant les plugins champs extras 2 et Interface pour champs extras. -
Encodage et transformation en formats lisibles sur Internet
10 avril 2011MediaSPIP transforme et ré-encode les documents mis en ligne afin de les rendre lisibles sur Internet et automatiquement utilisables sans intervention du créateur de contenu.
Les vidéos sont automatiquement encodées dans les formats supportés par HTML5 : MP4, Ogv et WebM. La version "MP4" est également utilisée pour le lecteur flash de secours nécessaire aux anciens navigateurs.
Les documents audios sont également ré-encodés dans les deux formats utilisables par HTML5 :MP3 et Ogg. La version "MP3" (...)
Sur d’autres sites (9611)
-
Pydub unable to locate ffprobe
25 décembre 2022, par RecessiveHere is the link to a similar question to this : Pydub (WindowsError : [Error 2] The system can not find the file specified)
Although in this one the problem is with ffmpeg, which I solved by setting the absolute path.


After setting the absolute path for converter and/or ffmpeg with either :


AudioSegment.converter = r'C:\ffmpeg\bin'

or


AudioSegment.ffmpeg = r'C:\ffmpeg\bin'

I still get this error :




C :\Program Files\Python36\lib\site-packages\pydub\utils.py:193 : RuntimeWarning : Couldn't find ffprobe or avprobe - defaulting to ffprobe, but may not work
warn("Couldn't find ffprobe or avprobe - defaulting to ffprobe, but may not work", RuntimeWarning)
Traceback (most recent call last) :
File "C :/Users/Sean/Desktop/vp/encode_audio/m4a_to_wav.py", line 4, in 
song = AudioSegment.from_file("pines.m4a", "m4a")
File "C :\Program Files\Python36\lib\site-packages\pydub\audio_segment.py", line 660, in from_file
info = mediainfo_json(orig_file)
File "C :\Program Files\Python36\lib\site-packages\pydub\utils.py", line 263, in mediainfo_json
res = Popen(command, stdin=stdin_parameter, stdout=PIPE, stderr=PIPE)
File "C :\Program Files\Python36\lib\subprocess.py", line 707, in init
restore_signals, start_new_session)
File "C :\Program Files\Python36\lib\subprocess.py", line 990, in _execute_child
startupinfo)
FileNotFoundError : [WinError 2] The system cannot find the file specified`




I have ffmpeg in my path envvar. I also have libav in my path envvar, and installed libav and then pydub in the order specified at https://github.com/jiaaro/pydub#dependencies.


Nothing I'm doing appears to be working, so any ideas or solutions would be greatly appreciated !


-
Using FFmpeg programmatically with a proxy
2 mai 2013, par William SeemannI'm trying to use FFmpeg with a proxy. The following code works if I comment out :
setenv("http_proxy", "http://172.0.0.1:3128/", 1);The proxy server is an instance of Squid. I know the proxy server is working because I can use the same URL with VLC without any issues. With the proxy specified, the output from my code is always :
Proxy path: http://172.0.0.1:3128/
Metadata could not be retrieved -5 // indicates an IO Error
setDataSource failed, rc is: -1I compiled FFmpeg with everything enabled. Can someone explain why this code doesn't work with a proxy ?
#include
#include
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
const int SUCCESS = 0;
const int FAILURE = -1;
typedef struct State {
AVFormatContext *pFormatCtx;
int audio_stream;
int video_stream;
AVStream *audio_st;
AVStream *video_st;
} State;
int setDataSource(State** ps, const char* path) {
State *state = *ps;
if (state->pFormatCtx) {
avformat_close_input(&state->pFormatCtx);
}
int ret = 0;
if ((ret = avformat_open_input(&state->pFormatCtx, path, NULL, NULL)) != 0) {
printf("Metadata could not be retrieved %d\n", ret);
*ps = NULL;
return FAILURE;
}
if (avformat_find_stream_info(state->pFormatCtx, NULL) < 0) {
printf("Metadata could not be retrieved\n");
avformat_close_input(&state->pFormatCtx);
*ps = NULL;
return FAILURE;
}
*ps = state;
return SUCCESS;
}
const char* extractMetadata(State** ps, const char* key) {
char* value = NULL;
State *state = *ps;
if (!state->pFormatCtx) {
goto fail;
}
if (key) {
if (av_dict_get(state->pFormatCtx->metadata, key, NULL, AV_DICT_IGNORE_SUFFIX)) {
value = av_dict_get(state->pFormatCtx->metadata, key, NULL, AV_DICT_IGNORE_SUFFIX)->value;
}
}
fail:
return value;
}
int main(void) {
setenv("http_proxy", "http://172.0.0.1:3128/", 1);
unsetenv("no_proxy");
const char *proxy_path = getenv("http_proxy");
if (proxy_path) {
printf("Proxy path: %s\n", proxy_path);
} else {
printf("No proxy specified\n");
}
av_register_all();
avformat_network_init();
State * state = av_mallocz(sizeof(State));
int ret = setDataSource(&state, "http://<some host="host">/song.mp3");
if (ret == 0) {
printf("setDataSource succedded!\n");
printf("Artist: %s\n", extractMetadata(&state, "artist"));
} else {
printf("setDataSource failed, rc is: %d\n", ret);
}
return EXIT_SUCCESS;
}
</some> -
Reading mp3 file using ffmpeg caues memory leaks, even after freeing it in main
12 août 2020, par leonardltk1i am continuously reading mp3 files and processing them, but the memory keeps getting build up even though i freed it.


At the bottom
read_audio_mp3(), they are already freeing some variable.
why do i still face a memory build up and how do i deal with it ?

following this code : https://rodic.fr/blog/libavcodec-tutorial-decode-audio-file/, i read mp3 using this function


int read_audio_mp3(string filePath_str, const int sample_rate, 
 double** output_buffer, int &AUDIO_DURATION){
 const char* path = filePath_str.c_str();

 /* Reads the file header and stores information about the file format. */
 AVFormatContext* format = avformat_alloc_context();
 if (avformat_open_input(&format, path, NULL, NULL) != 0) {
 fprintf(stderr, "Could not open file '%s'\n", path);
 return -1;
 }

 /* Check out the stream information in the file. */
 if (avformat_find_stream_info(format, NULL) < 0) {
 fprintf(stderr, "Could not retrieve stream info from file '%s'\n", path);
 return -1;
 }

 /* find an audio stream. */
 int stream_index =- 1;
 for (unsigned i=0; inb_streams; i++) {
 if (format->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 stream_index = i;
 break;
 }
 }
 if (stream_index == -1) {
 fprintf(stderr, "Could not retrieve audio stream from file '%s'\n", path);
 return -1;
 }
 AVStream* stream = format->streams[stream_index];

 // find & open codec
 AVCodecContext* codec = stream->codec;
 if (avcodec_open2(codec, avcodec_find_decoder(codec->codec_id), NULL) < 0) {
 fprintf(stderr, "Failed to open decoder for stream #%u in file '%s'\n", stream_index, path);
 return -1;
 }

 // prepare resampler
 struct SwrContext* swr = swr_alloc();
 av_opt_set_int(swr, "in_channel_count", codec->channels, 0);
 av_opt_set_int(swr, "out_channel_count", 1, 0);
 av_opt_set_int(swr, "in_channel_layout", codec->channel_layout, 0);
 av_opt_set_int(swr, "out_channel_layout", AV_CH_LAYOUT_MONO, 0);
 av_opt_set_int(swr, "in_sample_rate", codec->sample_rate, 0);
 av_opt_set_int(swr, "out_sample_rate", sample_rate, 0);
 av_opt_set_sample_fmt(swr, "in_sample_fmt", codec->sample_fmt, 0);
 av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_DBL, 0);
 swr_init(swr);
 if (!swr_is_initialized(swr)) {
 fprintf(stderr, "Resampler has not been properly initialized\n");
 return -1;
 }

 /* Allocate an audio frame. */
 AVPacket packet;
 av_init_packet(&packet);
 AVFrame* frame = av_frame_alloc();
 if (!frame) {
 fprintf(stderr, "Error allocating the frame\n");
 return -1;
 }

 // iterate through frames
 *output_buffer = NULL;
 AUDIO_DURATION = 0;
 while (av_read_frame(format, &packet) >= 0) {
 // decode one frame
 int gotFrame;
 if (avcodec_decode_audio4(codec, frame, &gotFrame, &packet) < 0) {
 // free packet
 av_free_packet(&packet);
 break;
 }
 if (!gotFrame) {
 // free packet
 av_free_packet(&packet);
 continue;
 }
 // resample frames
 double* buffer;
 av_samples_alloc((uint8_t**) &buffer, NULL, 1, frame->nb_samples, AV_SAMPLE_FMT_DBL, 0);
 int frame_count = swr_convert(swr, (uint8_t**) &buffer, frame->nb_samples, (const uint8_t**) frame->data, frame->nb_samples);
 // append resampled frames to output_buffer
 *output_buffer = (double*) realloc(*output_buffer,
 (AUDIO_DURATION + frame->nb_samples) * sizeof(double));
 memcpy(*output_buffer + AUDIO_DURATION, buffer, frame_count * sizeof(double));
 AUDIO_DURATION += frame_count;
 // free buffer & packet
 av_free_packet(&packet);
 av_free( buffer );
 }

 // clean up
 av_frame_free(&frame);
 swr_free(&swr);
 avcodec_close(codec);
 avformat_free_context(format);

 return 0;
 }


Main Script :
MemoryLeak.cpp

// imports
 #include <fstream>
 #include 
 #include 
 #include 
 #include 
 #include <iostream>
 #include <sstream>
 #include <vector>
 #include <sys></sys>time.h> 
 extern "C"
 {
 #include <libavutil></libavutil>opt.h>
 #include <libavcodec></libavcodec>avcodec.h>
 #include <libavformat></libavformat>avformat.h>
 #include <libswresample></libswresample>swresample.h>
 }
 using namespace std;

 int main (int argc, char ** argv) {
 string wavpath = argv[1];
 printf("wavpath=%s\n", wavpath.c_str());

 printf("\n==== Params =====\n");
 // Init
 int AUDIO_DURATION;
 int sample_rate = 8000;
 av_register_all();

 printf("\n==== Reading MP3 =====\n");
 while (true) {
 // Read mp3
 double* buffer;
 if (read_audio_mp3(wavpath, sample_rate, &buffer, AUDIO_DURATION) != 0) {
 printf("Cannot read %s\n", wavpath.c_str());
 continue;
 }

 /* 
 Process the buffer for down stream tasks.
 */

 // Freeing the buffer
 free(buffer);
 }

 return 0 ;
 }
</vector></sstream></iostream></fstream>

Compiling


g++ -o ./MemoryLeak.out -Ofast -Wall -Wextra \
 -std=c++11 "./MemoryLeak.cpp" \
 -lavformat -lavcodec -lavutil -lswresample


Running, by right my input an argument
wav.scpthat reads text file of all the mp3s.
But for easy to replicate purpose, i only read 1 filesong.mp3in and i keep re-reading it

./MemoryLeak.out song.mp3


Why do i know i have memory leaks ?


- 

- I was running up 32 jobs in parallel for 14 million files, and when i wake up in the morning, they were abruptly killed.
- I run
htopand i monitor the progress when i re-run it, and i saw that theVIRT&RES&Memare continuously increasing.








Edit 1 :
My setup :




ffmpeg version 2.8.15-0ubuntu0.16.04.1
built with gcc 5.4.0


Syndiquer tout le site
