Recherche avancée
Médias (1)
-
Richard Stallman et le logiciel libre
19 octobre 2011, par
Mis à jour : Mai 2013
Langue : français
Type : Texte
Autres articles (63)
-
MediaSPIP 0.1 Beta version
25 avril 2011, parMediaSPIP 0.1 beta is the first version of MediaSPIP proclaimed as "usable".
The zip file provided here only contains the sources of MediaSPIP in its standalone version.
To get a working installation, you must manually install all-software dependencies on the server.
If you want to use this archive for an installation in "farm mode", you will also need to proceed to other manual (...) -
Submit bugs and patches
13 avril 2011Unfortunately a software is never perfect.
If you think you have found a bug, report it using our ticket system. Please to help us to fix it by providing the following information : the browser you are using, including the exact version as precise an explanation as possible of the problem if possible, the steps taken resulting in the problem a link to the site / page in question
If you think you have solved the bug, fill in a ticket and attach to it a corrective patch.
You may also (...) -
Les tâches Cron régulières de la ferme
1er décembre 2010, parLa gestion de la ferme passe par l’exécution à intervalle régulier de plusieurs tâches répétitives dites Cron.
Le super Cron (gestion_mutu_super_cron)
Cette tâche, planifiée chaque minute, a pour simple effet d’appeler le Cron de l’ensemble des instances de la mutualisation régulièrement. Couplée avec un Cron système sur le site central de la mutualisation, cela permet de simplement générer des visites régulières sur les différents sites et éviter que les tâches des sites peu visités soient trop (...)
Sur d’autres sites (7293)
-
FFmpeg VAAPI : GOP Size Setting Not Applied During Encoding
17 octobre 2024, par sun tonyI'm working on a video transcoding project using FFmpeg with VAAPI hardware acceleration, and I'm encountering an issue where the gop_size parameter is not being respected during encoding. Despite setting the gop_size to 150 in the encoder context, the output video does not have the expected GOP structure. This problem only occurs when using VAAPI for hardware acceleration—when I switch to software decoding or CUDA, the GOP size is applied correctly.


Here’s a simplified version of the relevant code where I set the gop_size :


encoder_ctx->gop_size = 150;


I'm using FFmpeg's VAAPI for hardware-accelerated encoding, and everything else works as expected, except for this GOP size issue. Has anyone encountered this problem, or is there something specific to VAAPI that I'm missing ?


Environment :


- 

- FFmpeg version : (6.0)
- VAAPI (Intel GPU)
- Encoder : H.264








#include 
#include 
extern "C"
{
#include <libavutil></libavutil>hwcontext.h>
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
}
static AVFormatContext* ifmt_ctx = NULL, * ofmt_ctx = NULL;
static AVBufferRef* hw_device_ctx = NULL;
static AVCodecContext* decoder_ctx = NULL, * encoder_ctx = NULL;
static int video_stream = -1;
static AVStream* ost;
static int initialized = 0;

static enum AVPixelFormat get_vaapi_format(AVCodecContext* ctx,
 const enum AVPixelFormat* pix_fmts)
{
 const enum AVPixelFormat* p;

 for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) { 
 if (*p == AV_PIX_FMT_VAAPI)
 return *p;
 }

 fprintf(stderr, "Unable to decode this file using VA-API.\n");
 return AV_PIX_FMT_NONE;
}

static int open_input_file(const char* filename)
{
 int ret;
 const AVCodec* decoder = NULL;
 AVStream* video = NULL;
 char err_buf[AV_ERROR_MAX_STRING_SIZE] = { 0, };

 if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Cannot open input file '%s', Error code: %s\n", filename, err_buf);
 return ret;
 }

 if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Cannot find input stream information. Error code: %s\n", err_buf);
 return ret;
 }

 ret = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &decoder, 0);
 if (ret < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Cannot find a video stream in the input file. Error code: %s\n", err_buf);
 return ret;
 }
 video_stream = ret;

 if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
 return AVERROR(ENOMEM);

 video = ifmt_ctx->streams[video_stream];
 if ((ret = avcodec_parameters_to_context(decoder_ctx, video->codecpar)) < 0) {

 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "avcodec_parameters_to_context error. Error code: %s\n", err_buf);
 return ret;
 }

 decoder_ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
 if (!decoder_ctx->hw_device_ctx) {
 fprintf(stderr, "A hardware device reference create failed.\n");
 return AVERROR(ENOMEM);
 }
 decoder_ctx->get_format = get_vaapi_format;

 if ((ret = avcodec_open2(decoder_ctx, decoder, NULL)) < 0){
 
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Failed to open codec for decoding.Error code: %s\n", err_buf);
 }
 
 return ret;
}

static int encode_write(AVPacket* enc_pkt, AVFrame* frame)
{
 int ret = 0;
 char err_buf[AV_ERROR_MAX_STRING_SIZE] = { 0, };
 av_packet_unref(enc_pkt);

 if ((ret = avcodec_send_frame(encoder_ctx, frame)) < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Error during encoding. Error code: %s\n", err_buf);
 goto end;
 }
 while (1) {
 ret = avcodec_receive_packet(encoder_ctx, enc_pkt);
 if (ret)
 break;

 enc_pkt->stream_index = 0;
 av_packet_rescale_ts(enc_pkt, ifmt_ctx->streams[video_stream]->time_base,
 ofmt_ctx->streams[0]->time_base);
 ret = av_interleaved_write_frame(ofmt_ctx, enc_pkt);
 if (ret < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Error during writing data to output file. Error code: %s\n", err_buf);
 return -1;
 }
 }

end:
 if (ret == AVERROR_EOF)
 return 0;
 ret = ((ret == AVERROR(EAGAIN)) ? 0 : -1);
 return ret;
}

static int dec_enc(AVPacket* pkt, const AVCodec* enc_codec)
{
 AVFrame* frame;
 AVDictionary* opts = NULL;

 int ret = 0;
 char err_buf[AV_ERROR_MAX_STRING_SIZE] = { 0, };
 ret = avcodec_send_packet(decoder_ctx, pkt);
 if (ret < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Error during decoding.Error code : %s\n", err_buf);
 return ret;
 }

 while (ret >= 0) {
 if (!(frame = av_frame_alloc()))
 return AVERROR(ENOMEM);

 ret = avcodec_receive_frame(decoder_ctx, frame);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 av_frame_free(&frame);
 return 0;
 }
 else if (ret < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Error while decoding.Error code : %s\n", err_buf);
 goto fail;
 }

 if (!initialized) {
 /* we need to ref hw_frames_ctx of decoder to initialize encoder's codec.
 Only after we get a decoded frame, can we obtain its hw_frames_ctx */
 encoder_ctx->hw_frames_ctx = av_buffer_ref(decoder_ctx->hw_frames_ctx);
 if (!encoder_ctx->hw_frames_ctx) {
 ret = AVERROR(ENOMEM);
 goto fail;
 }
 /* set AVCodecContext Parameters for encoder, here we keep them stay
 * the same as decoder.
 * xxx: now the sample can't handle resolution change case.
 */
 encoder_ctx->time_base = av_inv_q(decoder_ctx->framerate);
 encoder_ctx->pix_fmt = AV_PIX_FMT_VAAPI;
 encoder_ctx->width = decoder_ctx->width;
 encoder_ctx->height = decoder_ctx->height;
 encoder_ctx->gop_size = 150;
 av_dict_set(&opts, "g", "150", 0); // gop_size 설정

 if ((ret = avcodec_open2(encoder_ctx, enc_codec, &opts)) < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Failed to open encode codec. Error code : %s\n", err_buf);
 goto fail;
 }

 if (!(ost = avformat_new_stream(ofmt_ctx, enc_codec))) {
 fprintf(stderr, "Failed to allocate stream for output format.\n");
 ret = AVERROR(ENOMEM);
 goto fail;
 }

 ost->time_base = encoder_ctx->time_base;
 ret = avcodec_parameters_from_context(ost->codecpar, encoder_ctx);
 if (ret < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Failed to copy the stream parameters. Error code : %s\n", err_buf);
 goto fail;
 }

 /* write the stream header */
 if ((ret = avformat_write_header(ofmt_ctx, NULL)) < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Error while writing stream header. Error code : %s\n", err_buf);
 goto fail;
 }

 initialized = 1;
 }

 if ((ret = encode_write(pkt, frame)) < 0)
 fprintf(stderr, "Error during encoding and writing.\n");

 fail:
 av_frame_free(&frame);
 if (ret < 0)
 return ret;
 }
 return 0;
}

int main(int argc, char** argv)
{
 const AVCodec* enc_codec;
 int ret = 0;
 AVPacket* dec_pkt;
 char err_buf[AV_ERROR_MAX_STRING_SIZE] = { 0, };

 if (argc != 4) {
 fprintf(stderr, "Usage: %s <input file="file" /> <encode codec="codec"> <output file="file">\n"
 "The output format is guessed according to the file extension.\n"
 "\n", argv[0]);
 return -1;
 }

 ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI, NULL, NULL, 0);
 if (ret < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Failed to create a VAAPI device. Error code : %s\n", err_buf);
 return -1;
 }

 dec_pkt = av_packet_alloc();
 if (!dec_pkt) {
 fprintf(stderr, "Failed to allocate decode packet\n");
 goto end;
 }

 if ((ret = open_input_file(argv[1])) < 0)
 goto end;

 if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
 fprintf(stderr, "Could not find encoder '%s'\n", argv[2]);
 ret = -1;
 goto end;
 }

 if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Failed to deduce output format from file extension. Error code : %s\n", err_buf);
 goto end;
 }

 if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
 ret = AVERROR(ENOMEM);
 goto end;
 }

 ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
 if (ret < 0) {
 av_strerror(ret, err_buf, AV_ERROR_MAX_STRING_SIZE);
 fprintf(stderr, "Cannot open output file. Error code : %s\n", err_buf);
 goto end;
 }

 /* read all packets and only transcoding video */
 while (ret >= 0) {
 if ((ret = av_read_frame(ifmt_ctx, dec_pkt)) < 0)
 break;

 if (video_stream == dec_pkt->stream_index)
 ret = dec_enc(dec_pkt, enc_codec);

 av_packet_unref(dec_pkt);
 }

 /* flush decoder */
 av_packet_unref(dec_pkt);
 ret = dec_enc(dec_pkt, enc_codec);

 /* flush encoder */
 ret = encode_write(dec_pkt, NULL);

 /* write the trailer for output stream */
 av_write_trailer(ofmt_ctx);

end:
 avformat_close_input(&ifmt_ctx);
 avformat_close_input(&ofmt_ctx);
 avcodec_free_context(&decoder_ctx);
 avcodec_free_context(&encoder_ctx);
 av_buffer_unref(&hw_device_ctx);
 av_packet_free(&dec_pkt);
 return ret;
}
</output></encode>

-
Add length for each frame in a MJPEG stream transcoded by ffmpeg
8 décembre 2020, par user3612643I am using the following command to transcode my cam's stream into
mjpegwhich I decode and present in my custom home-control app :

ffmpeg -i rtsp://mycamera:554/onvif1 -c:v mjpeg -f mjpeg -

That works quite nicely, but the result is just a continuous sequence of
jpegimages/frames. For faster decoding, I would like to have a length header before each frame, so that I can cut out the exact JPEG from the stream :

LENGTH FRAME LENGTH FRAME

Each
LENGTHshould be 4-bytes encoding in LE or BE the length of the followingFRAMEin bytes.

-
avfilter/vf_delogo : fix show option when clipping
14 décembre 2015, par Jean Delvareavfilter/vf_delogo : fix show option when clipping
The show option did not take clipping into account, so the borders on
the clipped side wouldn’t show up. Fix it.Signed-off-by : Jean Delvare <jdelvare@suse.de>
Signed-off-by : Michael Niedermayer <michael@niedermayer.cc>
Syndiquer tout le site
