Recherche avancée

Sur d’autres sites (5542)

• No frame decodes after upgrading from ffmpeg 1.1 to 3.3

  13 juin 2018, par M.Mahdipour

  I have a source code in C++ using libavcodec for decoding h264 rtsp stream frames. This source code was written using ffmpeg 1.1. Now when I upgraded to ffmpeg 3.3, all things seem to work correctly except that decoding frames not work.
  In old version, I was using avcodec_decode_video2. After upgrading, avcodec_decode_video2 always sets got_picture to 0 and return value is equal to the size of the input packet (which means all data is used). And never a frame is decoded.
  I have also removed avcodec_decode_video2 and done decoding with avcodec_send_packet and avcodec_receive_frame, but avcodec_send_packet always returns 0 and avcodec_receive_frame always returns -11 (EAGAIN).

  This is the code I use for decoding :

  #include "stdafx.h"
  
  #include 
  
  #include <string>
  
  #include <iostream>
  
  using namespace std;
  
  
  
  extern "C"{
  
  #include "libavformat/avformat.h"
  
  #include "libavcodec/avcodec.h"
  
  #include "libswscale/swscale.h"
  
  #include "libavutil/pixfmt.h"
  
  }
  
  
  
  int extraDataSize;
  
  static const int MaxExtraDataSize = 1024;
  
  uint8_t extraDataBuffer[MaxExtraDataSize];
  
  
  
  void AddExtraData(uint8_t* data, int size)
  
  {
  
      auto newSize = extraDataSize + size;
  
      if (newSize > MaxExtraDataSize){
  
          throw "extradata exceeds size limit";
  
      }
  
      memcpy(extraDataBuffer + extraDataSize, data, size);
  
      extraDataSize = newSize;
  
  }
  
  
  
  int _tmain(int argc, _TCHAR* argv[])
  
  {
  
      std::string strFramesPath("g:\\frames\\");
  
  
  
      AVCodec* avCodec;
  
      AVCodecContext* avCodecContext;
  
      AVFrame* avFrame;
  
      AVCodecID codecId = AV_CODEC_ID_H264;
  
      unsigned char sprops_part_1[9] = { 0x27, 0x42, 0x80, 0x1f, 0xda, 0x02, 0xd0, 0x49, 0x10 };
  
      unsigned char sprops_part_2[4] = { 0x28, 0xce, 0x3c, 0x80 };
  
  
  
      av_register_all();
  
      avcodec_register_all();
  
      avCodec = avcodec_find_decoder(codecId);
  
      avCodecContext = avcodec_alloc_context3(avCodec);
  
      if (!avCodecContext)
  
      {
  
          cout &lt;&lt; "avcodec_alloc_context3 failed." &lt;&lt; endl;
  
          return 0;
  
      }
  
      uint8_t startCode[] = { 0x00, 0x00, 0x01 };
  
  
  
      // sprops
  
      {
  
          // sprops 1
  
          AddExtraData(startCode, sizeof(startCode));
  
          AddExtraData(sprops_part_1, 9);
  
          // sprops 2
  
          AddExtraData(startCode, sizeof(startCode));
  
          AddExtraData(sprops_part_2, 4);
  
  
  
          avCodecContext->extradata = extraDataBuffer;
  
          avCodecContext->extradata_size = extraDataSize;
  
      }
  
  
  
      AddExtraData(startCode, sizeof(startCode));
  
      avCodecContext->flags = 0;
  
      if (avcodec_open2(avCodecContext, avCodec, NULL) &lt; 0)
  
      {
  
          cout &lt;&lt; "failed to open codec" &lt;&lt; endl;
  
          return 0;
  
      }
  
      avFrame = av_frame_alloc();
  
      if (!avFrame)
  
      {
  
          cout &lt;&lt; "failed to alloc frame" &lt;&lt; endl;
  
          return 0;
  
      }
  
  
  
      void *buffer = malloc(100 * 1024);  // 100 KB buffer - all frames fit in this buffer
  
      for (int nFrameIndex = 0; nFrameIndex &lt; 257; nFrameIndex++)
  
      {
  
          std::string strFilename = std::string("g:\\frames\\" + std::to_string(nFrameIndex));
  
          FILE* f = fopen(strFilename.c_str(), "rb");
  
          fseek(f, 0, SEEK_END);
  
          long nFileSize = ftell(f);
  
          fseek(f, 0, SEEK_SET);
  
          size_t nReadSize = fread(buffer, 1, nFileSize, f);
  
          // cout &lt;&lt; strFilename &lt;&lt; endl;
  
          if (nReadSize != nFileSize)
  
          {
  
              cout &lt;&lt; "Error reading file data" &lt;&lt; endl;
  
              continue;
  
          }
  
          AVPacket avpkt;
  
          avpkt.data = (uint8_t*)buffer;
  
          avpkt.size = nReadSize;
  
  
  
          while (avpkt.size > 0)
  
          {
  
              int got_frame = 0;
  
              auto len = avcodec_decode_video2(avCodecContext, avFrame, &amp;got_frame, &amp;avpkt);
  
              if (len &lt; 0) {
  
                  //TODO: log error
  
                  cout &lt;&lt; "Error decoding - error code: " &lt;&lt; len &lt;&lt; endl;
  
                  break;
  
              }
  
              if (got_frame)
  
              {
  
                  cout &lt;&lt; "* Got 1 Decoded Frame" &lt;&lt; endl;
  
              }
  
              avpkt.size -= len;
  
              avpkt.data += len;
  
          }
  
      }
  
  
  
      getchar();
  
      return 0;
  
  }
  
  </iostream></string>

  Test frames data can be downloaded from this link :
  Frames.zip ( 3.7MB)

  I have used windows builds from Builds - Zeranoe FFmpeg
  If you copy paste this code into your IDE, the code compiles successfully. Using libavcodec new versions, no frame is decoded. Using old version of libavcodec (20141216-git-92a596f), decoding starts when feed frame 2.

  Any ideas ?

• Catch if the Java process crashed

  10 mai 2018, par Victor Sheyanov

  I run java process to convert video using ffmpeg.exe.

  Runtime rt = Runtime.getRuntime();
  
  String cmd = FFMPEGFULLPATH + " -y -i " + '"' + mpeg4File + '"' + " -vcodec libx264 -vsync 2 " + '"' + H264file + '"';
  
  
  
  Process pr = rt.exec(cmd);
  
  
  
  ThreadedTranscoderIO errorHandler = new ThreadedTranscoderIO(pr.getErrorStream(), "Error Stream");
  
  errorHandler.start();
  
  ThreadedTranscoderIO inputHandler = new ThreadedTranscoderIO(pr.getInputStream(), "Output Stream");
  
  inputHandler.start();
  
  
  
  try {
  
        pr.waitFor();
  
  } catch (InterruptedException e) {
  
        LiveApplication.logger.info("Some shit happens during convertation 2 ");
  
        throw new IOException("UseTranscoderBlocking - Run_FFMPEG - process interrupted " + e);                  
  
  }

  But when the process started, sometimes especially with big files, but not always i get this windows message :

  

  This happens only on Windows server 2008 and didn’t happened on Windows 7.

  I have 2 questions :

  1. Why this process fails ?
  2. Can I catch this fail in Java, close
     this window and continue thread execution (maybe I’ll restart this
     proccess).

• C++ ffmpeg video missing frames and won't play in Quicktime

  5 décembre 2019, par Oliver Dain

  I wrote some C++ code that uses ffmpeg to encode a video. I’m having two strange issues :

  1. The final video is always missing 1 frame. That is, if I have it encode 10 frames the final video only has 9 (at least that’s what ffprobe -show_frames -pretty $VIDEO | grep -F '[FRAME]' | wc -l tells me.
  2. The final video plays fine in some players (mpv and vlc) but not in Quicktime. Quicktime just shows a completely black screen.

  My code is roughly this (modified a bit to remove types that are unique to our code base) :

  First, I open the video file, write the headers and initialize things :

  template <class ptrt="ptrt">
  
  using UniquePtrWithDeleteFunction = std::unique_ptr>;
  
  
  
  
  
  std::unique_ptr<ffmpegencodingframesink> FfmpegEncodingFrameSink::Create(
  
      const std::string&amp; dest_url) {
  
    AVFormatContext* tmp_format_ctxt;
  
    auto alloc_format_res = avformat_alloc_output_context2(&amp;tmp_format_ctxt, nullptr, "mp4", dest_url.c_str());
  
    if (alloc_format_res &lt; 0) {
  
      throw FfmpegException("Error opening output file.");
  
    }
  
    auto format_ctxt = UniquePtrWithDeleteFunction<avformatcontext>(
  
        tmp_format_ctxt, CloseAvFormatContext);
  
  
  
    AVStream* out_stream_video = avformat_new_stream(format_ctxt.get(), nullptr);
  
    if (out_stream_video == nullptr) {
  
      throw FfmpegException("Could not create outputstream");
  
    }
  
  
  
    auto codec_context = GetCodecContext(options);
  
    out_stream_video->time_base = codec_context->time_base;
  
  
  
    auto ret = avcodec_parameters_from_context(out_stream_video->codecpar, codec_context.get());
  
    if (ret &lt; 0) {
  
      throw FfmpegException("Failed to copy encoder parameters to outputstream");
  
    }
  
  
  
    if (!(format_ctxt->oformat->flags &amp; AVFMT_NOFILE)) {
  
      ret = avio_open(&amp;format_ctxt->pb, dest_url.c_str(), AVIO_FLAG_WRITE);
  
      if (ret &lt; 0) {
  
        throw VideoDecodeException("Could not open output file: " + dest_url);
  
      }
  
    }
  
  
  
    ret = avformat_init_output(format_ctxt.get(), nullptr);
  
    if (ret &lt; 0) {
  
      throw FfmpegException("Unable to initialize the codec.");
  
    }
  
  
  
    ret = avformat_write_header(format_ctxt.get(), nullptr);
  
    if (ret &lt; 0) {
  
      throw FfmpegException("Error occurred writing format header");
  
    }
  
  
  
    return std::unique_ptr<ffmpegencodingframesink>(
  
        new FfmpegEncodingFrameSink(std::move(format_ctxt), std::move(codec_context)));
  
  }
  
  </ffmpegencodingframesink></avformatcontext></ffmpegencodingframesink></class>

  Then, every time I get a new frame to encode I pass it to this function (the frames are being decoded via ffmpeg from another mp4 file which Quicktime plays just fine) :

  // If frame == nullptr then we're done and we're just flushing the encoder
  
  // otherwise encode an actual frame
  
  void FfmpegEncodingFrameSink::EncodeAndWriteFrame(
  
      const AVFrame* frame) {
  
    auto ret = avcodec_send_frame(codec_ctxt_.get(), frame);
  
    if (ret < 0) {
  
      throw FfmpegException("Error encoding the frame.");
  
    }
  
  
  
    AVPacket enc_packet;
  
    enc_packet.data = nullptr;
  
    enc_packet.size = 0;
  
    av_init_packet(&enc_packet);
  
  
  
    do {
  
      ret = avcodec_receive_packet(codec_ctxt_.get(), &enc_packet);
  
      if (ret ==  AVERROR(EAGAIN)) {
  
        CHECK(frame != nullptr);
  
        break;
  
      } else if (ret ==  AVERROR_EOF) {
  
        CHECK(frame == nullptr);
  
        break;
  
      } else if (ret < 0) {
  
        throw FfmpegException("Error putting the encoded frame into the packet.");
  
      }
  
  
  
      assert(ret == 0);
  
      enc_packet.stream_index = 0;
  
  
  
      LOG(INFO) << "Writing packet to stream.";
  
      av_interleaved_write_frame(format_ctxt_.get(), &enc_packet);
  
      av_packet_unref(&enc_packet);
  
    } while (ret == 0);
  
  }

  Finally, in my destructor I close everything up like so :

  FfmpegEncodingFrameSink::~FfmpegEncodingFrameSink() {
  
    // Pass a nullptr to EncodeAndWriteFrame so it flushes the encoder
  
    EncodeAndWriteFrame(nullptr);
  
    // write mp4 trailer
  
    av_write_trailer(format_ctxt_.get());
  
  }

  If I run this passing n frames to EncodeAndWriteFrame line LOG(INFO) << "Writing packet to stream."; gets run n times indicating the n packets were written to the stream. But ffprobe always shows only n - 1 frames int he video. And the final video doesn’t play on quicktime.

  What am I doing wrong ??