Recherche avancée
Autres articles (103)
-
Mise à jour de la version 0.1 vers 0.2
24 juin 2013, parExplications des différents changements notables lors du passage de la version 0.1 de MediaSPIP à la version 0.3. Quelles sont les nouveautés
Au niveau des dépendances logicielles Utilisation des dernières versions de FFMpeg (>= v1.2.1) ; Installation des dépendances pour Smush ; Installation de MediaInfo et FFprobe pour la récupération des métadonnées ; On n’utilise plus ffmpeg2theora ; On n’installe plus flvtool2 au profit de flvtool++ ; On n’installe plus ffmpeg-php qui n’est plus maintenu au (...) -
Ecrire une actualité
21 juin 2013, parPrésentez les changements dans votre MédiaSPIP ou les actualités de vos projets sur votre MédiaSPIP grâce à la rubrique actualités.
Dans le thème par défaut spipeo de MédiaSPIP, les actualités sont affichées en bas de la page principale sous les éditoriaux.
Vous pouvez personnaliser le formulaire de création d’une actualité.
Formulaire de création d’une actualité Dans le cas d’un document de type actualité, les champs proposés par défaut sont : Date de publication ( personnaliser la date de publication ) (...) -
Publier sur MédiaSpip
13 juin 2013Puis-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 (17834)
-
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 : 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 0 but frames are invalid
9 juillet 2019, par JinxI’ve been trying to extract images from videos, but not those with PNG codec. My code works fine with those with JPEG.
avcodec_receive_frameworked successfully but the data of the frames was like trash ? Do I have to do something special to demuxing when dealing with PNG ?Exception thrown at 0x00007FFF7DF34B9A (msvcrt.dll) in Program.exe : 0xC0000005 : Access violation reading location 0x00000000000003F0 when calling
avcodec_send_framein mysaveImagefunction, which means I was accessing invalid or unalloacted memory I guess. How this happened ?
Just suppose all the function calls returned 0 until exception thrown.
Decoding :
bool ImageExtractor::decode() {
// some other code here
ret = avcodec_send_packet(codec_ctx, packet); // returned 0
ret = avcodec_receive_frame(codec_ctx, frame); // returned 0
if (ret == 0) {
if (count >= target_frame) {
snprintf(buf, sizeof(buf), "%s/%d.png", destination.toLocal8Bit().data(), count);
saveImage(frame, buf); // a function that writes images on disk
}
// some other code here
}
bool ImageExtractor::saveImage(AVFrame *frame, char *destination) {
AVFormatContext *imgFmtCtx = avformat_alloc_context();
pFormatCtx->oformat = av_guess_format("mjpeg", NULL, NULL);
// some other code here
if (!frame)
std::cout << "invalid frame \n";
if (!imgCodecCtx) // AV_CODEC_ID_MJPEG(7)
std::cout << "invalid codec ctx \n";
ret = avcodec_send_frame(imgCodecCtx, frame); // everything stopped here
}Demuxing :
avformat_open_input(&format_ctx, source.toLocal8Bit(), nullptr, nullptr);
vsi = av_find_best_stream(format_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
codec_par = avcodec_parameters_alloc();
avcodec_parameters_copy(codec_par, format_ctx->streams[vsi]->codecpar);
AVCodec* codec = avcodec_find_decoder(codec_par->codec_id); // AV_CODEC_ID_PNG(61)
codec_ctx = avcodec_alloc_context3(codec);
avcodec_parameters_to_context(codec_ctx, codec_par);
avcodec_parameters_free(&codec_par);
avcodec_open2(codec_ctx, codec, 0);
Syndiquer tout le site
