Recherche avancée

Sur d’autres sites (17200)

• Increase/Decrease audio volume using FFmpeg

  9 juin 2016, par williamtroup

  I’m am currently using C# invokes to call the FFmpeg APIs to handle video and audio. I have the following code in place to extract the audio from a video and write it to a file.

  while (ffmpeg.av_read_frame(formatContext, &packet) >= 0)
  
  {
  
      if (packet.stream_index == streamIndex)
  
      {
  
          while (packet.size > 0)
  
          {
  
              int frameDecoded;
  
              int frameDecodedResult = ffmpeg.avcodec_decode_audio4(codecContext, frame, &frameDecoded, packet);
  
  
  
              if (frameDecoded > 0 && frameDecodedResult >= 0)
  
              {
  
                  //writeAudio.WriteFrame(frame);
  
  
  
                  packet.data += totalBytesDecoded;
  
                  packet.size -= totalBytesDecoded;
  
              }
  
          }
  
  
  
          frameIndex++;
  
      }
  
  
  
      Avcodec.av_free_packet(&packet);
  
  }

  This is all working correctly. I’m currently using the FFmpeg.AutoGen project for the API access.

  I want to be able to increase/decrease the volume of the audio before its written to the file, but I cannot seem to find a command or any help with this. Does it have to be done manually ?

  Update 1 :

  After receiving some help, this is the class layout I have :

  public unsafe class FilterVolume
  
  {
  
      #region Private Member Variables
  
  
  
      private AVFilterGraph* m_filterGraph = null;
  
      private AVFilterContext* m_aBufferSourceFilterContext = null;
  
      private AVFilterContext* m_aBufferSinkFilterContext = null;
  
  
  
      #endregion
  
  
  
      #region Private Constant Member Variables
  
  
  
      private const int EAGAIN = 11;
  
  
  
      #endregion
  
  
  
      public FilterVolume(AVCodecContext* codecContext, AVStream* stream, float volume)
  
      {
  
          CodecContext = codecContext;
  
          Stream = stream;
  
          Volume = volume;
  
  
  
          Initialise();
  
      }
  
  
  
      public AVFrame* Adjust(AVFrame* frame)
  
      {
  
          AVFrame* returnFilteredFrame = ffmpeg.av_frame_alloc();
  
  
  
          if (m_aBufferSourceFilterContext != null && m_aBufferSinkFilterContext != null)
  
          {
  
              int bufferSourceAddFrameResult = ffmpeg.av_buffersrc_add_frame(m_aBufferSourceFilterContext, frame);
  
              if (bufferSourceAddFrameResult < 0)
  
              {
  
              }
  
  
  
              int bufferSinkGetFrameResult = ffmpeg.av_buffersink_get_frame(m_aBufferSinkFilterContext, returnFilteredFrame);
  
              if (bufferSinkGetFrameResult < 0 && bufferSinkGetFrameResult != -EAGAIN)
  
              {
  
              }
  
          }
  
  
  
          return returnFilteredFrame;
  
      }
  
  
  
      public void Dispose()
  
      {
  
          Cleanup(m_filterGraph);
  
      }
  
  
  
      #region Private Properties
  
  
  
      private AVCodecContext* CodecContext { get; set; }
  
      private AVStream* Stream { get; set; }
  
      private float Volume { get; set; }
  
  
  
      #endregion
  
  
  
      #region Private Setup Helper Functions
  
  
  
      private void Initialise()
  
      {
  
          m_filterGraph = GetAllocatedFilterGraph();
  
  
  
          string aBufferFilterArguments = string.Format("sample_fmt={0}:channel_layout={1}:sample_rate={2}:time_base={3}/{4}",
  
              (int)CodecContext->sample_fmt,
  
              CodecContext->channel_layout,
  
              CodecContext->sample_rate,
  
              Stream->time_base.num,
  
              Stream->time_base.den);
  
  
  
          AVFilterContext* aBufferSourceFilterContext = CreateFilter("abuffer", m_filterGraph, aBufferFilterArguments);
  
          AVFilterContext* volumeFilterContext = CreateFilter("volume", m_filterGraph, string.Format("volume={0}", Volume));
  
          AVFilterContext* aBufferSinkFilterContext = CreateFilter("abuffersink", m_filterGraph);
  
  
  
          LinkFilter(aBufferSourceFilterContext, volumeFilterContext);
  
          LinkFilter(volumeFilterContext, aBufferSinkFilterContext);
  
  
  
          SetFilterGraphConfiguration(m_filterGraph, null);
  
  
  
          m_aBufferSourceFilterContext = aBufferSourceFilterContext;
  
          m_aBufferSinkFilterContext = aBufferSinkFilterContext;
  
      }
  
  
  
      #endregion
  
  
  
      #region Private Cleanup Helper Functions
  
  
  
      private static void Cleanup(AVFilterGraph* filterGraph)
  
      {
  
          if (filterGraph != null)
  
          {
  
              ffmpeg.avfilter_graph_free(&filterGraph);
  
          }
  
      }
  
  
  
      #endregion
  
  
  
      #region Provate Helpers
  
  
  
      private AVFilterGraph* GetAllocatedFilterGraph()
  
      {
  
          AVFilterGraph* filterGraph = ffmpeg.avfilter_graph_alloc();
  
          if (filterGraph == null)
  
          {
  
          }
  
  
  
          return filterGraph;
  
      }
  
  
  
      private AVFilter* GetFilterByName(string name)
  
      {
  
          AVFilter* filter = ffmpeg.avfilter_get_by_name(name);
  
          if (filter == null)
  
          {
  
          }
  
  
  
          return filter;
  
      }
  
  
  
      private void SetFilterGraphConfiguration(AVFilterGraph* filterGraph, void* logContext)
  
      {
  
          int filterGraphConfigResult = ffmpeg.avfilter_graph_config(filterGraph, logContext);
  
          if (filterGraphConfigResult < 0)
  
          {
  
          }
  
      }
  
  
  
      private AVFilterContext* CreateFilter(string filterName, AVFilterGraph* filterGraph, string filterArguments = null)
  
      {
  
          AVFilter* filter = GetFilterByName(filterName);
  
          AVFilterContext* filterContext;
  
  
  
          int aBufferFilterCreateResult = ffmpeg.avfilter_graph_create_filter(&filterContext, filter, filterName, filterArguments, null, filterGraph);
  
          if (aBufferFilterCreateResult < 0)
  
          {
  
          }
  
  
  
          return filterContext;
  
      }
  
  
  
      private void LinkFilter(AVFilterContext* source, AVFilterContext* destination)
  
      {
  
          int filterLinkResult = ffmpeg.avfilter_link(source, 0, destination, 0);
  
          if (filterLinkResult < 0)
  
          {
  
          }
  
      }
  
  
  
      #endregion
  
  }

  The Adjust() function is called after a frame is decoded. I’m currently getting a -22 error when av_buffersrc_add_frame() is called. This indicates that a parameter is invalid, but after debugging, I cannot see anything that would be causing this.

  This is how the code is called :

  while (ffmpeg.av_read_frame(formatContext, &packet) >= 0)
  
  {
  
      if (packet.stream_index == streamIndex)
  
      {
  
          while (packet.size > 0)
  
          {
  
              int frameDecoded;
  
              int frameDecodedResult = ffmpeg.avcodec_decode_audio4(codecContext, frame, &frameDecoded, packet);
  
  
  
              if (frameDecoded > 0 && frameDecodedResult >= 0)
  
              {
  
                  AVFrame* filteredFrame = m_filterVolume.Adjust(frame);
  
  
  
                  //writeAudio.WriteFrame(filteredFrame);
  
  
  
                  packet.data += totalBytesDecoded;
  
                  packet.size -= totalBytesDecoded;
  
              }
  
          }
  
  
  
          frameIndex++;
  
      }
  
  
  
      Avcodec.av_free_packet(&packet);
  
  }

  Update 2 :

  Cracked it. The "channel_layout" option in the filter argument string is supposed to be a hexadecimal. This is what the string formatting should look like :

  string aBufferFilterArguments = string.Format("sample_fmt={0}:channel_layout=0x{1}:sample_rate={2}:time_base={3}/{4}",
  
      (int)CodecContext->sample_fmt,
  
      CodecContext->channel_layout,
  
      CodecContext->sample_rate,
  
      Stream->time_base.num,
  
      Stream->time_base.den);

• Decode mp3 using FFMpeg, Android NDK - What is wrong with my AVFormatContext ?

  27 février 2020, par michpohl

  I am trying to decode am MP3 file to a raw PCM stream using FFMpeg via JNI on Android. I have compiled the latest FFMpeg version (4.2) and added it to my app. This did not make any problems.
  The goal is to be able to use mp3 files from the device’s storage for playback with oboe

  Since I am relatively inexperienced with both C++ and FFMpeg, my approach is based upon this :
  oboe’s RhythmGame example

  I have based my FFMpegExtractorclass on the one found in the example here. With the help of StackOverflow the AAssetManageruse was removed and instead a MediaSource helper class now serves as a wrapper for my stream (see here)

  But unfortunately, creating the AVFormatContext doesn’t work right - and I can’t seem to understand why. Since I have very limited understanding of correct pointer usage and C++ memory management, I suspect it’s most likely I’m doing something wrong in that area. But honestly, I have no idea.

  This is my FFMpegExtractor.h :

  #define MYAPP_FFMPEGEXTRACTOR_H
  
  
  
  extern "C" {
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libswresample></libswresample>swresample.h>
  
  #include <libavutil></libavutil>opt.h>
  
  }
  
  
  
  #include <cstdint>
  
  #include <android></android>asset_manager.h>
  
  #include 
  
  #include <fstream>
  
  #include "MediaSource.cpp"
  
  
  
  
  
  class FFMpegExtractor {
  
  public:
  
  
  
      FFMpegExtractor();
  
  
  
      ~FFMpegExtractor();
  
  
  
      int64_t decode2(char *filepath, uint8_t *targetData, AudioProperties targetProperties);
  
  
  
  private:
  
      MediaSource *mSource;
  
  
  
      bool createAVFormatContext(AVIOContext *avioContext, AVFormatContext **avFormatContext);
  
  
  
      bool openAVFormatContext(AVFormatContext *avFormatContext);
  
  
  
      int32_t cleanup(AVIOContext *avioContext, AVFormatContext *avFormatContext);
  
  
  
      bool getStreamInfo(AVFormatContext *avFormatContext);
  
  
  
      AVStream *getBestAudioStream(AVFormatContext *avFormatContext);
  
  
  
      AVCodec *findCodec(AVCodecID id);
  
  
  
      void printCodecParameters(AVCodecParameters *params);
  
  
  
      bool createAVIOContext2(const std::string &amp;filePath, uint8_t *buffer, uint32_t bufferSize,
  
                              AVIOContext **avioContext);
  
  };
  
  
  
  
  
  #endif //MYAPP_FFMPEGEXTRACTOR_H
  
  </fstream></cstdint>

  This is FFMPegExtractor.cpp :

  #include <memory>
  
  #include <oboe></oboe>Definitions.h>
  
  #include "FFMpegExtractor.h"
  
  #include "logging.h"
  
  #include <fstream>
  
  
  
  FFMpegExtractor::FFMpegExtractor() {
  
      mSource = new MediaSource;
  
  }
  
  
  
  FFMpegExtractor::~FFMpegExtractor() {
  
      delete mSource;
  
  }
  
  
  
  constexpr int kInternalBufferSize = 1152; // Use MP3 block size. https://wiki.hydrogenaud.io/index.php?title=MP3
  
  
  
  /**
  
   * Reads from an IStream into FFmpeg.
  
   *
  
   * @param ptr       A pointer to the user-defined IO data structure.
  
   * @param buf       A buffer to read into.
  
   * @param buf_size  The size of the buffer buff.
  
   *
  
   * @return The number of bytes read into the buffer.
  
   */
  
  
  
  
  
  // If FFmpeg needs to read the file, it will call this function.
  
  // We need to fill the buffer with file's data.
  
  int read(void *opaque, uint8_t *buffer, int buf_size) {
  
      MediaSource *source = (MediaSource *) opaque;
  
      return source->read(buffer, buf_size);
  
  }
  
  
  
  // If FFmpeg needs to seek in the file, it will call this function.
  
  // We need to change the read pos.
  
  int64_t seek(void *opaque, int64_t offset, int whence) {
  
      MediaSource *source = (MediaSource *) opaque;
  
      return source->seek(offset, whence);
  
  }
  
  
  
  
  
  // Create and save a MediaSource instance.
  
  bool FFMpegExtractor::createAVIOContext2(const std::string &amp;filepath, uint8_t *buffer, uint32_t bufferSize,
  
                                           AVIOContext **avioContext) {
  
  
  
      mSource = new MediaSource;
  
      mSource->open(filepath);
  
      constexpr int isBufferWriteable = 0;
  
  
  
      *avioContext = avio_alloc_context(
  
              buffer, // internal buffer for FFmpeg to use
  
              bufferSize, // For optimal decoding speed this should be the protocol block size
  
              isBufferWriteable,
  
              mSource, // Will be passed to our callback functions as a (void *)
  
              read, // Read callback function
  
              nullptr, // Write callback function (not used)
  
              seek); // Seek callback function
  
  
  
      if (*avioContext == nullptr) {
  
          LOGE("Failed to create AVIO context");
  
          return false;
  
      } else {
  
          return true;
  
      }
  
  }
  
  
  
  bool
  
  FFMpegExtractor::createAVFormatContext(AVIOContext *avioContext,
  
                                         AVFormatContext **avFormatContext) {
  
  
  
      *avFormatContext = avformat_alloc_context();
  
      (*avFormatContext)->pb = avioContext;
  
  
  
      if (*avFormatContext == nullptr) {
  
          LOGE("Failed to create AVFormatContext");
  
          return false;
  
      } else {
  
          LOGD("Successfully created AVFormatContext");
  
          return true;
  
      }
  
  }
  
  
  
  bool FFMpegExtractor::openAVFormatContext(AVFormatContext *avFormatContext) {
  
  
  
      int result = avformat_open_input(&amp;avFormatContext,
  
                                       "", /* URL is left empty because we're providing our own I/O */
  
                                       nullptr /* AVInputFormat *fmt */,
  
                                       nullptr /* AVDictionary **options */
  
      );
  
  
  
      if (result == 0) {
  
          return true;
  
      } else {
  
          LOGE("Failed to open file. Error code %s", av_err2str(result));
  
          return false;
  
      }
  
  }
  
  
  
  bool FFMpegExtractor::getStreamInfo(AVFormatContext *avFormatContext) {
  
  
  
      int result = avformat_find_stream_info(avFormatContext, nullptr);
  
      if (result == 0) {
  
          return true;
  
      } else {
  
          LOGE("Failed to find stream info. Error code %s", av_err2str(result));
  
          return false;
  
      }
  
  }
  
  
  
  AVStream *FFMpegExtractor::getBestAudioStream(AVFormatContext *avFormatContext) {
  
  
  
      int streamIndex = av_find_best_stream(avFormatContext, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);
  
  
  
      if (streamIndex &lt; 0) {
  
          LOGE("Could not find stream");
  
          return nullptr;
  
      } else {
  
          return avFormatContext->streams[streamIndex];
  
      }
  
  }
  
  
  
  int64_t FFMpegExtractor::decode2(
  
          char* filepath,
  
          uint8_t *targetData,
  
          AudioProperties targetProperties) {
  
  
  
      LOGD("Decode SETUP");
  
      int returnValue = -1; // -1 indicates error
  
  
  
      // Create a buffer for FFmpeg to use for decoding (freed in the custom deleter below)
  
      auto buffer = reinterpret_cast(av_malloc(kInternalBufferSize));
  
  
  
  
  
      // Create an AVIOContext with a custom deleter
  
      std::unique_ptr ioContext{
  
              nullptr,
  
              [](AVIOContext *c) {
  
                  av_free(c->buffer);
  
                  avio_context_free(&amp;c);
  
              }
  
      };
  
      {
  
          AVIOContext *tmp = nullptr;
  
          if (!createAVIOContext2(filepath, buffer, kInternalBufferSize, &amp;tmp)) {
  
              LOGE("Could not create an AVIOContext");
  
              return returnValue;
  
          }
  
          ioContext.reset(tmp);
  
      }
  
      // Create an AVFormatContext using the avformat_free_context as the deleter function
  
      std::unique_ptr formatContext{
  
              nullptr,
  
              &amp;avformat_free_context
  
      };
  
  
  
      {
  
          AVFormatContext *tmp;
  
          if (!createAVFormatContext(ioContext.get(), &amp;tmp)) return returnValue;
  
          formatContext.reset(tmp);
  
      }
  
      if (!openAVFormatContext(formatContext.get())) return returnValue;
  
      LOGD("172");
  
  
  
      if (!getStreamInfo(formatContext.get())) return returnValue;
  
      LOGD("175");
  
  
  
      // Obtain the best audio stream to decode
  
      AVStream *stream = getBestAudioStream(formatContext.get());
  
      if (stream == nullptr || stream->codecpar == nullptr) {
  
          LOGE("Could not find a suitable audio stream to decode");
  
          return returnValue;
  
      }
  
      LOGD("183");
  
  
  
      printCodecParameters(stream->codecpar);
  
  
  
      // Find the codec to decode this stream
  
      AVCodec *codec = avcodec_find_decoder(stream->codecpar->codec_id);
  
      if (!codec) {
  
          LOGE("Could not find codec with ID: %d", stream->codecpar->codec_id);
  
          return returnValue;
  
      }
  
  
  
      // Create the codec context, specifying the deleter function
  
      std::unique_ptr codecContext{
  
              nullptr,
  
              [](AVCodecContext *c) { avcodec_free_context(&amp;c); }
  
      };
  
      {
  
          AVCodecContext *tmp = avcodec_alloc_context3(codec);
  
          if (!tmp) {
  
              LOGE("Failed to allocate codec context");
  
              return returnValue;
  
          }
  
          codecContext.reset(tmp);
  
      }
  
  
  
      // Copy the codec parameters into the context
  
      if (avcodec_parameters_to_context(codecContext.get(), stream->codecpar) &lt; 0) {
  
          LOGE("Failed to copy codec parameters to codec context");
  
          return returnValue;
  
      }
  
  
  
      // Open the codec
  
      if (avcodec_open2(codecContext.get(), codec, nullptr) &lt; 0) {
  
          LOGE("Could not open codec");
  
          return returnValue;
  
      }
  
  
  
      // prepare resampler
  
      int32_t outChannelLayout = (1 &lt;&lt; targetProperties.channelCount) - 1;
  
      LOGD("Channel layout %d", outChannelLayout);
  
  
  
      SwrContext *swr = swr_alloc();
  
      av_opt_set_int(swr, "in_channel_count", stream->codecpar->channels, 0);
  
      av_opt_set_int(swr, "out_channel_count", targetProperties.channelCount, 0);
  
      av_opt_set_int(swr, "in_channel_layout", stream->codecpar->channel_layout, 0);
  
      av_opt_set_int(swr, "out_channel_layout", outChannelLayout, 0);
  
      av_opt_set_int(swr, "in_sample_rate", stream->codecpar->sample_rate, 0);
  
      av_opt_set_int(swr, "out_sample_rate", targetProperties.sampleRate, 0);
  
      av_opt_set_int(swr, "in_sample_fmt", stream->codecpar->format, 0);
  
      av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
  
      av_opt_set_int(swr, "force_resampling", 1, 0);
  
  
  
      // Check that resampler has been inited
  
      int result = swr_init(swr);
  
      if (result != 0) {
  
          LOGE("swr_init failed. Error: %s", av_err2str(result));
  
          return returnValue;
  
      };
  
      if (!swr_is_initialized(swr)) {
  
          LOGE("swr_is_initialized is false\n");
  
          return returnValue;
  
      }
  
  
  
      // Prepare to read data
  
      int bytesWritten = 0;
  
      AVPacket avPacket; // Stores compressed audio data
  
      av_init_packet(&amp;avPacket);
  
      AVFrame *decodedFrame = av_frame_alloc(); // Stores raw audio data
  
      int bytesPerSample = av_get_bytes_per_sample((AVSampleFormat) stream->codecpar->format);
  
  
  
      LOGD("Bytes per sample %d", bytesPerSample);
  
  
  
      // While there is more data to read, read it into the avPacket
  
      while (av_read_frame(formatContext.get(), &amp;avPacket) == 0) {
  
  
  
          if (avPacket.stream_index == stream->index) {
  
  
  
              while (avPacket.size > 0) {
  
                  // Pass our compressed data into the codec
  
                  result = avcodec_send_packet(codecContext.get(), &amp;avPacket);
  
                  if (result != 0) {
  
                      LOGE("avcodec_send_packet error: %s", av_err2str(result));
  
                      goto cleanup;
  
                  }
  
  
  
                  // Retrieve our raw data from the codec
  
                  result = avcodec_receive_frame(codecContext.get(), decodedFrame);
  
                  if (result != 0) {
  
                      LOGE("avcodec_receive_frame error: %s", av_err2str(result));
  
                      goto cleanup;
  
                  }
  
  
  
                  // DO RESAMPLING
  
                  auto dst_nb_samples = (int32_t) av_rescale_rnd(
  
                          swr_get_delay(swr, decodedFrame->sample_rate) + decodedFrame->nb_samples,
  
                          targetProperties.sampleRate,
  
                          decodedFrame->sample_rate,
  
                          AV_ROUND_UP);
  
  
  
                  short *buffer1;
  
                  av_samples_alloc(
  
                          (uint8_t **) &amp;buffer1,
  
                          nullptr,
  
                          targetProperties.channelCount,
  
                          dst_nb_samples,
  
                          AV_SAMPLE_FMT_FLT,
  
                          0);
  
                  int frame_count = swr_convert(
  
                          swr,
  
                          (uint8_t **) &amp;buffer1,
  
                          dst_nb_samples,
  
                          (const uint8_t **) decodedFrame->data,
  
                          decodedFrame->nb_samples);
  
  
  
                  int64_t bytesToWrite = frame_count * sizeof(float) * targetProperties.channelCount;
  
                  memcpy(targetData + bytesWritten, buffer1, (size_t) bytesToWrite);
  
                  bytesWritten += bytesToWrite;
  
                  av_freep(&amp;buffer1);
  
  
  
                  avPacket.size = 0;
  
                  avPacket.data = nullptr;
  
              }
  
          }
  
      }
  
  
  
      av_frame_free(&amp;decodedFrame);
  
  
  
      returnValue = bytesWritten;
  
  
  
      cleanup:
  
      return returnValue;
  
  }
  
  
  
  void FFMpegExtractor::printCodecParameters(AVCodecParameters *params) {
  
  
  
      LOGD("Stream properties");
  
      LOGD("Channels: %d", params->channels);
  
      LOGD("Channel layout: %"
  
                   PRId64, params->channel_layout);
  
      LOGD("Sample rate: %d", params->sample_rate);
  
      LOGD("Format: %s", av_get_sample_fmt_name((AVSampleFormat) params->format));
  
      LOGD("Frame size: %d", params->frame_size);
  
  }
  
  </fstream></memory>

  And this is the MediaSource.cpp :

  #ifndef MYAPP_MEDIASOURCE_CPP
  
  #define MYAPP_MEDIASOURCE_CPP
  
  
  
  extern "C" {
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libswresample></libswresample>swresample.h>
  
  #include <libavutil></libavutil>opt.h>
  
  }
  
  
  
  #include <cstdint>
  
  #include <android></android>asset_manager.h>
  
  #include 
  
  #include <fstream>
  
  #include "logging.h"
  
  
  
  // wrapper class for file stream
  
  class MediaSource {
  
  public:
  
  
  
      MediaSource() {
  
      }
  
  
  
      ~MediaSource() {
  
          source.close();
  
      }
  
  
  
      void open(const std::string &amp;filePath) {
  
          const char *x = filePath.c_str();
  
          LOGD("Opened %s", x);
  
          source.open(filePath, std::ios::in | std::ios::binary);
  
      }
  
  
  
      int read(uint8_t *buffer, int buf_size) {
  
          // read data to buffer
  
          source.read((char *) buffer, buf_size);
  
          // return how many bytes were read
  
          return source.gcount();
  
      }
  
  
  
      int64_t seek(int64_t offset, int whence) {
  
          if (whence == AVSEEK_SIZE) {
  
              // FFmpeg needs file size.
  
              int oldPos = source.tellg();
  
              source.seekg(0, std::ios::end);
  
              int64_t length = source.tellg();
  
              // seek to old pos
  
              source.seekg(oldPos);
  
              return length;
  
          } else if (whence == SEEK_SET) {
  
              // set pos to offset
  
              source.seekg(offset);
  
          } else if (whence == SEEK_CUR) {
  
              // add offset to pos
  
              source.seekg(offset, std::ios::cur);
  
          } else {
  
              // do not support other flags, return -1
  
              return -1;
  
          }
  
          // return current pos
  
          return source.tellg();
  
      }
  
  
  
  private:
  
      std::ifstream source;
  
  };
  
  
  
  #endif //MYAPP_MEDIASOURCE_CPP
  
  </fstream></cstdint>

  When the code is executed, I can see that I submit the correct file path, so I assume the resource mp3 is there.
  When this code is executed the app crashes in line 103 of FFMpegExtractor.cpp, at formatContext.reset(tmp);

  This is what Android Studio logs when the app crashes :

  --------- beginning of crash
  
  2020-02-27 14:31:26.341 9852-9945/com.user.myapp A/libc: Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x7fffffff0 in tid 9945 (chaelpohl.loopy), pid 9852 (user.myapp)

  This is the (sadly very short) output I get with ndk-stack :

  ********** Crash dump: **********
  
  Build fingerprint: 'samsung/dreamltexx/dreamlte:9/PPR1.180610.011/G950FXXU6DSK9:user/release-keys'
  
  #00 0x0000000000016c50 /data/app/com.user.myapp-D7dBCgHF-vdQNNSald4lWA==/lib/arm64/libavformat.so (avformat_free_context+260)
  
                                                                                                           avformat_free_context
  
                                                                                                           ??:0:0
  
  Crash dump is completed

  I tested a bit around, and every call to my formatContext crashes the app. So I assume there is something wrong with the input I provide to build it but I have no clue how to debug this.

  Any help is appreciated ! (Happy to provide additional resources if something crucial is missing).

• Screen Recording with FFmpeg-Lib with c++

  27 janvier 2020, par Baschdel

  I’m trying to record the whole desktop stream with FFmpeg on Windows.
  I found a working example here. The Problem is that some og the functions depricated. So I tried to replace them with the updated ones.

  But there are some slight problems. The error "has triggered a breakpoint." occurse and also "not able to read the location."
  The bigger problem is that I don’t know if this is the right way to do this..

  My code looks like this :

  using namespace std;
  
  
  
  /* initialize the resources*/
  
  Recorder::Recorder()
  
  {
  
  
  
      av_register_all();
  
      avcodec_register_all();
  
      avdevice_register_all();
  
      cout<<"\nall required functions are registered successfully";
  
  }
  
  
  
  /* uninitialize the resources */
  
  Recorder::~Recorder()
  
  {
  
  
  
      avformat_close_input(&pAVFormatContext);
  
      if( !pAVFormatContext )
  
      {
  
          cout<<"\nfile closed sucessfully";
  
      }
  
      else
  
      {
  
          cout<<"\nunable to close the file";
  
          exit(1);
  
      }
  
  
  
      avformat_free_context(pAVFormatContext);
  
      if( !pAVFormatContext )
  
      {
  
          cout<<"\navformat free successfully";
  
      }
  
      else
  
      {
  
          cout<<"\nunable to free avformat context";
  
          exit(1);
  
      }
  
  
  
  }
  
  
  
  /* establishing the connection between camera or screen through its respective folder */
  
  int Recorder::openCamera()
  
  {
  
  
  
      value = 0;
  
      options = NULL;
  
      pAVFormatContext = NULL;
  
  
  
      pAVFormatContext = avformat_alloc_context();//Allocate an AVFormatContext.
  
  
  
      openScreen(pAVFormatContext);
  
  
  
      /* set frame per second */
  
      value = av_dict_set( &options,"framerate","30",0 );
  
      if(value < 0)
  
      {
  
        cout<<"\nerror in setting dictionary value";
  
         exit(1);
  
      }
  
  
  
      value = av_dict_set( &options, "preset", "medium", 0 );
  
      if(value < 0)
  
      {
  
        cout<<"\nerror in setting preset values";
  
        exit(1);
  
      }
  
  
  
  //  value = avformat_find_stream_info(pAVFormatContext,NULL);
  
      if(value < 0)
  
      {
  
        cout<<"\nunable to find the stream information";
  
        exit(1);
  
      }
  
  
  
      VideoStreamIndx = -1;
  
  
  
      /* find the first video stream index . Also there is an API available to do the below operations */
  
      for(int i = 0; i < pAVFormatContext->nb_streams; i++ ) // find video stream posistion/index.
  
      {
  
        if( pAVFormatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO )
  
        {
  
           VideoStreamIndx = i;
  
           break;
  
        }
  
  
  
      } 
  
  
  
      if( VideoStreamIndx == -1)
  
      {
  
        cout<<"\nunable to find the video stream index. (-1)";
  
        exit(1);
  
      }
  
  
  
      // assign pAVFormatContext to VideoStreamIndx
  
      pAVCodecContext = pAVFormatContext->streams[VideoStreamIndx]->codec;
  
  
  
      pAVCodec = avcodec_find_decoder(pAVCodecContext->codec_id);
  
      if( pAVCodec == NULL )
  
      {
  
        cout<<"\nunable to find the decoder";
  
        exit(1);
  
      }
  
  
  
      value = avcodec_open2(pAVCodecContext , pAVCodec , NULL);//Initialize the AVCodecContext to use the given AVCodec.
  
      if( value < 0 )
  
      {
  
        cout<<"\nunable to open the av codec";
  
        exit(1);
  
      }
  
  }
  
  
  
  /* initialize the video output file and its properties  */
  
  int Recorder::init_outputfile()
  
  {
  
      outAVFormatContext = NULL;
  
      value = 0;
  
      output_file = "output.mp4";
  
  
  
      avformat_alloc_output_context2(&outAVFormatContext, NULL, NULL, output_file);
  
      if (!outAVFormatContext)
  
      {
  
          cout<<"\nerror in allocating av format output context";
  
          exit(1);
  
      }
  
  
  
  /* Returns the output format in the list of registered output formats which best matches the provided parameters, or returns NULL if there is no match. */
  
      output_format = av_guess_format(NULL, output_file ,NULL);
  
      if( !output_format )
  
      {
  
       cout<<"\nerror in guessing the video format. try with correct format";
  
       exit(1);
  
      }
  
  
  
      video_st = avformat_new_stream(outAVFormatContext ,NULL);
  
      if( !video_st )
  
      {
  
          cout<<"\nerror in creating a av format new stream";
  
          exit(1);
  
      }
  
  
  
      if (codec_id == AV_CODEC_ID_H264)
  
      {
  
          av_opt_set(outAVCodecContext->priv_data, "preset", "slow", 0);
  
      }
  
  
  
      outAVCodec = avcodec_find_encoder(AV_CODEC_ID_MPEG4);
  
      if (!outAVCodec)
  
      {
  
          cout << "\nerror in finding the av codecs. try again with correct codec";
  
          exit(1);
  
      }
  
  
  
      outAVCodecContext = avcodec_alloc_context3(outAVCodec);
  
      if( !outAVCodecContext )
  
      {
  
          cout<<"\nerror in allocating the codec contexts";
  
          exit(1);
  
      }
  
  
  
      /* set property of the video file */
  
      outAVCodecContext = video_st->codec;
  
      outAVCodecContext->codec_id = AV_CODEC_ID_MPEG4;// AV_CODEC_ID_MPEG4; // AV_CODEC_ID_H264 // AV_CODEC_ID_MPEG1VIDEO
  
      outAVCodecContext->codec_type = AVMEDIA_TYPE_VIDEO;
  
      outAVCodecContext->pix_fmt  = AV_PIX_FMT_YUV420P;
  
      outAVCodecContext->bit_rate = 400000; // 2500000
  
      outAVCodecContext->width = 1920;
  
      outAVCodecContext->height = 1080;
  
      outAVCodecContext->gop_size = 3;
  
      outAVCodecContext->max_b_frames = 2;
  
      outAVCodecContext->time_base.num = 1;
  
      outAVCodecContext->time_base.den = 30; //15fps
  
  
  
  
  
      /* Some container formats (like MP4) require global headers to be present
  
         Mark the encoder so that it behaves accordingly. */
  
  
  
      if ( outAVFormatContext->oformat->flags & AVFMT_GLOBALHEADER)
  
      {
  
          outAVCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
      }
  
  
  
      value = avcodec_open2(outAVCodecContext, outAVCodec, NULL);
  
      if( value < 0)
  
      {
  
          cout<<"\nerror in opening the avcodec";
  
          exit(1);
  
      }
  
  
  
      /* create empty video file */
  
      if ( !(outAVFormatContext->flags & AVFMT_NOFILE) )
  
      {
  
       if( avio_open2(&outAVFormatContext->pb , output_file , AVIO_FLAG_WRITE ,NULL, NULL) < 0 )
  
       {
  
        cout<<"\nerror in creating the video file";
  
        exit(1);
  
       }
  
      }
  
  
  
      if(!outAVFormatContext->nb_streams)
  
      {
  
          cout<<"\noutput file dose not contain any stream";
  
          exit(1);
  
      }
  
  
  
      /* imp: mp4 container or some advanced container file required header information*/
  
      value = avformat_write_header(outAVFormatContext , &options);
  
      if(value < 0)
  
      {
  
          cout<<"\nerror in writing the header context";
  
          exit(1);
  
      }
  
  
  
      /*
  
      // uncomment here to view the complete video file informations
  
      cout<<"\n\nOutput file information :\n\n";
  
      av_dump_format(outAVFormatContext , 0 ,output_file ,1);
  
      */
  
  }
  
  
  
  int Recorder::stop() {
  
      threading = false;
  
  
  
      demux->join();
  
      rescale->join();
  
      mux->join();
  
  
  
      return 0;
  
  }
  
  
  
  int Recorder::start() {
  
      initVideoThreads();
  
      return 0;
  
  }
  
  
  
  int Recorder::initVideoThreads() {
  
      demux = new thread(&Recorder::demuxVideoStream, this, pAVCodecContext, pAVFormatContext, VideoStreamIndx);
  
  
  
      rescale = new thread(&Recorder::rescaleVideoStream, this, pAVCodecContext, outAVCodecContext);
  
  
  
      demux = new thread(&Recorder::encodeVideoStream, this, outAVCodecContext);
  
      return 0;
  
  }
  
  
  
  void Recorder::demuxVideoStream(AVCodecContext* codecContext, AVFormatContext* formatContext, int streamIndex)
  
  {
  
      // init packet
  
      AVPacket* packet = (AVPacket*)av_malloc(sizeof(AVPacket));
  
      av_init_packet(packet);
  
  
  
      int ctr = 0;
  
  
  
      while (threading)
  
      {
  
          if (av_read_frame(formatContext, packet) < 0) {
  
              exit(1);
  
          }
  
  
  
          if (packet->stream_index == streamIndex)
  
          {
  
              int return_value; // = 0;
  
              ctr++;
  
  
  
              do
  
              {
  
                  return_value = avcodec_send_packet(codecContext, packet);
  
              } while (return_value == AVERROR(EAGAIN) && threading);
  
  
  
              //int i = avcodec_send_packet(codecContext, packet);
  
              if (return_value < 0 && threading) { // call Decoder
  
                  cout << "unable to decode video";
  
                  exit(1);
  
              }
  
          }
  
      }
  
  
  
      avcodec_send_packet(codecContext, NULL); // flush decoder
  
  
  
      // return 0;
  
  }
  
  
  
  void Recorder::rescaleVideoStream(AVCodecContext* inCodecContext, AVCodecContext* outCodecContext)
  
  {
  
      bool closing = false;
  
      AVFrame* inFrame = av_frame_alloc();
  
      if (!inFrame)
  
      {
  
          cout << "\nunable to release the avframe resources";
  
          exit(1);
  
      }
  
  
  
      int nbytes = av_image_get_buffer_size(outAVCodecContext->pix_fmt, outAVCodecContext->width, outAVCodecContext->height, 32);
  
      uint8_t* video_outbuf = (uint8_t*)av_malloc(nbytes);
  
      if (video_outbuf == NULL)
  
      {
  
          cout << "\nunable to allocate memory";
  
          exit(1);
  
      }
  
  
  
      AVFrame* outFrame = av_frame_alloc();//Allocate an AVFrame and set its fields to default values.
  
      if (!outFrame)
  
      {
  
          cout << "\nunable to release the avframe resources for outframe";
  
          exit(1);
  
      }
  
  
  
      // Setup the data pointers and linesizes based on the specified image parameters and the provided array.
  
      int value = av_image_fill_arrays(outFrame->data, outFrame->linesize, video_outbuf, AV_PIX_FMT_YUV420P, outAVCodecContext->width, outAVCodecContext->height, 1); // returns : the size in bytes required for src
  
      if (value < 0)
  
      {
  
          cout << "\nerror in filling image array";
  
      }
  
      int ctr = 0;
  
  
  
      while (threading || !closing) {
  
          int value = avcodec_receive_frame(inCodecContext, inFrame);
  
          if (value == 0) {
  
              ctr++;
  
              SwsContext* swsCtx_ = sws_getContext(inCodecContext->width,
  
                  inCodecContext->height,
  
                  inCodecContext->pix_fmt,
  
                  outAVCodecContext->width,
  
                  outAVCodecContext->height,
  
                  outAVCodecContext->pix_fmt,
  
                  SWS_BICUBIC, NULL, NULL, NULL);
  
              sws_scale(swsCtx_, inFrame->data, inFrame->linesize, 0, inCodecContext->height, outFrame->data, outFrame->linesize);
  
  
  
  
  
              int return_value;
  
              do
  
              {
  
                  return_value = avcodec_send_frame(outCodecContext, outFrame);
  
              } while (return_value == AVERROR(EAGAIN) && threading);
  
          }
  
          closing = (value == AVERROR_EOF);
  
      }
  
      avcodec_send_frame(outCodecContext, NULL);
  
  
  
  
  
      // av_free(video_outbuf);
  
  
  
      // return 0;
  
  }
  
  
  
  void Recorder::encodeVideoStream(AVCodecContext* codecContext)
  
  {
  
      bool closing = true;
  
      AVPacket* packet = (AVPacket*)av_malloc(sizeof(AVPacket));
  
      av_init_packet(packet);
  
  
  
      int ctr = 0;
  
  
  
      while (threading || !closing) {
  
          packet->data = NULL;    // packet data will be allocated by the encoder
  
          packet->size = 0;
  
          ctr++;
  
          int value = avcodec_receive_packet(codecContext, packet);
  
          if (value == 0) {
  
              if (packet->pts != AV_NOPTS_VALUE)
  
                  packet->pts = av_rescale_q(packet->pts, video_st->codec->time_base, video_st->time_base);
  
              if (packet->dts != AV_NOPTS_VALUE)
  
                  packet->dts = av_rescale_q(packet->dts, video_st->codec->time_base, video_st->time_base);
  
  
  
              //printf("Write frame %3d (size= %2d)\n", j++, packet->size / 1000);
  
              if (av_write_frame(outAVFormatContext, packet) != 0)
  
              {
  
                  cout << "\nerror in writing video frame";
  
              }
  
          }
  
  
  
          closing = (value == AVERROR_EOF);
  
      }
  
  
  
      value = av_write_trailer(outAVFormatContext);
  
      if (value < 0)
  
      {
  
          cout << "\nerror in writing av trailer";
  
          exit(1);
  
      }
  
  
  
      // av_free(packet);
  
  
  
      // return 0;
  
  }
  
  
  
  
  
  int Recorder::openScreen(AVFormatContext* pFormatCtx) {
  
      /*
  
  
  
      X11 video input device.
  
      To enable this input device during configuration you need libxcb installed on your system. It will be automatically detected during configuration.
  
      This device allows one to capture a region of an X11 display.
  
      refer : https://www.ffmpeg.org/ffmpeg-devices.html#x11grab
  
      */
  
      /* current below is for screen recording. to connect with camera use v4l2 as a input parameter for av_find_input_format */
  
      pAVInputFormat = av_find_input_format("gdigrab");
  
      //value = avformat_open_input(&pAVFormatContext, ":0.0+10,250", pAVInputFormat, NULL);
  
  
  
      value = avformat_open_input(&pAVFormatContext, "desktop", pAVInputFormat, NULL);
  
      if (value != 0)
  
      {
  
          cout << "\nerror in opening input device";
  
          exit(1);
  
      }
  
      return 0;
  
  }