Recherche avancée
Médias (29)
-
#7 Ambience
16 octobre 2011, par
Mis à jour : Juin 2015
Langue : English
Type : Audio
-
#6 Teaser Music
16 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Audio
-
#5 End Title
16 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Audio
-
#3 The Safest Place
16 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Audio
-
#4 Emo Creates
15 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Audio
-
#2 Typewriter Dance
15 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Audio
Autres articles (108)
-
Les formats acceptés
28 janvier 2010, parLes commandes suivantes permettent d’avoir des informations sur les formats et codecs gérés par l’installation local de ffmpeg :
ffmpeg -codecs ffmpeg -formats
Les format videos acceptés en entrée
Cette liste est non exhaustive, elle met en exergue les principaux formats utilisés : h264 : H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 m4v : raw MPEG-4 video format flv : Flash Video (FLV) / Sorenson Spark / Sorenson H.263 Theora wmv :
Les formats vidéos de sortie possibles
Dans un premier temps on (...) -
Encoding and processing into web-friendly formats
13 avril 2011, parMediaSPIP automatically converts uploaded files to internet-compatible formats.
Video files are encoded in MP4, Ogv and WebM (supported by HTML5) and MP4 (supported by Flash).
Audio files are encoded in MP3 and Ogg (supported by HTML5) and MP3 (supported by Flash).
Where possible, text is analyzed in order to retrieve the data needed for search engine detection, and then exported as a series of image files.
All uploaded files are stored online in their original format, so you can (...) -
Installation en mode ferme
4 février 2011, parLe mode ferme permet d’héberger plusieurs sites de type MediaSPIP en n’installant qu’une seule fois son noyau fonctionnel.
C’est la méthode que nous utilisons sur cette même plateforme.
L’utilisation en mode ferme nécessite de connaïtre un peu le mécanisme de SPIP contrairement à la version standalone qui ne nécessite pas réellement de connaissances spécifique puisque l’espace privé habituel de SPIP n’est plus utilisé.
Dans un premier temps, vous devez avoir installé les mêmes fichiers que l’installation (...)
Sur d’autres sites (11108)
-
FFMPEG and STB_Image Create awful Picture
9 février 2023, par murage kibichoI was learning how to use the FFMPEG C api and I was trying to encode a jpeg into a MPEG file. I load the JPEG into (unsigned char *) using the stb-image library. Then I create a (uint8_t *) and copy my rgb values. Finally, I convert RGB to YUV420 using sws_scale. However, a portion of my image blurs out when I perform the encoding.

/
This is the original image



Perhaps I allocate my frame buffer incorrectly ?

ret = av_frame_get_buffer(frame, 0);



This is my entire program


#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"
#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include "stb_image_resize.h"
#include 

#include <libavcodec></libavcodec>avcodec.h>
#include <libavutil></libavutil>opt.h>
#include <libavutil></libavutil>imgutils.h>
#include <libswscale></libswscale>swscale.h>
//gcc stack.c -lm -o stack.o `pkg-config --cflags --libs libavformat libavcodec libswresample libswscale libavutil` && ./stack.o

/*
int i : pts of current frame
*/
void PictureToFrame(int i, AVFrame *frame, int height, int width)
{
 //Use stb image to get rgb values
 char *fileName = "profil.jpeg";
 int imageHeight = 0;
 int imageWidth = 0;
 int colorChannels = 0;
 int arrayLength = 0;
 unsigned char *image = stbi_load(fileName,&imageWidth,&imageHeight,&colorChannels,0);
 
 printf("(height: %d, width: %d)\n",imageHeight, imageWidth);
 assert(colorChannels == 3 && imageHeight == height && imageWidth == width);
 
 //Convert unsigned char * to uint8_t *
 arrayLength = imageHeight * imageWidth * colorChannels;
 uint8_t *rgb = calloc(arrayLength, sizeof(uint8_t));
 int j = arrayLength-1;
 for(int i = 0; i < arrayLength; i++)
 {
 rgb[i] = (uint8_t) image[i];
 }
 
 //Use SwsContext to scale RGB to YUV420P and write to frame
 const int in_linesize[1] = { 3* imageWidth};
 struct SwsContext *sws_context = NULL;
 sws_context = sws_getCachedContext(sws_context,
 imageWidth, imageHeight, AV_PIX_FMT_RGB24,
 imageWidth, imageHeight, AV_PIX_FMT_YUV420P,
 0, 0, 0, 0);
 sws_scale(sws_context, (const uint8_t * const *)&rgb, in_linesize, 0,
 imageHeight, frame->data, frame->linesize);
 //Save frame pts
 frame->pts = i;
 
 //Free alloc'd data
 stbi_image_free(image);
 sws_freeContext(sws_context);
 free(rgb);
}
static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt, FILE *outfile)
{
 int returnValue;
 /* send the frame to the encoder */
 if(frame)
 {
 printf("Send frame %3"PRId64"\n", frame->pts);
 }
 returnValue = avcodec_send_frame(enc_ctx, frame);
 if(returnValue < 0)
 {
 printf("Error sending a frame for encoding\n");
 return;
 }
 while(returnValue >= 0)
 {
 returnValue = avcodec_receive_packet(enc_ctx, pkt);
 if(returnValue == AVERROR(EAGAIN) || returnValue == AVERROR_EOF)
 {
 return;
 }
 else if(returnValue < 0)
 {
 printf("Error during encoding\n");
 return;
 }

 printf("Write packet %3"PRId64" (size=%5d)\n", pkt->pts, pkt->size);
 fwrite(pkt->data, 1, pkt->size, outfile);
 av_packet_unref(pkt);
 }
}


int main(int argc, char **argv)
{
 const char *filename, *codec_name;
 const AVCodec *codec;
 AVCodecContext *c= NULL;
 int i, ret, x, y;
 FILE *f;
 AVFrame *frame;
 AVPacket *pkt;
 uint8_t endcode[] = { 0, 0, 1, 0xb7 };

 filename = "outo.mp4";
 codec_name = "mpeg1video";//"mpeg1video";//"libx264";


 /* find the mpeg1video encoder */
 codec = avcodec_find_encoder_by_name(codec_name);
 if(!codec)
 {
 printf("Error finding codec\n");
 return 0;
 }

 c = avcodec_alloc_context3(codec);
 if(!c)
 {
 printf("Error allocating c\n");
 return 0;
 }

 pkt = av_packet_alloc();
 if(!pkt)
 {
 printf("Error allocating pkt\n");
 return 0;
 }

 /* put sample parameters */
 c->bit_rate = 400000;
 /* resolution must be a multiple of two */
 c->width = 800;
 c->height = 800;
 /* frames per second */
 c->time_base = (AVRational){1, 25};
 c->framerate = (AVRational){25, 1};
 c->gop_size = 10;
 c->max_b_frames = 1;
 c->pix_fmt = AV_PIX_FMT_YUV420P;

 if(codec->id == AV_CODEC_ID_H264)
 {
 av_opt_set(c->priv_data, "preset", "slow", 0);
 }
 

 /* open it */
 ret = avcodec_open2(c, codec, NULL);
 if(ret < 0) 
 {
 printf("Error opening codec\n");
 return 0;
 }

 f = fopen(filename, "wb");
 if(!f)
 {
 printf("Error opening file\n");
 return 0;
 }

 frame = av_frame_alloc();
 if(!frame)
 {
 printf("Error allocating frame\n");
 return 0;
 }
 frame->format = c->pix_fmt;
 frame->width = c->width;
 frame->height = c->height;

 //I suspect this is the problem
 ret = av_frame_get_buffer(frame, 0);
 if(ret < 0)
 {
 fprintf(stderr, "Could not allocate the video frame data\n");
 exit(1);
 }

 /* encode 25 frames*/
 for(i = 0; i < 25; i++) 
 {

 /* make sure the frame data is writable */
 ret = av_frame_make_writable(frame);
 if(ret < 0)
 {
 return 0;
 }
 //FIll Frame with picture data
 PictureToFrame(i, frame, c->height, c->width);

 /* encode the image */
 encode(c, frame, pkt, f);
 }

 /* flush the encoder */
 encode(c, NULL, pkt, f);

 /* add sequence end code to have a real MPEG file */
 if (codec->id == AV_CODEC_ID_MPEG1VIDEO || codec->id == AV_CODEC_ID_MPEG2VIDEO)
 fwrite(endcode, 1, sizeof(endcode), f);
 fclose(f);

 avcodec_free_context(&c);
 av_frame_free(&frame);
 av_packet_free(&pkt);

 return 0;
}



-
How AVCodecContext bitrate, framerate and timebase is used when encoding single frame
28 mars 2023, par CyrusI am trying to learn FFmpeg from examples as there is a tight schedule. The task is to encode a raw YUV image into JPEG format of the given width and height. I have found examples from ffmpeg official website, which turns out to be quite straight-forward. However there are some fields in AVCodecContext that I thought only makes sense when encoding videos(e.g. bitrate, framerate, timebase, gopsize, max_b_frames etc).


I understand on a high level what those values are when it comes to videos, but do I need to care about those when I just want a single image ? Currently for testing, I am just setting them as dummy values and it seems to work. But I want to make sure that I am not making terrible assumptions that will break in the long run.


EDIT :


Here is the code I got. Most of them are copy and paste from examples, with some changes to replace old APIs with newer ones.


#include "thumbnail.h"
#include "libavcodec/avcodec.h"
#include "libavutil/imgutils.h"
#include 
#include 
#include 

void print_averror(int error_code) {
 char err_msg[100] = {0};
 av_strerror(error_code, err_msg, 100);
 printf("Reason: %s\n", err_msg);
}

ffmpeg_status_t save_yuv_as_jpeg(uint8_t* source_buffer, char* output_thumbnail_filename, int thumbnail_width, int thumbnail_height) {
 const AVCodec* mjpeg_codec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
 if (!mjpeg_codec) {
 printf("Codec for mjpeg cannot be found.\n");
 return FFMPEG_THUMBNAIL_CODEC_NOT_FOUND;
 }

 AVCodecContext* codec_ctx = avcodec_alloc_context3(mjpeg_codec);
 if (!codec_ctx) {
 printf("Codec context cannot be allocated for the given mjpeg codec.\n");
 return FFMPEG_THUMBNAIL_ALLOC_CONTEXT_FAILED;
 }

 AVPacket* pkt = av_packet_alloc();
 if (!pkt) {
 printf("Thumbnail packet cannot be allocated.\n");
 return FFMPEG_THUMBNAIL_ALLOC_PACKET_FAILED;
 }

 AVFrame* frame = av_frame_alloc();
 if (!frame) {
 printf("Thumbnail frame cannot be allocated.\n");
 return FFMPEG_THUMBNAIL_ALLOC_FRAME_FAILED;
 }

 // The part that I don't understand
 codec_ctx->bit_rate = 400000;
 codec_ctx->width = thumbnail_width;
 codec_ctx->height = thumbnail_height;
 codec_ctx->time_base = (AVRational){1, 25};
 codec_ctx->framerate = (AVRational){1, 25};

 codec_ctx->gop_size = 10;
 codec_ctx->max_b_frames = 1;
 codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
 int ret = av_image_fill_arrays(frame->data, frame->linesize, source_buffer, AV_PIX_FMT_YUV420P, thumbnail_width, thumbnail_height, 32);
 if (ret < 0) {
 print_averror(ret);
 printf("Pixel format: yuv420p, width: %d, height: %d\n", thumbnail_width, thumbnail_height);
 return FFMPEG_THUMBNAIL_FILL_FRAME_DATA_FAILED;
 }

 ret = avcodec_send_frame(codec_ctx, frame);
 if (ret < 0) {
 print_averror(ret);
 printf("Failed to send frame to encoder.\n");
 return FFMPEG_THUMBNAIL_FILL_SEND_FRAME_FAILED;
 }

 ret = avcodec_receive_packet(codec_ctx, pkt);
 if (ret < 0) {
 print_averror(ret);
 printf("Failed to receive packet from encoder.\n");
 return FFMPEG_THUMBNAIL_FILL_SEND_FRAME_FAILED;
 }

 // store the thumbnail in output
 int fd = open(output_thumbnail_filename, O_CREAT | O_RDWR);
 write(fd, pkt->data, pkt->size);
 close(fd);

 // freeing allocated structs
 avcodec_free_context(&codec_ctx);
 av_frame_free(&frame);
 av_packet_free(&pkt);
 return FFMPEG_SUCCESS;
}


-
avcodec_open2 returns Invalid Argument (errnum -22)
7 avril 2023, par noklaI am trying to encode a vector of AVFrames to an MP4 file using the h264 codec.


Everything seems to work fine until the avcodec_open2 function, which returns an "Invalid Argument" (-22) error.


*The stream parameter is a pointer to AVStream.


Here is the code that sets the stream parameters :


stream->codecpar->codec_id = AV_CODEC_ID_H264;
 stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 stream->codecpar->width = settings.resolution[0]; // 270
 stream->codecpar->height = settings.resolution[1]; // 480
 stream->codecpar->format = AV_PIX_FMT_YUV420P;
 stream->codecpar->bit_rate = 400000;
 AVRational framerate = { 1, 30};
 stream->time_base = av_inv_q(framerate);


And here is the code that opens the codec context :


// Open the codec context
 AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
 if (!codec_ctx) {
 std::cout << "Error allocating codec context" << std::endl;
 avformat_free_context(format_ctx);
 return;
 }

 ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);
 if (ret < 0) {
 std::cout << "Error setting codec context parameters: " << av_err2str(ret) << std::endl;
 avcodec_free_context(&codec_ctx);
 avformat_free_context(format_ctx);
 return;
 }

 ret = avcodec_open2(codec_ctx, codec, nullptr);
 if (ret < 0) {
 wxMessageBox("Error opening codec: ");
 wxMessageBox(av_err2str(ret));
 avcodec_free_context(&codec_ctx);
 avformat_free_context(format_ctx);
 return;
 }


I tried the solution that @philipp suggested in ffmpeg-avcodec-open2-returns-invalid-argument but it didn't resolve my error.


I don't know what's causing this error in my code, can someone please help me ?


Syndiquer tout le site
