Recherche avancée
Médias (91)
-
999,999
26 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
The Slip - Artworks
26 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Texte
-
Demon seed (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
The four of us are dying (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Corona radiata (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Lights in the sky (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
Autres articles (49)
-
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 (...) -
Multilang : améliorer l’interface pour les blocs multilingues
18 février 2011, parMultilang est un plugin supplémentaire qui n’est pas activé par défaut lors de l’initialisation de MediaSPIP.
Après son activation, une préconfiguration est mise en place automatiquement par MediaSPIP init permettant à la nouvelle fonctionnalité d’être automatiquement opérationnelle. Il n’est donc pas obligatoire de passer par une étape de configuration pour cela. -
Le plugin : Gestion de la mutualisation
2 mars 2010, parLe plugin de Gestion de mutualisation permet de gérer les différents canaux de mediaspip depuis un site maître. Il a pour but de fournir une solution pure SPIP afin de remplacer cette ancienne solution.
Installation basique
On installe les fichiers de SPIP sur le serveur.
On ajoute ensuite le plugin "mutualisation" à la racine du site comme décrit ici.
On customise le fichier mes_options.php central comme on le souhaite. Voilà pour l’exemple celui de la plateforme mediaspip.net :
< ?php (...)
Sur d’autres sites (4354)
-
ffmpeg error "Could not allocate picture : Invalid argument Found Video Stream Found Audio Stream"
26 octobre 2020, par DinkanI am trying to write a C program to stream AV by copying both AV codecs with
rtp_mpegtsusing RTP over network

ffmpeg -re -i Sample_AV_15min.ts -acodec copy -vcodec copy -f rtp_mpegts rtp://192.168.1.1:5004


using muxing.c as example which used ffmpeg libraries.
ffmpeg application works fine.


Stream details


Input #0, mpegts, from 'Weather_Nation_10min.ts':
 Duration: 00:10:00.38, start: 41313.400811, bitrate: 2840 kb/s
 Program 1
 Stream #0:0[0x11]: Video: h264 (High) ([27][0][0][0] / 0x001B), yuv420p, 1440x1080 [SAR 4:3 DAR 16:9], 29.97 fps, 59.94 tbr, 90k tbn, 59.94 tbc
 Stream #0:1[0x14]: Audio: ac3 (AC-3 / 0x332D4341), 48000 Hz, stereo, fltp, 448 kb/s
Output #0, rtp_mpegts, to 'rtp://192.168.1.1:5004':
 Metadata:
 encoder : Lavf54.63.104
 Stream #0:0: Video: h264 ([27][0][0][0] / 0x001B), yuv420p, 1440x1080 [SAR 4:3 DAR 16:9], q=2-31, 29.97 fps, 90k tbn, 29.97 tbc
 Stream #0:1: Audio: ac3 (AC-3 / 0x332D4341), 48000 Hz, stereo, 448 kb/s
Stream mapping:
 Stream #0:0 -> #0:0 (copy)
 Stream #0:1 -> #0:1 (copy)


However, my application fails with


./my_test_app Sample_AV_15min.ts rtp://192.168.1.1:5004 
[h264 @ 0x800b30] non-existing PPS referenced 
[h264 @ 0x800b30] non-existing PPS 0 referenced 
[h264 @ 0x800b30] decode_slice_header error 
[h264 @ 0x800b30] no frame! 

[....snipped...]
[h264 @ 0x800b30] non-existing PPS 0 referenced 
[h264 @ 0x800b30] non-existing PPS referenced 
[h264 @ 0x800b30] non-existing PPS 0 referenced 
[h264 @ 0x800b30] decode_slice_header error 
[h264 @ 0x800b30] no frame! 
[h264 @ 0x800b30] mmco: unref short failure 
[h264 @ 0x800b30] mmco: unref short failure

[mpegts @ 0x800020] max_analyze_duration 5000000 reached at 5024000 microseconds 
[mpegts @ 0x800020] PES packet size mismatch could not find codec tag for codec id 
17075200, default to 0. could not find codec tag for codec id 86019, default to 0. 
Could not allocate picture: Invalid argument 
Found Video Stream Found Audio Stream


How do I fix this ? My complete source code based on muxing.c


/**
 * @file
 * libavformat API example.
 *
 * Output a media file in any supported libavformat format.
 * The default codecs are used.
 * @example doc/examples/muxing.c
 */

#include 
#include 
#include 
#include 

#include <libavutil></libavutil>mathematics.h>
#include <libavformat></libavformat>avformat.h>
#include <libswscale></libswscale>swscale.h>

/* 5 seconds stream duration */
#define STREAM_DURATION 200.0
#define STREAM_FRAME_RATE 25 /* 25 images/s */
#define STREAM_NB_FRAMES ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
#define STREAM_PIX_FMT AV_PIX_FMT_YUV420P /* default pix_fmt */

static int sws_flags = SWS_BICUBIC;

/**************************************************************/
/* audio output */

static float t, tincr, tincr2;
static int16_t *samples;
static int audio_input_frame_size;
#if 0
/* Add an output stream. */
static AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
 enum AVCodecID codec_id)
{
 AVCodecContext *c;
 AVStream *st;

 /* find the encoder */
 *codec = avcodec_find_encoder(codec_id);
 if (!(*codec)) {
 fprintf(stderr, "Could not find encoder for '%s'\n",
 avcodec_get_name(codec_id));
 exit(1);
 }

 st = avformat_new_stream(oc, *codec);
 if (!st) {
 fprintf(stderr, "Could not allocate stream\n");
 exit(1);
 }
 st->id = oc->nb_streams-1;
 c = st->codec;

 switch ((*codec)->type) {
 case AVMEDIA_TYPE_AUDIO:
 st->id = 1;
 c->sample_fmt = AV_SAMPLE_FMT_S16;
 c->bit_rate = 64000;
 c->sample_rate = 44100;
 c->channels = 2;
 break;

 case AVMEDIA_TYPE_VIDEO:
 c->codec_id = codec_id;

 c->bit_rate = 400000;
 /* Resolution must be a multiple of two. */
 c->width = 352;
 c->height = 288;
 /* timebase: This is the fundamental unit of time (in seconds) in terms
 * of which frame timestamps are represented. For fixed-fps content,
 * timebase should be 1/framerate and timestamp increments should be
 * identical to 1. */
 c->time_base.den = STREAM_FRAME_RATE;
 c->time_base.num = 1;
 c->gop_size = 12; /* emit one intra frame every twelve frames at most */
 c->pix_fmt = STREAM_PIX_FMT;
 if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
 /* just for testing, we also add B frames */
 c->max_b_frames = 2;
 }
 if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
 /* Needed to avoid using macroblocks in which some coeffs overflow.
 * This does not happen with normal video, it just happens here as
 * the motion of the chroma plane does not match the luma plane. */
 c->mb_decision = 2;
 }
 break;

 default:
 break;
 }

 /* Some formats want stream headers to be separate. */
 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 c->flags |= CODEC_FLAG_GLOBAL_HEADER;

 return st;
}
#endif 
/**************************************************************/
/* audio output */

static float t, tincr, tincr2;
static int16_t *samples;
static int audio_input_frame_size;

static void open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st)
{
 AVCodecContext *c;
 int ret;

 c = st->codec;

 /* open it */
 ret = avcodec_open2(c, codec, NULL);
 if (ret < 0) {
 fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
 exit(1);
 }

 /* init signal generator */
 t = 0;
 tincr = 2 * M_PI * 110.0 / c->sample_rate;
 /* increment frequency by 110 Hz per second */
 tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;

 if (c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)
 audio_input_frame_size = 10000;
 else
 audio_input_frame_size = c->frame_size;
 samples = av_malloc(audio_input_frame_size *
 av_get_bytes_per_sample(c->sample_fmt) *
 c->channels);
 if (!samples) {
 fprintf(stderr, "Could not allocate audio samples buffer\n");
 exit(1);
 }
}

/* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
 * 'nb_channels' channels. */
static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
{
 int j, i, v;
 int16_t *q;

 q = samples;
 for (j = 0; j < frame_size; j++) {
 v = (int)(sin(t) * 10000);
 for (i = 0; i < nb_channels; i++)
 *q++ = v;
 t += tincr;
 tincr += tincr2;
 }
}

static void write_audio_frame(AVFormatContext *oc, AVStream *st)
{
 AVCodecContext *c;
 AVPacket pkt = { 0 }; // data and size must be 0;
 AVFrame *frame = avcodec_alloc_frame();
 int got_packet, ret;

 av_init_packet(&pkt);
 c = st->codec;

 get_audio_frame(samples, audio_input_frame_size, c->channels);
 frame->nb_samples = audio_input_frame_size;
 avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
 (uint8_t *)samples,
 audio_input_frame_size *
 av_get_bytes_per_sample(c->sample_fmt) *
 c->channels, 1);

 ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
 if (ret < 0) {
 fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
 exit(1);
 }

 if (!got_packet)
 return;

 pkt.stream_index = st->index;

 /* Write the compressed frame to the media file. */
 ret = av_interleaved_write_frame(oc, &pkt);
 if (ret != 0) {
 fprintf(stderr, "Error while writing audio frame: %s\n",
 av_err2str(ret));
 exit(1);
 }
 avcodec_free_frame(&frame);
}

static void close_audio(AVFormatContext *oc, AVStream *st)
{
 avcodec_close(st->codec);

 av_free(samples);
}

/**************************************************************/
/* video output */

static AVFrame *frame;
static AVPicture src_picture, dst_picture;
static int frame_count;

static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
{
 int ret;
 AVCodecContext *c = st->codec;

 /* open the codec */
 ret = avcodec_open2(c, codec, NULL);
 if (ret < 0) {
 fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
 exit(1);
 }

 /* allocate and init a re-usable frame */
 frame = avcodec_alloc_frame();
 if (!frame) {
 fprintf(stderr, "Could not allocate video frame\n");
 exit(1);
 }

 /* Allocate the encoded raw picture. */
 ret = avpicture_alloc(&dst_picture, c->pix_fmt, c->width, c->height);
 if (ret < 0) {
 fprintf(stderr, "Could not allocate picture: %s\n", av_err2str(ret));
 exit(1);
 }

 /* If the output format is not YUV420P, then a temporary YUV420P
 * picture is needed too. It is then converted to the required
 * output format. */
 if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 ret = avpicture_alloc(&src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
 if (ret < 0) {
 fprintf(stderr, "Could not allocate temporary picture: %s\n",
 av_err2str(ret));
 exit(1);
 }
 }

 /* copy data and linesize picture pointers to frame */
 *((AVPicture *)frame) = dst_picture;
}

/* Prepare a dummy image. */
static void fill_yuv_image(AVPicture *pict, int frame_index,
 int width, int height)
{
 int x, y, i;

 i = frame_index;

 /* Y */
 for (y = 0; y < height; y++)
 for (x = 0; x < width; x++)
 pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;

 /* Cb and Cr */
 for (y = 0; y < height / 2; y++) {
 for (x = 0; x < width / 2; x++) {
 pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
 pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
 }
 }
}

static void write_video_frame(AVFormatContext *oc, AVStream *st)
{
 int ret;
 static struct SwsContext *sws_ctx;
 AVCodecContext *c = st->codec;

 if (frame_count >= STREAM_NB_FRAMES) {
 /* No more frames to compress. The codec has a latency of a few
 * frames if using B-frames, so we get the last frames by
 * passing the same picture again. */
 } else {
 if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 /* as we only generate a YUV420P picture, we must convert it
 * to the codec pixel format if needed */
 if (!sws_ctx) {
 sws_ctx = sws_getContext(c->width, c->height, AV_PIX_FMT_YUV420P,
 c->width, c->height, c->pix_fmt,
 sws_flags, NULL, NULL, NULL);
 if (!sws_ctx) {
 fprintf(stderr,
 "Could not initialize the conversion context\n");
 exit(1);
 }
 }
 fill_yuv_image(&src_picture, frame_count, c->width, c->height);
 sws_scale(sws_ctx,
 (const uint8_t * const *)src_picture.data, src_picture.linesize,
 0, c->height, dst_picture.data, dst_picture.linesize);
 } else {
 fill_yuv_image(&dst_picture, frame_count, c->width, c->height);
 }
 }

 if (oc->oformat->flags & AVFMT_RAWPICTURE) {
 /* Raw video case - directly store the picture in the packet */
 AVPacket pkt;
 av_init_packet(&pkt);

 pkt.flags |= AV_PKT_FLAG_KEY;
 pkt.stream_index = st->index;
 pkt.data = dst_picture.data[0];
 pkt.size = sizeof(AVPicture);

 ret = av_interleaved_write_frame(oc, &pkt);
 } else {
 /* encode the image */
 AVPacket pkt;
 int got_output;

 av_init_packet(&pkt);
 pkt.data = NULL; // packet data will be allocated by the encoder
 pkt.size = 0;

 ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
 if (ret < 0) {
 fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
 exit(1);
 }

 /* If size is zero, it means the image was buffered. */
 if (got_output) {
 if (c->coded_frame->key_frame)
 pkt.flags |= AV_PKT_FLAG_KEY;

 pkt.stream_index = st->index;

 /* Write the compressed frame to the media file. */
 ret = av_interleaved_write_frame(oc, &pkt);
 } else {
 ret = 0;
 }
 }
 if (ret != 0) {
 fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
 exit(1);
 }
 frame_count++;
}

static void close_video(AVFormatContext *oc, AVStream *st)
{
 avcodec_close(st->codec);
 av_free(src_picture.data[0]);
 av_free(dst_picture.data[0]);
 av_free(frame);
}

/**************************************************************/
/* media file output */

int main(int argc, char **argv)
{
 const char *filename;
 AVOutputFormat *fmt;
 AVFormatContext *oc;
 AVStream *audio_st, *video_st;
 AVCodec *audio_codec, *video_codec;
 double audio_pts, video_pts;
 int ret;
 char errbuf[50];
 int i = 0;
 /* Initialize libavcodec, and register all codecs and formats. */
 av_register_all();

 if (argc != 3) {
 printf("usage: %s input_file out_file|stream\n"
 "API example program to output a media file with libavformat.\n"
 "This program generates a synthetic audio and video stream, encodes and\n"
 "muxes them into a file named output_file.\n"
 "The output format is automatically guessed according to the file extension.\n"
 "Raw images can also be output by using '%%d' in the filename.\n"
 "\n", argv[0]);
 return 1;
 }

 filename = argv[2];

 /* allocate the output media context */
 avformat_alloc_output_context2(&oc, NULL, "rtp_mpegts", filename);
 if (!oc) {
 printf("Could not deduce output format from file extension: using MPEG.\n");
 avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
 }
 if (!oc) {
 return 1;
 }
 fmt = oc->oformat;
 //Find input stream info.

 video_st = NULL;
 audio_st = NULL;

 avformat_open_input( &oc, argv[1], 0, 0);

 if ((ret = avformat_find_stream_info(oc, 0))< 0)
 {
 av_strerror(ret, errbuf,sizeof(errbuf));
 printf("Not Able to find stream info::%s ", errbuf);
 ret = -1;
 return ret;
 }
 for (i = 0; i < oc->nb_streams; i++)
 {
 if(oc->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
 {
 AVCodecContext *codec_ctx;
 unsigned int tag = 0;

 printf("Found Video Stream ");
 video_st = oc->streams[i];
 codec_ctx = video_st->codec;
 // m_num_frames = oc->streams[i]->nb_frames;
 video_codec = avcodec_find_decoder(codec_ctx->codec_id);
 ret = avcodec_open2(codec_ctx, video_codec, NULL);
 if (ret < 0) 
 {
 av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
 return ret;
 }
 if (av_codec_get_tag2(oc->oformat->codec_tag, video_codec->id, &tag) == 0) 
 {
 av_log(NULL, AV_LOG_ERROR, "could not find codec tag for codec id %d, default to 0.\n", audio_codec->id);
 }
 video_st->codec = avcodec_alloc_context3(video_codec);
 video_st->codec->codec_tag = tag;
 }

 if(oc->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
 {
 AVCodecContext *codec_ctx;
 unsigned int tag = 0;

 printf("Found Audio Stream ");
 audio_st = oc->streams[i];
 // aud_dts = audio_st->cur_dts;
 // aud_pts = audio_st->last_IP_pts; 
 codec_ctx = audio_st->codec;
 audio_codec = avcodec_find_decoder(codec_ctx->codec_id);
 ret = avcodec_open2(codec_ctx, audio_codec, NULL);
 if (ret < 0) 
 {
 av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
 return ret;
 }
 if (av_codec_get_tag2(oc->oformat->codec_tag, audio_codec->id, &tag) == 0) 
 {
 av_log(NULL, AV_LOG_ERROR, "could not find codec tag for codec id %d, default to 0.\n", audio_codec->id);
 }
 audio_st->codec = avcodec_alloc_context3(audio_codec);
 audio_st->codec->codec_tag = tag;
 }
 }
 /* Add the audio and video streams using the default format codecs
 * and initialize the codecs. */
 /*
 if (fmt->video_codec != AV_CODEC_ID_NONE) {
 video_st = add_stream(oc, &video_codec, fmt->video_codec);
 }
 if (fmt->audio_codec != AV_CODEC_ID_NONE) {
 audio_st = add_stream(oc, &audio_codec, fmt->audio_codec);
 }
 */

 /* Now that all the parameters are set, we can open the audio and
 * video codecs and allocate the necessary encode buffers. */
 if (video_st)
 open_video(oc, video_codec, video_st);
 if (audio_st)
 open_audio(oc, audio_codec, audio_st);

 av_dump_format(oc, 0, filename, 1);

 /* open the output file, if needed */
 if (!(fmt->flags & AVFMT_NOFILE)) {
 ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
 if (ret < 0) {
 fprintf(stderr, "Could not open '%s': %s\n", filename,
 av_err2str(ret));
 return 1;
 }
 }

 /* Write the stream header, if any. */
 ret = avformat_write_header(oc, NULL);
 if (ret < 0) {
 fprintf(stderr, "Error occurred when opening output file: %s\n",
 av_err2str(ret));
 return 1;
 }

 if (frame)
 frame->pts = 0;
 for (;;) {
 /* Compute current audio and video time. */
 if (audio_st)
 audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
 else
 audio_pts = 0.0;

 if (video_st)
 video_pts = (double)video_st->pts.val * video_st->time_base.num /
 video_st->time_base.den;
 else
 video_pts = 0.0;

 if ((!audio_st || audio_pts >= STREAM_DURATION) &&
 (!video_st || video_pts >= STREAM_DURATION))
 break;

 /* write interleaved audio and video frames */
 if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
 write_audio_frame(oc, audio_st);
 } else {
 write_video_frame(oc, video_st);
 frame->pts += av_rescale_q(1, video_st->codec->time_base, video_st->time_base);
 }
 }

 /* Write the trailer, if any. The trailer must be written before you
 * close the CodecContexts open when you wrote the header; otherwise
 * av_write_trailer() may try to use memory that was freed on
 * av_codec_close(). */
 av_write_trailer(oc);

 /* Close each codec. */
 if (video_st)
 close_video(oc, video_st);
 if (audio_st)
 close_audio(oc, audio_st);

 if (!(fmt->flags & AVFMT_NOFILE))
 /* Close the output file. */
 avio_close(oc->pb);

 /* free the stream */
 avformat_free_context(oc);

 return 0;
}


-
lavc/pnm_parser : disable parsing for text based PNMs
27 juin 2016, par Clément Bœschlavc/pnm_parser : disable parsing for text based PNMs
P1, P2, and P3 are respectively the text versions of PBM, PGM and PPM
files.We can not obtain the buffer size using av_imgage_get_buffer_size() as
every pixel in the picture will occupy a random size between 16 and 32
bits ("4 " and "231 " are such example).Ideally, we could look for the next header (or EOF) in the bytestream,
but this commit is meant to fix a decoding regression introduced by
48ac4532d437790e56b8ed5d0d467dc88685f035.Fix Ticket #5670
-
Could NOT find FFmpeg (missing : swresample) (found version "56.1.0")
28 juin 2016, par sushiI try to install obs (Open Broadcaster Software) in my Kali Linux 2.
I follow this instruction. I have no problem until the obs building :
cmake -DUNIX_STRUCTURE=1 -DCMAKE_INSTALL_PREFIX=/usr ..Where I get this error :
Could NOT find FFmpeg (missing: swresample) (found version "56.1.0")I found this topic but I can’t use this command :
apt-get -t jessie-backports install libswresample-devBecause I am on Kali Linux.
This is the output of
ffmpegcommand :ffmpeg version N-79093-g7916f04 Copyright (c) 2000-2016 the FFmpeg developers
built with gcc 4.9.2 (Debian 4.9.2-10)
configuration: --prefix=/root/ffmpeg_build --pkg-config-flags=--static --extra-cflags=-I/root/ffmpeg_build/include --extra-ldflags=-L/root/ffmpeg_build/lib --bindir=/root/bin --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-libx265 --enable-nonfree
libavutil 55. 19.100 / 55. 19.100
libavcodec 57. 28.103 / 57. 28.103
libavformat 57. 28.102 / 57. 28.102
libavdevice 57. 0.101 / 57. 0.101
libavfilter 6. 39.102 / 6. 39.102
libswscale 4. 0.100 / 4. 0.100
libswresample 2. 0.101 / 2. 0.101
libpostproc 54. 0.100 / 54. 0.100
Hyper fast Audio and Video encoder
usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...
Use -h to get full help or, even better, run 'man ffmpeg'
Syndiquer tout le site
