Recherche avancée

Sur d’autres sites (9612)

• ffmpeg - where to save the video I plan to cut to frames

  28 décembre 2017, par Kyle

  I have ffmpeg up and running on my computer.

  Now I am trying to cut a video into individual frames. The video is titled IMG_2299.MOV.

  I am using the following command :

  ffmpeg -i img_2299.mov $filename%12d.jpeg

  Two questions :
  1) where do I need the actual video saved for this to work ? In the same folder as the ff* executable files (/usr/loca/bin) ?
  2) And where will the images created be saved ?

  I can run the command above — but I don’t see any results.

  Thank you for any help you can offer.

• How can I save the h264 encoded video as a sequence of AVPacket-s to the file using libav c++ ?

  8 juillet 2023, par danvik13

  I'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 :

  


  

  1. [file @ 0000017a74c6c540] Setting default whitelist 'file,crypto,data'
I have some concers about the appropriateness of the whitelist as no crypto is expected

  


  2. [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.

  


• 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 Strongman

  Today... I used the following command : with subprocess.PIPE and subprocess.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 and overrun_fatal. I thought that maybe I can set fifo_size to be equal to NUM_WANTED_FRAMES, and overrun_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 ?