Recherche avancée
Autres articles (97)
-
Configuration spécifique d’Apache
4 février 2011, parModules spécifiques
Pour la configuration d’Apache, il est conseillé d’activer certains modules non spécifiques à MediaSPIP, mais permettant d’améliorer les performances : mod_deflate et mod_headers pour compresser automatiquement via Apache les pages. Cf ce tutoriel ; mode_expires pour gérer correctement l’expiration des hits. Cf ce tutoriel ;
Il est également conseillé d’ajouter la prise en charge par apache du mime-type pour les fichiers WebM comme indiqué dans ce tutoriel.
Création d’un (...) -
Organiser par catégorie
17 mai 2013, parDans MédiaSPIP, une rubrique a 2 noms : catégorie et rubrique.
Les différents documents stockés dans MédiaSPIP peuvent être rangés dans différentes catégories. On peut créer une catégorie en cliquant sur "publier une catégorie" dans le menu publier en haut à droite ( après authentification ). Une catégorie peut être rangée dans une autre catégorie aussi ce qui fait qu’on peut construire une arborescence de catégories.
Lors de la publication prochaine d’un document, la nouvelle catégorie créée sera proposée (...) -
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 (...)
Sur d’autres sites (6636)
-
Online timelapse creation with ffmpeg
27 mai 2016, par MichaelI would like to create a timelapse using a command line tool like ffmpeg. The usual way is to prepare a series of images first. In my case it is not possible, because discrete images would take too much space, and there is nearly no difference between subsequent images so they compress extremely well as a video.
So I’m looking for a way to create a video file, keep it opened and then just append successive images to it without intermediate files.
-
Convert PNGs to webm video with transparency
20 septembre 2016, par sebastianI would like to use
avconvto convert a series of PNG images to a WebM video, preserving transparency.I understand that the pixel format used in the output video must support transparency. So I tried :
$ avconv -framerate 25 -f image2 -i frames/%03d.png -pix_fmt yuva420p output.webm
Unfortunately,
avconvcomplains :Incompatible pixel format 'yuva420p' for codec 'libvpx-vp9', auto-selecting format 'yuv420p'I am using
ffmpeg version 2.8.4-1+b1 Copyright (c) 2000-2015 the FFmpeg developers. -
FFmpeg : generating H264 video in c++
13 octobre 2015, par EZEROFIVE EMDIm using ffmpeg library in windows with vs2012 to convert a series of images into Mp4 with H264 encoding. Im new to FFMPEG.
Below is my code. Everything went fine. Video is created.But i can play the video in vlc player only if i changed the extension to ".h264", also when i check for codec information it says "H264 - MPEG-4 AVC (part 10) (h264)". but when i checked the same for other mp4 videos which are downloaded from web. it says "H264 - MPEG-4" AVC (part 10) (avc1)". I dont understand where it went wrong. Also i searched a lot, some says like add SPS and PPS.
const uint8_t sps[] = { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00,
0x0a, 0xf8, 0x41, 0xa2 };
const uint8_t pps[] = { 0x00, 0x00, 0x00, 0x01, 0x68, 0xce,
0x38, 0x80 };So i added the above value to video file before i add the image stream. But no luck.
Can anyone help on this..Thanks in advance.const uint8_t sps[] = { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00,
0x0a, 0xf8, 0x41, 0xa2 };
const uint8_t pps[] = { 0x00, 0x00, 0x00, 0x01, 0x68, 0xce,
0x38, 0x80 };
const uint8_t slice_header[] = { 0x00, 0x00, 0x00, 0x01, 0x05, 0x88,
0x84, 0x21, 0xa0 };
const uint8_t macroblock_header[] = { 0x0d, 0x00 };
const uint8_t spspps[] = { 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x0a, 0xf8, 0x41, 0xa2,
0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x38, 0x80
};
int ff_load_image(uint8_t *data[4], int linesize[4],
int *w, int *h, enum PixelFormat *pix_fmt,
const char *filename, void *log_ctx)
{
AVInputFormat *iformat = NULL;
AVFormatContext *format_ctx = NULL;
AVCodec *codec=NULL;
AVCodecContext *codec_ctx=NULL;
AVFrame *frame=NULL;
int frame_decoded, ret = 0;
AVPacket pkt;
av_register_all();
iformat = av_find_input_format("image2");
if ((ret = avformat_open_input(&format_ctx, filename, iformat, NULL)) < 0) {
return ret;
}
codec_ctx = format_ctx->streams[0]->codec;
codec = avcodec_find_decoder(codec_ctx->codec_id);
if (!codec) {
ret = AVERROR(EINVAL);
goto end;
}
if ((ret = avcodec_open2(codec_ctx, codec, NULL)) < 0) {
goto end;
}
//if (!(frame = avcodec_alloc_frame()) ) {
if (!(frame = av_frame_alloc()) ) {
ret = AVERROR(ENOMEM);
goto end;
}
ret = av_read_frame(format_ctx, &pkt);
if (ret < 0) {
goto end;
}
ret = avcodec_decode_video2(codec_ctx, frame, &frame_decoded, &pkt);
if (ret < 0 || !frame_decoded) {
goto end;
}
ret = 0;
*w = frame->width;
*h = frame->height;
*pix_fmt = (PixelFormat)frame->format;
if ((ret = av_image_alloc(data, linesize, *w, *h, (AVPixelFormat)*pix_fmt, 16)) < 0)
goto end;
ret = 0;
av_image_copy(data, linesize, (const uint8_t **)frame->data, frame->linesize, (AVPixelFormat)*pix_fmt, *w, *h);
end:
if(codec_ctx) { avcodec_close(codec_ctx); }
if(format_ctx) { avformat_close_input(&format_ctx); }
if(frame) { av_freep(&frame); }
av_free_packet(&pkt);
return ret;
}
int load_image_into_frame(AVFrame *frame, const char *filename)
{
int retval = -1, res;
static struct SwsContext *sws_ctx;
uint8_t *image_data[4];
int linesize[4];
int source_width, source_height;
enum PixelFormat source_fmt;
res = ff_load_image(image_data, linesize, &source_width, &source_height, &source_fmt, filename, NULL);
if (source_fmt != frame->format) {
sws_ctx = sws_getContext(source_width, source_height, (AVPixelFormat)source_fmt,
frame->width, frame->height, (AVPixelFormat)frame->format,
sws_flags, NULL, NULL, NULL);
sws_scale(sws_ctx,
(const uint8_t * const *)image_data, linesize,
0, frame->height, frame->data, frame->linesize);
}
retval = 0;
error:
av_freep(&image_data[0]);
sws_freeContext(sws_ctx);
return retval;
}
int write_frame_to_file(FILE *file, AVFrame *frame, AVCodecContext *codec_context, AVPacket *pkt) {
int res, got_output;
av_init_packet(pkt);
pkt->data = NULL;
pkt->size = 0;
/* generate synthetic video */
frame->pts += 30;
res = avcodec_encode_video2(codec_context, pkt, frame, &got_output);
if (got_output) {
fwrite(pkt->data, 1, pkt->size, file);
av_free_packet(pkt);
}
return 0;
error:
return -1;
}
int write_image_to_file(FILE *file, const char *filename, int count, AVFrame *frame, AVCodecContext *codec_context, AVPacket *pkt) {
int res, i;
res = load_image_into_frame(frame, filename);
for (i = 0; i < count; i++) {
res = write_frame_to_file(file, frame, codec_context, pkt);
}
return 0;
error:
return -1;
}
int write_delayed_frames_to_file(FILE *file, AVFrame *frame, AVCodecContext *codec_context, AVPacket *pkt) {
int res, got_output;
for (got_output = 1; got_output;) {
res = avcodec_encode_video2(codec_context, pkt, NULL, &got_output);
if (got_output) {
fwrite(pkt->data, 1, pkt->size, file);
av_free_packet(pkt);
}
}
return 0;
error:
return -1;
}
AVCodecContext *get_codec_context(int width, int height, int fps)
{
int res;
avcodec_register_all();
AVCodec *codec;
AVCodecContext *codec_context = NULL;
codec = avcodec_find_encoder(AV_CODEC_ID_H264);
codec_context = avcodec_alloc_context3(codec);
codec_context->bit_rate = 441000;
codec_context->width = width;
codec_context->height = height;
AVRational temp_113 = {1, fps};
AVRational temp_114 = {fps, 1};
codec_context->time_base= temp_113;
codec_context->gop_size = 10;
codec_context->max_b_frames=1;
codec_context->pix_fmt = AV_PIX_FMT_YUV420P;
res = avcodec_open2(codec_context, codec, NULL);
return codec_context;
error:
return NULL;
}
AVFrame *get_av_frame(AVCodecContext *codec_context) {
int res;
AVFrame *frame;
frame = av_frame_alloc();
frame->height = codec_context->height;
frame->width = codec_context->width;
frame->format = codec_context->pix_fmt;
frame->pts = 0;
res = av_image_alloc(frame->data, frame->linesize, frame->width, frame->height, (AVPixelFormat)frame->format, 1);
return frame;
error:
return NULL;
}
int main(int argc, char **argv)
{
const char *filename = "result video\\test.mp4";
FILE *file=NULL;
int res, retval=-1;
AVCodecContext *codec_context= NULL;
AVFrame *frame=NULL;
AVPacket pkt;
uint8_t endcode[] = { 0, 0, 1, 0xb7 };
codec_context = get_codec_context(1920, 1080, 30);
file = fopen(filename, "wb");
//check(file != NULL, "could not open destination file %s", filename);
frame = get_av_frame(codec_context);
//fwrite(sps, 1, sizeof(sps), file);
//fwrite(pps, 1, sizeof(pps), file);
/*codec_context->extradata = (uint8_t *)malloc(sizeof(uint8_t) * sizeof(spspps));
for(unsigned int index = 0; index < sizeof(spspps); index++)
{
codec_context->extradata[index] = spspps[index];
}
codec_context->extradata_size = (int)sizeof(spspps);*/
codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
int i, frames= 51;
for (i = 0; i < frames; i++) {
std::stringstream ss;
ss<<"\\frames\\out"<<( i + 1)<<".jpg";
res = write_image_to_file(file, ss.str().c_str(), 3, frame, codec_context, &pkt);
}
res = write_delayed_frames_to_file(file, frame, codec_context, &pkt);
fwrite(endcode, 1, sizeof(endcode), file);
retval = 0;
error:
if (file)
fclose(file);
if (codec_context) {
avcodec_close(codec_context);
av_free(codec_context);
}
if (frame) {
av_freep(&frame->data[0]);
av_free(frame);
}
return retval;
}
}
Syndiquer tout le site
