Recherche avancée
Autres articles (58)
-
MediaSPIP : Modification des droits de création d’objets et de publication définitive
11 novembre 2010, parPar défaut, MediaSPIP permet de créer 5 types d’objets.
Toujours par défaut les droits de création et de publication définitive de ces objets sont réservés aux administrateurs, mais ils sont bien entendu configurables par les webmestres.
Ces droits sont ainsi bloqués pour plusieurs raisons : parce que le fait d’autoriser à publier doit être la volonté du webmestre pas de l’ensemble de la plateforme et donc ne pas être un choix par défaut ; parce qu’avoir un compte peut servir à autre choses également, (...) -
Les autorisations surchargées par les plugins
27 avril 2010, parMediaspip core
autoriser_auteur_modifier() afin que les visiteurs soient capables de modifier leurs informations sur la page d’auteurs -
Déploiements possibles
31 janvier 2010, parDeux types de déploiements sont envisageable dépendant de deux aspects : La méthode d’installation envisagée (en standalone ou en ferme) ; Le nombre d’encodages journaliers et la fréquentation envisagés ;
L’encodage de vidéos est un processus lourd consommant énormément de ressources système (CPU et RAM), il est nécessaire de prendre tout cela en considération. Ce système n’est donc possible que sur un ou plusieurs serveurs dédiés.
Version mono serveur
La version mono serveur consiste à n’utiliser qu’une (...)
Sur d’autres sites (6486)
-
ffmpeg : libavfilter API av_buffersink_get_frame returns alway EAGAIN
29 juin 2024, par aculnaigI want to resize an image with
libavfilterC API throughzscalefilter andlibplacebofilter but no matter how I callav_buffersink_get_frame, it always returnsEAGAINand no data is filled in thefiltered_frame.

#include 
#include 
#include 
#include 
#include 

#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavfilter></libavfilter>avfilter.h>
#include <libavfilter></libavfilter>buffersrc.h>
#include <libavfilter></libavfilter>buffersink.h>
#include <libavutil></libavutil>log.h>

int main(int argc, char **argv)
{
 if (argc != 2) {
 fprintf(stderr, "usage: %s <filename>\n", argv[0]);
 exit(EXIT_FAILURE);
 }

 const char *src_name = argv[1];
 const char *dst_name = basename(src_name);
 int ret = 0;

 const enum AVPixelFormat src_format = AV_PIX_FMT_YUV422P;

 av_log_set_level(AV_LOG_TRACE);

 AVFormatContext *fmt_ctx = avformat_alloc_context();
 if (fmt_ctx == NULL) {
 av_log(NULL, AV_LOG_TRACE, "avformat_alloc_context(): failed.\n");
 exit(EXIT_SUCCESS);
 }
 if ((ret = avformat_open_input(&fmt_ctx, src_name, NULL, NULL)) != 0) {
 av_log(NULL, AV_LOG_TRACE, "avformat_open_input(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }

 AVCodecContext *dec_ctx;
 AVCodec *dec;

 if ((ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "av_find_best_stream(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }
 dec_ctx = avcodec_alloc_context3(dec);
 if (dec_ctx == NULL) {
 av_log(NULL, AV_LOG_TRACE, "avcodec_alloc_context3(): failed.\n");
 exit(EXIT_SUCCESS);
 }
 if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "avcodec_open2(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }

 AVFrame *frame = av_frame_alloc();
 if (frame == NULL) {
 av_log(NULL, AV_LOG_TRACE, "av_frame_alloc(): failed.\n");
 exit(EXIT_SUCCESS);
 }
 AVPacket *packet = av_packet_alloc();
 if (packet == NULL) {
 av_log(NULL, AV_LOG_TRACE, "av_packet_alloc(): failed.\n");
 exit(EXIT_SUCCESS);
 }

 if ((ret = av_read_frame(fmt_ctx, packet)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "av_read_frame(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }
 ret = avcodec_send_packet(dec_ctx, packet);
 if (ret == AVERROR(EAGAIN)) {
 av_log(NULL, AV_LOG_TRACE, "avcodec_send_packet(): %s.\n", av_err2str(ret));
 avcodec_receive_frame(dec_ctx, frame);
 avcodec_send_packet(dec_ctx, packet);
 }
 
 if ((ret = avcodec_receive_frame(dec_ctx, frame)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "avcodec_receive_frame(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }
 av_packet_unref(packet);

 av_log(NULL, AV_LOG_TRACE, "filename: %s, w: %d, h: %d, fmt: %d\n", src_name, frame->width, frame->height, frame->format);

 AVFilterGraph *filter_graph = avfilter_graph_alloc();

 char buffersrc_args[512];
 snprintf(buffersrc_args, sizeof(buffersrc_args), "video_size=%dx%d:pix_fmt=%d:time_base=1/25", frame->width, frame->height, frame->format); 

 AVFilterContext *buffersrc_ctx;
 if ((ret = avfilter_graph_create_filter(&buffersrc_ctx, avfilter_get_by_name("buffer"), NULL, buffersrc_args, NULL, filter_graph)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "avfilter_graph_create_filter(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }

 char libplacebo_args[512];
 snprintf(libplacebo_args, sizeof(libplacebo_args), "format=yuv420p:colorspace=bt470bg:color_primaries=bt709:color_trc=iec61966-2-1:range=pc:w=(iw/2):h=(ih/2):downscaler=none:dithering=none");
 AVFilterContext *libplacebo_ctx;
 if ((ret = avfilter_graph_create_filter(&libplacebo_ctx, avfilter_get_by_name("libplacebo"), NULL, libplacebo_args, NULL, filter_graph)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "avfilter_graph_create_filter(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }

 AVFilterContext *buffersink_ctx;
 if ((ret = avfilter_graph_create_filter(&buffersink_ctx, avfilter_get_by_name("buffersink"), NULL, NULL, NULL, filter_graph)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "avfilter_graph_create_filter(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }

 if ((ret = avfilter_link(buffersrc_ctx, 0, libplacebo_ctx, 0)) != 0) {
 av_log(NULL, AV_LOG_TRACE, "avfilter_link(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }
 if ((ret = avfilter_link(libplacebo_ctx, 0, buffersink_ctx, 0)) != 0) {
 av_log(NULL, AV_LOG_TRACE, "avfilter_link(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }
 
 if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "avfilter_graph_config(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }

 AVFrame *filtered_frame = av_frame_alloc();
 if (filtered_frame == NULL) {
 av_log(NULL, AV_LOG_TRACE, "av_frame_alloc(): failed.\n");
 exit(EXIT_SUCCESS);
 }
 if ((ret = av_buffersrc_add_frame(buffersrc_ctx, frame)) < 0) {
 av_log(NULL, AV_LOG_TRACE, "av_buffersrc_add_frame(): %s.\n", av_err2str(ret));
 exit(EXIT_SUCCESS);
 }
 
 while (1) {
 int ret = av_buffersink_get_frame(buffersink_ctx, filtered_frame);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 break;
 if (ret < 0) {
 av_log(NULL, AV_LOG_TRACE, "av_buffersink_get_frame(): %s.\n", av_err2str(ret));
 exit(EXIT_FAILURE);
 } 
 }

 av_log(NULL, AV_LOG_TRACE, "filename: %s, w: %d, h: %d, f: %d\n", dst_name, filtered_frame->width, filtered_frame->height, filtered_frame->format);

 AVCodecContext *enc_ctx;
 AVCodec *enc;
 AVPacket *enc_packet = av_packet_alloc();

 enc = avcodec_find_encoder_by_name("mjpeg");
 enc_ctx = avcodec_alloc_context3(enc);
 enc_ctx->width = filtered_frame->width;
 enc_ctx->height = filtered_frame->height;
 enc_ctx->bit_rate = dec_ctx->bit_rate * 1024;
 enc_ctx->time_base = (AVRational) {1, 25};
 enc_ctx->framerate = (AVRational) {25, 1};
 enc_ctx->pix_fmt = filtered_frame->format;
 enc_ctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
 enc_ctx->compression_level = 0;
 enc_ctx->color_range = AVCOL_RANGE_JPEG;

 avcodec_open2(enc_ctx, enc, NULL);

 avcodec_send_frame(enc_ctx, filtered_frame);
 avcodec_receive_packet(enc_ctx, enc_packet);

 FILE *dst_file = fopen(dst_name, "wb");
 fwrite(enc_packet->data, 1, enc_packet->size, dst_file);
 fclose(dst_file);

 av_packet_unref(enc_packet);
 av_frame_free(&frame);
 av_frame_free(&filtered_frame);
 
 avfilter_graph_free(&filter_graph);

 avformat_close_input(&fmt_ctx);
 avformat_free_context(fmt_ctx);
 
 exit(EXIT_SUCCESS);
}
</filename>

and here are the logs




PS : the logs were so many I could paste in stackoverflow


-
FFmpeg - avcodec_receive_frame returns AVERROR(EAGAIN)
8 novembre 2019, par JinxI’m using an QOpenGL widget to draw frames. However, I’m struggling to get frames by using
avcodec_receive_frame. It ended within the blockelse if (ret == AVERROR(EAGAIN))and returned -11. I have no idea what made this happen. Also I checked that codecs were fine, so I guess the problem wasn’t caused by codecs.MyDemux.cpp
AVPacket* MyDemux::allocatePacket()
{
AVPacket* packet = av_packet_alloc();
return packet;
}
AVFrame* MyDemux::allocateFrame()
{
AVFrame* frame = av_frame_alloc();
return frame;
}
int MyDemux::readFrame(AVPacket* packet)
{
mux.lock();
if (!formatCtx) {
std::cout << "formaetCtx is null" << std::endl;
mux.unlock();
return -1;
}
int ret = av_read_frame(formatCtx, packet);
if (ret == AVERROR_EOF) {
return -2;
}
if (ret != 0) {
mux.unlock();
av_packet_free(&packet);
return -1;
}
media_type = packet->stream_index;
mux.unlock();
return 0;
}MyDecode.cpp
void MyDecode::decode(AVFrame* frame, AVPacket* packet)
{
int ret;
ret = avcodec_send_packet(codecCtx, packet); // this returned 0
while (ret == 0) {
ret = avcodec_receive_frame(codecCtx, frame); // this returned -11
if (ret == AVERROR(EINVAL)) {
std::cout << "codec issue" << std::endl;
av_frame_free(&frame);
return;
}
else if (ret == AVERROR(EAGAIN)) { // program ends here
std::cout << "output is not available this state" << std::endl;
av_frame_free(&frame);
return;
}
else if (ret == AVERROR(EINVAL)) {
std::cout << "no more frames" << std::endl;
av_frame_free(&frame);
return;
}
}
}main.cpp
class MyThread : public QThread
{
public:
MyDemux demux;
MyDecode video_decode;
myDecode audio_decode;
MyVideoWidget* videoWidget;
AVPacket* packet;
AVFrame* frame;
void initThread()
{
char* url = "demo.mp4";
demux.openFile(url);
video_decode.openCodec(demux.copy_video_codec_par());
audio_decode.openCodec(demux.copy_audio_codec_par());
packet = demux.allocatePacket();
frame = demux.allocateFrame();
}
void run()
{
while (demux.readFrame(packet) != -2) {
if (demux.get_media_type() == 0) {
video_decode.decode(frame, packet);
videoWidget->paintFrame(frame);
}
else if (demux.get_media_type() == 1) {
}
}
video_decode.decode(frame, nullptr);
demux.clear();
demux.close();
}
}; -
FFMPEG and Mencoder building screenshot returns 0 size images
12 avril 2014, par GenusI have a script and it used to work fine but suddenly it stopped working and giving me zero size images as screenshot after video convert.
here is the command for video screenshot.
$cmd = $GLOBALS["paths"]["ffmpeg"]." -y -i ".$file." -f mjpeg -r 1 -ss ".$time." -vframes 1 -an ".$tmpdir."/00000001.jpg 2>&1";
exec($cmd,$results);Debug :
-----------------------------------------------------
------------mencoder_and_fmpeg.php SCREENSHOT -------
-----------------------------------------------------
COMMAND: ffmpeg -y -i /home/TESTING/public_html/vid/6d/ad/29/6dad2946a2ba102.flv -f mjpeg -r 1 -ss 14.48 -vframes 1 -an /home/TESTING/public_html/scr/42/3a/92/00000001.jpg 2>&1
FFmpeg version SVN-r16244, Copyright (c) 2000-2008 Fabrice Bellard, et al.
configuration: --disable-mmx --enable-shared --enable-libvorbis --enable-gpl --enable-swscale --enable-pthreads --disable-static --disable-demuxer=v4l --disable-demuxer=v4l2 --enable-libtheora --enable-gpl --enable-libspeex --enable-libmp3lame --enable-libfaac --enable-libfaad --enable-libfaadbin --enable-libamr-nb --enable-libamr-wb --enable-nonfree --enable-libxvid
libavutil 49.12. 0 / 49.12. 0
libavcodec 52. 7. 0 / 52.108. 0
libavformat 52.23. 1 / 52.92. 0
libavdevice 52. 1. 0 / 52. 2. 3
libswscale 0. 6. 1 / 0.12. 0
built on Apr 9 2011 22:48:41, gcc: 4.1.2 20080704 (Red Hat 4.1.2-50)
built by Admin-Ahead Server Technologies FFmpeg installer v5.0.6b
Seems stream 0 codec frame rate differs from container frame rate: 1000.00 (1000/1) -> 10.92 (131/12)
Stream mapping:
Stream #0.0 -> #0.0
Press [q] to stop encoding
ffmpeg: symbol lookup error: ffmpeg: undefined symbol: frame_hook_process
Syndiquer tout le site
