Recherche avancée
Médias (91)
-
Head down (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Echoplex (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Discipline (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Letting you (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
1 000 000 (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
999 999 (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
Autres articles (81)
-
Des sites réalisés avec MediaSPIP
2 mai 2011, parCette page présente quelques-uns des sites fonctionnant sous MediaSPIP.
Vous pouvez bien entendu ajouter le votre grâce au formulaire en bas de page. -
Keeping control of your media in your hands
13 avril 2011, parThe vocabulary used on this site and around MediaSPIP in general, aims to avoid reference to Web 2.0 and the companies that profit from media-sharing.
While using MediaSPIP, you are invited to avoid using words like "Brand", "Cloud" and "Market".
MediaSPIP is designed to facilitate the sharing of creative media online, while allowing authors to retain complete control of their work.
MediaSPIP aims to be accessible to as many people as possible and development is based on expanding the (...) -
Participer à sa traduction
10 avril 2011Vous pouvez nous aider à améliorer les locutions utilisées dans le logiciel ou à traduire celui-ci dans n’importe qu’elle nouvelle langue permettant sa diffusion à de nouvelles communautés linguistiques.
Pour ce faire, on utilise l’interface de traduction de SPIP où l’ensemble des modules de langue de MediaSPIP sont à disposition. ll vous suffit de vous inscrire sur la liste de discussion des traducteurs pour demander plus d’informations.
Actuellement MediaSPIP n’est disponible qu’en français et (...)
Sur d’autres sites (10635)
-
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
