Recherche avancée
Autres articles (112)
-
Personnaliser en ajoutant son logo, sa bannière ou son image de fond
5 septembre 2013, parCertains thèmes prennent en compte trois éléments de personnalisation : l’ajout d’un logo ; l’ajout d’une bannière l’ajout d’une image de fond ;
-
Script d’installation automatique de MediaSPIP
25 avril 2011, parAfin de palier aux difficultés d’installation dues principalement aux dépendances logicielles coté serveur, un script d’installation "tout en un" en bash a été créé afin de faciliter cette étape sur un serveur doté d’une distribution Linux compatible.
Vous devez bénéficier d’un accès SSH à votre serveur et d’un compte "root" afin de l’utiliser, ce qui permettra d’installer les dépendances. Contactez votre hébergeur si vous ne disposez pas de cela.
La documentation de l’utilisation du script d’installation (...) -
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.
Sur d’autres sites (11255)
-
I want to save a video with effects applied on it. OnSucccess is not calling [duplicate]
10 novembre 2016, par shriyaThis question already has an answer here :
This is command string which i want to process.
String[] command = new String[]"ffmpeg -y -i " + old_video_path + " -strict experimental -vf curves=vintage -s 240x320 -r 30 -aspect 4:3 -ab 48000 /storage/emulated/0/video.mp4" ;
executeFFmpeg(command) ;private void executeFFmpeg(String[] cmd) {
try {
ffmpeg.execute(cmd, new ExecuteBinaryResponseHandler() {
@Override
public void onStart() {
Log.e("Progress", "onStart");
}
@Override
public void onProgress(String message) {
Log.e("Progress", "onProgress");
}
@Override
public void onSuccess(String message) {
Log.e("Progress", "onSuccess");
}
@Override
public void onFailure(String message) {
Log.e("Progress", "onFailure" + message);
}
@Override
public void onFinish() {
Log.e("Progress", "onFinish");
}
});
} catch (FFmpegCommandAlreadyRunningException e) {
// Handle if FFmpeg is already running
}
}in Log i am getting onProcess call and onFininsh call. How do i write code to save this video in sdcard and where ?
-
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>

-
avcodec/ffv1enc : Store run1start_mul_index instead of computing
25 mars, par Michael Niedermayer
Syndiquer tout le site
