
Recherche avancée
Autres articles (64)
-
Demande de création d’un canal
12 mars 2010, parEn fonction de la configuration de la plateforme, l’utilisateur peu avoir à sa disposition deux méthodes différentes de demande de création de canal. La première est au moment de son inscription, la seconde, après son inscription en remplissant un formulaire de demande.
Les deux manières demandent les mêmes choses fonctionnent à peu près de la même manière, le futur utilisateur doit remplir une série de champ de formulaire permettant tout d’abord aux administrateurs d’avoir des informations quant à (...) -
MediaSPIP v0.2
21 juin 2013, parMediaSPIP 0.2 est la première version de MediaSPIP stable.
Sa date de sortie officielle est le 21 juin 2013 et est annoncée ici.
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Comme pour la version précédente, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...) -
MediaSPIP version 0.1 Beta
16 avril 2011, parMediaSPIP 0.1 beta est la première version de MediaSPIP décrétée comme "utilisable".
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Pour avoir une installation fonctionnelle, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...)
Sur d’autres sites (15424)
-
Revision 7af927e324 : Merge "vp9_ethread : calculate and save the tok starting address for tiles"
1er décembre 2014, par Yunqing WangMerge "vp9_ethread : calculate and save the tok starting address for tiles"
-
ffmpeg : What is the best practice to keep a live connection/socket with a camera, and save time on ffprobe
15 mai 2022, par Jeff StrongmanToday... I used the following command : with
subprocess.PIPE
andsubprocess.Popen
in python 3 :

ffmpeg -i udp://{address_of_camera} \
 -vf select='if(eq(pict_type,I),st(1,t),gt(t,ld(1)))' setpts=N/FRAME_RATE/TB \
 -f rawvideo -an -vframes {NUM_WANTED_FRAMES} pipe:`



This command helps me to capture
NUM_WANTED_FRAMES
frames from a live camera at a given moment.

However... it takes me about 4 seconds to read the frames, and about 2.5 seconds to open a socket between my computer and the camera's computer.


Is there a way, to have a socket/connection always open between my computer and the camera's computer, to save the 2.5 seconds ?


I read something about
fifo_size
andoverrun_fatal
. I thought that maybe I can setfifo_size
to be equal toNUM_WANTED_FRAMES
, andoverrun_fatal
to True ? Will this solve my problem ? Or is there a different and simpler/better solution ?

Should I try to record always (no
-vframes
flag) store the frames in a queue(With max size), and upon a wish to slice the video, read from my queue buffer ? Will it work well with the keyframe ?

Also... What to do when ffmpeg fails ? restart the ffmpeg command ?


-
How can I save the h264 encoded video as a sequence of AVPacket-s to the file using libav c++ ?
8 juillet 2023, par danvik13I'm trying to save video, which is generated and encoded on fly using libav (ffmpeg) functional. When I receive next non-empty AVPacket with encoded frame, I call writer.saveNextPacket() method.
Of cause, before saving, I properly init both codec and filewriter and close them in the very ending.
Here is some code :


#include "utils/FileWriter.h"

#define DEBUG 1

void tp::utils::FileWriter::open(const char* path, tp::encoders::IEncoder* encoder) {
 int hr;

 debI("guessing");
 format = av_guess_format(nullptr, path, nullptr);
 if (!format){
 debI("av_guess_format");
 }

 debI("allocating output");
 hr = avformat_alloc_output_context2(&formatContext, format, nullptr, nullptr);
 if (hr < 0){
 debI("avformat_alloc_output_context2", hr);
 }

 debI("allocating stream");
 stream = avformat_new_stream(formatContext, nullptr);
 if (!stream){
 debI("avformat_new_stream");
 }
 debI("setting parameters");
 AVCodecParameters* parameters = avcodec_parameters_alloc();
 hr = avcodec_parameters_from_context(parameters, encoder->getCodecContext());
 if (hr < 0){
 debI("avcodec_parameters_from_context", hr);
 }

 stream->codecpar = parameters;

 debI("opening");
 hr = avio_open(&formatContext->pb, path, AVIO_FLAG_WRITE);
 if (hr < 0){
 debI("avio_open", hr);
 }

 debI("writing headers");
 hr = avformat_write_header(formatContext, nullptr);
 if (hr < 0){
 debI("avformat_write_header", hr);
 }
 debI("writer is set");
}

#define DEBUG 0

void tp::utils::FileWriter::saveNextPacket(AVPacket* packet) {
 int hr;

 hr = av_interleaved_write_frame(formatContext, packet);
 if (hr < 0){
 logF("av_write_frame", hr);
 }
}

void tp::utils::FileWriter::close() {
 int hr;

 hr = av_write_trailer(formatContext);
 if (hr < 0){
 logF("av_write_trailer", hr);
 }

 hr = avio_close(formatContext->pb);
 if (hr < 0){
 logF("avio_close", hr);
 }

 avformat_free_context(formatContext);
}




Here is the setup part of the encoder :


codec = avcodec_find_encoder(AV_CODEC_ID_H264);
 if (!codec){
 logF("avcodec_find_encoder", hr);
 }
 codecContext = avcodec_alloc_context3(codec);
 if (!codecContext){
 logF("avcodec_alloc_context3");
 }
 codecContext->width = parameters.width;
 codecContext->height = parameters.height;
 codecContext->bit_rate = parameters.bitRate;
 codecContext->time_base = (AVRational){1, parameters.fps};
 codecContext->gop_size = 0;
 codecContext->max_b_frames = 0;
 codecContext->pix_fmt = AV_PIX_FMT_YUV420P;
 if (parameters.preset == EncoderParameters::Preset::Fast){
 av_opt_set(codecContext->priv_data, "preset", "ultrafast", 0);
 }else if (parameters.preset == EncoderParameters::Preset::Slow){
 av_opt_set(codecContext->priv_data, "preset", "slow", 0);
 }

 hr = avcodec_open2(codecContext, codec, nullptr);
 if (hr < 0){
 logF("avcodec_open2", hr);
 }



The problem : I open "output.mp4" file and assume that the class properly saves the header of the file. However, the file weights 262 bytes (there is no useful data such as frames) and it is corrupted for running video on any video players
ps : I've enabled libav logging, which seems to be ok, despite some messages :


- 

- [file @ 0000017a74c6c540] Setting default whitelist 'file,crypto,data'
I have some concers about the appropriateness of the whitelist as no crypto is expected
- [AVIOContext @ 0000017a6a249100] Statistics : 266 bytes written, 2 seeks, 3 writeouts
The actual size of the file is 262. Does it mean that there are some info leaking during saving and even the header is already broken ?






I've tried to adjust various codec settings. Even turning off any speed presets. Actually, the encoder was tested in the pair with various libav decoders and image rendering and I'm pretty sure about encoder part.
Moreover, I've written the FileWriter code three times as there are some dissimilar guides. Only the current code does not throw any warnings or errors.
Give me a hint, which part of code may be wrong or provide me with some samples of using latest ffmpeg and answer my questions, please.