Recherche avancée

Sur d’autres sites (9967)

• compile ffmpeg decode only without audio codecs

  28 juillet 2016, par Rob

  I work on a media manager and use ffmpeg.exe to extract screenshots.
  With the latest size of ffmpeg.exe exceeding 35MB, I am attempting to build ffmpeg without the majority of its functions, to allow only saving of a frame of video.

  I had thought disabling many of the filters, Audio Codecs etc would shrink the size of ffmpeg to something more manageable.

  Following this guide
  https://pracucci.com/compile-ffmpeg-on-windows-with-visual-studio-compiler.html
  to allow building of ffmpeg using Visual Studio 2015, I have come to the part of ./configuration and hit a wall.
  With so many options and no idea what all of them mean or do, I am asking if someone in the community can give me laymans instructions.

  I also know that I need to build x264, and possible x265 (HEVC), but am not sure if there is anything other codecs needed.
  In the end, I and am hoping to just have the one file, ffmpeg.exe for use in the media manager project.

  The code I use to get a screenshot is as follows

  Public Shared Function CreateScreenShot(ByVal FullPathAndFilename As String, ByVal SavePath As String, ByVal sec As Integer, Optional ByVal Overwrite As Boolean = False) As Boolean
  
      If Not File.Exists(SavePath) Or Overwrite Then
  
          Try
  
              IO.File.Delete(SavePath)
  
          Catch
  
              Return False
  
          End Try
  
          If IO.File.Exists(FullPathAndFilename) Then
  
              Dim myProcess As Process = New Process
  
              Try
  
                  Dim seconds As Integer = sec
  
                  myProcess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden
  
                  myProcess.StartInfo.CreateNoWindow = False
  
                  myProcess.StartInfo.FileName = Utilities.applicationPath & "\Assets\ffmpeg.exe"
  
                  Dim proc_arguments As String = "-ss " & seconds.ToString & " -i """ & FullPathAndFilename & """ -vframes:v 1 -an " & """" & SavePath & """"
  
                  myProcess.StartInfo.Arguments = proc_arguments
  
                  myProcess.Start()
  
                  myProcess.WaitForExit()
  
                  If File.Exists(SavePath) Then Return True
  
              Catch ex As Exception
  
                  Throw ex
  
              Finally
  
                  myProcess.Close()
  
              End Try
  
          End If
  
      End If
  
      Return False
  
  End Function

  I hope this is sufficient information, and appreciated any help or suggestions.

• Could not open encoder using ffmpeg C APi for MOV format

  22 juin 2016, par lupod

  Context

  I am writing a program for doing some video processing on an input file. I wrote two classes for handling the "reading/writing frames" part that essentially wrap the functions of ffmpeg. These classes may be instantiated by providing an input and output file name, and in their constructor I initialize everything that is needed (or at least I hope so).

  This are the two routines that are called inside the constructors :

  // InputVideoHandler.cpp
  
  void InputVideoHandler::init(char* name) {
  
    streamIndex = -1;
  
    int numStreams;
  
  
  
    if (avformat_open_input(&formatCtx, name, NULL, NULL) != 0)
  
      throw std::exception("Invalid input file name.");
  
  
  
    if (avformat_find_stream_info(formatCtx, NULL)<0)
  
      throw std::exception("Could not find stream information.");
  
  
  
    numStreams = formatCtx->nb_streams;
  
  
  
    if (numStreams < 0)
  
      throw std::exception("No streams in input video file.");
  
  
  
    for (int i = 0; i < numStreams; i++) {
  
      if (formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
  
        streamIndex = i;
  
        break;
  
      }
  
    }
  
  
  
    if (streamIndex < 0)
  
      throw std::exception("No video stream in input video file.");
  
  
  
    // find decoder using id
  
    codec = avcodec_find_decoder(formatCtx->streams[streamIndex]->codec->codec_id);
  
    if (codec == nullptr)
  
      throw std::exception("Could not find suitable decoder for input file.");
  
  
  
    // copy context from input stream
  
    codecCtx = avcodec_alloc_context3(codec);
  
    if (avcodec_copy_context(codecCtx, formatCtx->streams[streamIndex]->codec) != 0)
  
      throw std::exception("Could not copy codec context from input stream.");
  
  
  
    if (avcodec_open2(codecCtx, codec, NULL) < 0)
  
      throw std::exception("Could not open decoder.");
  
  
  
    codecCtx->refcounted_frames = 1;
  
  }
  
  
  
  // OutputVideoBuilder.cpp
  
  void OutputVideoBuilder::init(char* name, AVCodecContext* inputCtx) {
  
    if (avformat_alloc_output_context2(&formatCtx, NULL, NULL, name) < 0)
  
      throw std::exception("Could not determine file extension from provided name.");
  
  
  
    codec = avcodec_find_encoder(inputCtx->codec_id);
  
    if (codec == nullptr) {
  
      throw std::exception("Could not find suitable encoder.");
  
    }
  
  
  
    codecCtx = avcodec_alloc_context3(codec);
  
    if (avcodec_copy_context(codecCtx, inputCtx) < 0)
  
      throw std::exception("Could not copy output codec context from input");
  
  
  
    codecCtx->time_base = inputCtx->time_base;
  
  
  
    if (avcodec_open2(codecCtx, codec, NULL) < 0)
  
      throw std::exception("Could not open encoder.");
  
  
  
    stream = avformat_new_stream(formatCtx, codec);
  
    if (stream == nullptr) {
  
      throw std::exception("Could not allocate stream.");
  
    }
  
  
  
    stream->id = formatCtx->nb_streams - 1;
  
    stream->codec = codecCtx;
  
    stream->time_base = codecCtx->time_base;
  
  
  
    av_dump_format(formatCtx, 0, name, 1);
  
    if (!(formatCtx->oformat->flags & AVFMT_NOFILE)) {
  
      if (avio_open(&formatCtx->pb, name, AVIO_FLAG_WRITE) < 0) {
  
        throw std::exception("Could not open output file.");
  
      }
  
    }
  
  
  
    if (avformat_write_header(formatCtx, NULL) < 0) {
  
      throw std::exception("Error occurred when opening output file.");
  
    }
  
  
  
  }

  As you see, for the Init function of the output handler I require that an AVCodecContext must be provided. In my code, I pass to the constructor the AVCodecContext that is stored in the input handler and that was previously created.

  Question :

  The two functions work fine when I test my program with some video formats, like .mpg or .avi. When I try to process .mov/.mp4 files, however, my code throws the exception that I labeled "Could not open encoder." in OutputVideoBuilder::Init(). Why is this happening ? I read from the General documentation of ffmpeg that that format should be supported as well by ffmpeg. I am assuming that I am doing something wrong in my code, which I do not completely understand because it was created by trying to adapt the tutorials of the documentation to my specific case. Also for this reason, any comments on things that are useless or things that are missing will be greatly appreciated.

• Losing quality when encoding with ffmpeg

  22 mai 2016, par lupod

  I am using the c libraries of ffmpeg to read frames from a video and create an output file that is supposed to be identical to the input.
  However, somewhere during this process some quality gets lost and the result is "less sharp". My guess is that the problem is the encoding and that the frames are too compressed (also because the size of the file decreases quite significantly). Is there some parameter in the encoder that allows me to control the quality of the result ? I found that AVCodecContext has a compression_level member, but changing it that does not seem to have any effect.

  I post here part of my code in case it could help. I would say that something must be changed in the init function of OutputVideoBuilder when I set the codec. The AVCodecContext that is passed to the method is the same of InputVideoHandler.
  Here are the two main classes that I created to wrap the ffmpeg functionalities :

  // This class opens the video files and sets the decoder
  
  class InputVideoHandler {
  
  public:
  
    InputVideoHandler(char* name);
  
    ~InputVideoHandler();
  
    AVCodecContext* getCodecContext();
  
    bool readFrame(AVFrame* frame, int* success);
  
  
  
  private:
  
    InputVideoHandler();
  
    void init(char* name);
  
    AVFormatContext* formatCtx;
  
    AVCodec* codec;
  
    AVCodecContext* codecCtx;
  
    AVPacket packet;
  
    int streamIndex;
  
  };
  
  
  
  void InputVideoHandler::init(char* name) {
  
    streamIndex = -1;
  
    int numStreams;
  
  
  
    if (avformat_open_input(&formatCtx, name, NULL, NULL) != 0)
  
      throw std::exception("Invalid input file name.");
  
  
  
    if (avformat_find_stream_info(formatCtx, NULL)<0)
  
      throw std::exception("Could not find stream information.");
  
  
  
    numStreams = formatCtx->nb_streams;
  
  
  
    if (numStreams < 0)
  
      throw std::exception("No streams in input video file.");
  
  
  
    for (int i = 0; i < numStreams; i++) {
  
      if (formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
  
        streamIndex = i;
  
        break;
  
      }
  
    }
  
  
  
    if (streamIndex < 0)
  
      throw std::exception("No video stream in input video file.");
  
  
  
    // find decoder using id
  
    codec = avcodec_find_decoder(formatCtx->streams[streamIndex]->codec->codec_id);
  
    if (codec == nullptr)
  
      throw std::exception("Could not find suitable decoder for input file.");
  
  
  
    // copy context from input stream
  
    codecCtx = avcodec_alloc_context3(codec);
  
    if (avcodec_copy_context(codecCtx, formatCtx->streams[streamIndex]->codec) != 0)
  
      throw std::exception("Could not copy codec context from input stream.");
  
  
  
    if (avcodec_open2(codecCtx, codec, NULL) < 0)
  
      throw std::exception("Could not open decoder.");
  
  }
  
  
  
  // frame must be initialized with av_frame_alloc() before!
  
  // Returns true if there are other frames, false if not.
  
  // success == 1 if frame is valid, 0 if not.
  
  bool InputVideoHandler::readFrame(AVFrame* frame, int* success) {
  
    *success = 0;
  
    if (av_read_frame(formatCtx, &packet) < 0)
  
      return false;
  
    if (packet.stream_index == streamIndex) {
  
      avcodec_decode_video2(codecCtx, frame, success, &packet);
  
    }
  
    av_free_packet(&packet);
  
    return true;
  
  }
  
  
  
  // This class opens the output and write frames to it
  
  class OutputVideoBuilder{
  
  public:
  
    OutputVideoBuilder(char* name, AVCodecContext* inputCtx);
  
    ~OutputVideoBuilder();
  
    void writeFrame(AVFrame* frame);
  
    void writeVideo();
  
  
  
  private:
  
    OutputVideoBuilder();
  
    void init(char* name, AVCodecContext* inputCtx);
  
    void logMsg(AVPacket* packet, AVRational* tb);
  
    AVFormatContext* formatCtx;
  
    AVCodec* codec;
  
    AVCodecContext* codecCtx;
  
    AVStream* stream;
  
  };
  
  
  
  void OutputVideoBuilder::init(char* name, AVCodecContext* inputCtx) {
  
    if (avformat_alloc_output_context2(&formatCtx, NULL, NULL, name) < 0)
  
      throw std::exception("Could not determine file extension from provided name.");
  
  
  
    codec = avcodec_find_encoder(inputCtx->codec_id);
  
    if (codec == nullptr) {
  
      throw std::exception("Could not find suitable encoder.");
  
    }
  
  
  
    codecCtx = avcodec_alloc_context3(codec);
  
    if (avcodec_copy_context(codecCtx, inputCtx) < 0)
  
      throw std::exception("Could not copy output codec context from input");
  
  
  
    codecCtx->time_base = inputCtx->time_base;
  
    codecCtx->compression_level = 0;
  
  
  
    if (avcodec_open2(codecCtx, codec, NULL) < 0)
  
      throw std::exception("Could not open encoder.");
  
  
  
    stream = avformat_new_stream(formatCtx, codec);
  
    if (stream == nullptr) {
  
      throw std::exception("Could not allocate stream.");
  
    }
  
  
  
    stream->id = formatCtx->nb_streams - 1;
  
    stream->codec = codecCtx;
  
    stream->time_base = codecCtx->time_base;
  
  
  
  
  
  
  
    av_dump_format(formatCtx, 0, name, 1);
  
    if (!(formatCtx->oformat->flags & AVFMT_NOFILE)) {
  
      if (avio_open(&formatCtx->pb, name, AVIO_FLAG_WRITE) < 0) {
  
        throw std::exception("Could not open output file.");
  
      }
  
    }
  
  
  
    if (avformat_write_header(formatCtx, NULL) < 0) {
  
      throw std::exception("Error occurred when opening output file.");
  
    }
  
  
  
  }
  
  
  
  void OutputVideoBuilder::writeFrame(AVFrame* frame) {
  
    AVPacket packet = { 0 };
  
    int success;
  
    av_init_packet(&packet);
  
  
  
    if (avcodec_encode_video2(codecCtx, &packet, frame, &success))
  
      throw std::exception("Error encoding frames");
  
  
  
    if (success) {
  
      av_packet_rescale_ts(&packet, codecCtx->time_base, stream->time_base);
  
      packet.stream_index = stream->index;
  
      logMsg(&packet,&stream->time_base);
  
      av_interleaved_write_frame(formatCtx, &packet);
  
    }
  
    av_free_packet(&packet);
  
  }

  This is the part of the main function that reads and write frames :

   while (inputHandler->readFrame(frame,&gotFrame)) {
  
  
  
      if (gotFrame) {
  
        try {
  
          outputBuilder->writeFrame(frame);
  
        }
  
        catch (std::exception e) {
  
          std::cout << e.what() << std::endl;
  
          return -1;
  
        }
  
      }
  
    }