Recherche avancée

Sur d’autres sites (8047)

• Trying to cancel execution and delete file using ffmpeg C API

  6 mars 2020, par Vuwox

  The code below is a class that handle the conversion of multiples images, through add_frame() method, into a GIF with encode(). It also use a filter to generate and apply the palette. The usage is like this :

  Code call example

  std::unique_ptr gif_obj = nullptr;
  
  try
  
  {
  
      gif_obj = std::make_unique({1000,1000}, 12, "C:/out.gif",
  
                "format=pix_fmts=rgb24,split [a][b];[a]palettegen[p];[b][p]paletteuse");
  
  
  
      // Example: a simple vector of images (usually process internally)
  
      for(auto img : image_vector)
  
           gif_obj->add_frame(img);
  
  
  
      // Once all frame were added, encode the final GIF with the filter applied.
  
      gif_obj->encode();
  
  }
  
  catch(const std::exception& e)
  
  {
  
      // An error occured! We must close FFMPEG properly and delete the created file.
  
      gif_obj->cancel();
  
  }

  I have the following issue. If the code for any reason throw an exception, I call ffmpeg->cancel() and it supposes to delete the GIF file on disk. But this is never working, I assume there is a lock on the file or something like that. So here are my question :

  What is the proper way to close/free ffmpeg object in order to remove the file afterward ?

  ---

  Full class code below

  Header

  // C++ Standard includes    
  
  #include <memory>
  
  #include <string>
  
  #include <vector>
  
  
  
  
  
  // 3rd Party incldues
  
  #ifdef __cplusplus
  
  extern "C" {
  
  #include "libavformat/avformat.h"
  
  #include "libavfilter/avfilter.h"
  
  #include "libavutil/opt.h"
  
  #include "libavfilter/buffersrc.h"
  
  #include "libavfilter/buffersink.h"
  
  #include "libswscale/swscale.h"
  
  #include "libavutil/imgutils.h"
  
  }
  
  #endif
  
  
  
  #define FFMPEG_MSG_LEN 2000
  
  
  
  namespace px
  
  {
  
      namespace GIF
  
      {
  
          class FFMPEG
  
          {
  
          public:
  
              FFMPEG(const px::Point2D<int>&amp; dim,
  
                     const int framerate,
  
                     const std::string&amp; filename,
  
                     const std::string&amp; filter_cmd);
  
  
  
              ~FFMPEG();
  
  
  
              void add_frame(pxImage * const img);
  
              void encode();
  
              void cancel();
  
  
  
          private:
  
  
  
              void init_filters();            // Init everything that needed to filter the input frame.
  
              void init_muxer();              // The muxer that creates the output file.
  
              void muxing_one_frame(AVFrame* frame);
  
              void release();
  
  
  
              int _ret = 0;                   // status code from FFMPEG.
  
              char _err_msg[FFMPEG_MSG_LEN];  // Error message buffer.
  
  
  
  
  
              int m_width = 0;                // The width that all futur images must have to be accepted.
  
              int m_height = 0;               // The height that all futur images must have to be accepted.
  
  
  
              int m_framerate = 0;            // GIF Framerate.
  
              std::string m_filename = "";    // The GIF filename (on cache?)
  
              std::string m_filter_desc = ""; // The FFMPEG filter to apply over the frames.
  
  
  
              bool as_frame = false;
  
  
  
              AVFrame* picture_rgb24 = nullptr;           // Temporary frame that will hold the pxImage in an RGB24 format (NOTE: TOP-LEFT origin)
  
  
  
              AVFormatContext* ofmt_ctx = nullptr;        // ouput format context associated to the 
  
              AVCodecContext* o_codec_ctx = nullptr;      // output codec for the GIF
  
  
  
              AVFilterGraph* filter_graph = nullptr;      // filter graph associate with the string we want to execute
  
              AVFilterContext* buffersrc_ctx = nullptr;   // The buffer that will store all the frames in one place for the palette generation.
  
              AVFilterContext* buffersink_ctx = nullptr;  // The buffer that will store the result afterward (once the palette are used).
  
  
  
              int64_t m_pts_increment = 0;
  
          };
  
      };
  
  };
  
  </int></vector></string></memory>

  ctor

  px::GIF::FFMPEG::FFMPEG(const px::Point2D<int>&amp; dim,
  
                          const int framerate,
  
                          const std::string&amp; filename,
  
                          const std::string&amp; filter_cmd) :
  
      m_width(dim.x()),
  
      m_height(dim.y()),
  
      m_framerate(framerate),
  
      m_filename(filename),
  
      m_filter_desc(filter_cmd)
  
  {
  
  #if !_DEBUG
  
      av_log_set_level(AV_LOG_QUIET); // Set the FFMPEG log to quiet to avoid too much logs.
  
  #endif
  
  
  
      // Allocate the temporary buffer that hold the ffmpeg image (pxImage to AVFrame conversion).
  
      picture_rgb24 = av_frame_alloc();
  
      picture_rgb24->pts = 0;
  
      picture_rgb24->data[0] = NULL;
  
      picture_rgb24->linesize[0] = -1;
  
      picture_rgb24->format = AV_PIX_FMT_RGB24;
  
      picture_rgb24->height = m_height;
  
      picture_rgb24->width = m_width; 
  
  
  
      if ((_ret = av_image_alloc(picture_rgb24->data, picture_rgb24->linesize, m_width, m_height, (AVPixelFormat)picture_rgb24->format, 24)) &lt; 0)
  
          throw px::GIF::Error("Failed to allocate the AVFrame for pxImage conversion with error: " +
  
                               std::string(av_make_error_string(_err_msg, FFMPEG_MSG_LEN, _ret)),
  
                               "GIF::FFMPEG CTOR");   
  
  
  
      //printf("allocated picture of size %d, linesize %d %d %d %d\n", _ret, picture_rgb24->linesize[0], picture_rgb24->linesize[1], picture_rgb24->linesize[2], picture_rgb24->linesize[3]);
  
  
  
      init_muxer();   // Prepare the GIF encoder (open it on disk).
  
      init_filters(); // Prepare the filter that will be applied over the frame.
  
  
  
      // Instead of hardcoder {1,100} which is the GIF tbn, we collect it from its stream.
  
      // This will avoid future problem if the codec change in ffmpeg.
  
      if (ofmt_ctx &amp;&amp; ofmt_ctx->nb_streams > 0)
  
          m_pts_increment = av_rescale_q(1, { 1, m_framerate }, ofmt_ctx->streams[0]->time_base);
  
      else
  
          m_pts_increment = av_rescale_q(1, { 1, m_framerate }, { 1, 100 });
  
  }
  
  </int>

  FFMPEG Initialization (Filter and muxer)

  void px::GIF::FFMPEG::init_filters()
  
  {
  
      const AVFilter* buffersrc = avfilter_get_by_name("buffer");
  
      const AVFilter* buffersink = avfilter_get_by_name("buffersink");
  
  
  
      AVRational time_base = { 1, m_framerate };
  
      AVRational aspect_pixel = { 1, 1 };
  
  
  
      AVFilterInOut* inputs = avfilter_inout_alloc();
  
      AVFilterInOut* outputs = avfilter_inout_alloc();
  
  
  
      filter_graph = avfilter_graph_alloc();
  
  
  
      try
  
      {
  
          if (!outputs || !inputs || !filter_graph)
  
              throw px::GIF::Error("Failed to 'init_filters' could not allocated the graph/filters.", "GIF::FFMPEG init_filters");
  
  
  
          char args[512];
  
          snprintf(args, sizeof(args),
  
                   "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
  
                   m_width, m_height,
  
                   picture_rgb24->format,
  
                   time_base.num, time_base.den,
  
                   aspect_pixel.num, aspect_pixel.den);
  
  
  
          if (avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, nullptr, filter_graph) < 0)
  
              throw px::GIF::Error("Failed to create the 'source buffer' in init_filer method.", "GIF::FFMPEG init_filters");
  
  
  
  
  
          if (avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", nullptr, nullptr, filter_graph) < 0)
  
              throw px::GIF::Error("Failed to create the 'sink buffer' in init_filer method.", "GIF::FFMPEG init_filters");
  
  
  
          // GIF has possible output of PAL8.
  
          enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE };
  
  
  
          if (av_opt_set_int_list(buffersink_ctx, "pix_fmts", pix_fmts, AV_PIX_FMT_NONE, AV_OPT_SEARCH_CHILDREN) < 0)
  
              throw px::GIF::Error("Failed to set the output pixel format.", "GIF::FFMPEG init_filters");
  
  
  
          outputs->name = av_strdup("in");
  
          outputs->filter_ctx = buffersrc_ctx;
  
          outputs->pad_idx = 0;
  
          outputs->next = nullptr;
  
  
  
          inputs->name = av_strdup("out");
  
          inputs->filter_ctx = buffersink_ctx;
  
          inputs->pad_idx = 0;
  
          inputs->next = nullptr;
  
  
  
          // GIF has possible output of PAL8. 
  
          if (avfilter_graph_parse_ptr(filter_graph, m_filter_desc.c_str(), &inputs, &outputs, nullptr) < 0)
  
              throw px::GIF::Error("Failed to parse the filter graph (bad string!).", "GIF::FFMPEG init_filters");
  
  
  
          if (avfilter_graph_config(filter_graph, nullptr) < 0)
  
              throw px::GIF::Error("Failed to configure the filter graph (bad string!).", "GIF::FFMPEG init_filters");
  
  
  
          avfilter_inout_free(&inputs);
  
          avfilter_inout_free(&outputs);
  
      }
  
      catch (const std::exception& e)
  
      {
  
          // Catch exception to delete element.
  
          avfilter_inout_free(&inputs);
  
          avfilter_inout_free(&outputs);
  
          throw e; // re-throuw
  
      }
  
  }
  
  
  
  
  
  void px::GIF::FFMPEG::init_muxer()
  
  {
  
      AVOutputFormat* o_fmt = av_guess_format("gif", m_filename.c_str(), "video/gif");
  
  
  
      if ((_ret = avformat_alloc_output_context2(&ofmt_ctx, o_fmt, "gif", m_filename.c_str())) < 0)
  
          throw px::GIF::Error(std::string(av_make_error_string(_err_msg, FFMPEG_MSG_LEN, _ret)) + " allocate output format.", "GIF::FFMPEG init_muxer");
  
  
  
      AVCodec* codec = avcodec_find_encoder(AV_CODEC_ID_GIF);
  
      if (!codec) throw px::GIF::Error("Could to find the 'GIF' codec.", "GIF::FFMPEG init_muxer");
  
  
  
  #if 0
  
      const AVPixelFormat* p = codec->pix_fmts;
  
      while (p != NULL && *p != AV_PIX_FMT_NONE) {
  
          printf("supported pix fmt: %s\n", av_get_pix_fmt_name(*p));
  
          ++p;
  
      }
  
  #endif
  
  
  
      AVStream* stream = avformat_new_stream(ofmt_ctx, codec);
  
  
  
      AVCodecParameters* codec_paramters = stream->codecpar;
  
      codec_paramters->codec_tag = 0;
  
      codec_paramters->codec_id = codec->id;
  
      codec_paramters->codec_type = AVMEDIA_TYPE_VIDEO;
  
      codec_paramters->width = m_width;
  
      codec_paramters->height = m_height;
  
      codec_paramters->format = AV_PIX_FMT_PAL8;
  
  
  
      o_codec_ctx = avcodec_alloc_context3(codec);
  
      avcodec_parameters_to_context(o_codec_ctx, codec_paramters);
  
  
  
      o_codec_ctx->time_base = { 1, m_framerate };
  
  
  
      if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
  
          o_codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
  
  
      if ((_ret = avcodec_open2(o_codec_ctx, codec, NULL)) < 0)
  
          throw px::GIF::Error(std::string(av_make_error_string(_err_msg, FFMPEG_MSG_LEN, _ret)) + " open output codec.", "GIF::FFMPEG init_muxer");
  
  
  
      if ((_ret = avio_open(&ofmt_ctx->pb, m_filename.c_str(), AVIO_FLAG_WRITE)) < 0)
  
          throw px::GIF::Error(std::string(av_make_error_string(_err_msg, FFMPEG_MSG_LEN, _ret)) + " avio open error.", "GIF::FFMPEG init_muxer");
  
  
  
      if ((_ret = avformat_write_header(ofmt_ctx, NULL)) < 0)
  
          throw px::GIF::Error(std::string(av_make_error_string(_err_msg, FFMPEG_MSG_LEN, _ret)) + " write GIF header", "GIF::FFMPEG init_muxer");
  
  
  
  #if _DEBUG
  
      // This print the stream/output format.
  
      av_dump_format(ofmt_ctx, -1, m_filename.c_str(), 1);
  
  #endif
  
  }

  Add frame (usually in a loop)

  void px::GIF::FFMPEG::add_frame(pxImage * const img)
  
  {
  
      if (img->getImageType() != PXT_BYTE || img->getNChannels() != 4)
  
          throw px::GIF::Error("Failed to 'add_frame' since image is not PXT_BYTE and 4-channels.", "GIF::FFMPEG add_frame");
  
  
  
      if (img->getWidth() != m_width || img->getHeight() != m_height)
  
          throw px::GIF::Error("Failed to 'add_frame' since the size is not same to other inputs.", "GIF::FFMPEG add_frame");
  
  
  
      const int pitch = picture_rgb24->linesize[0];
  
      auto px_ptr = getImageAccessor(img);
  
  
  
      for (int y = 0; y < m_height; y++)
  
      {
  
          const int px_row = img->getOrigin() == ORIGIN_BOT_LEFT ? m_height - y - 1 : y;
  
          for (int x = 0; x < m_width; x++)
  
          {
  
              const int idx = y * pitch + 3 * x;
  
              picture_rgb24->data[0][idx] = px_ptr[px_row][x].ch[PX_RE];
  
              picture_rgb24->data[0][idx + 1] = px_ptr[px_row][x].ch[PX_GR];
  
              picture_rgb24->data[0][idx + 2] = px_ptr[px_row][x].ch[PX_BL];
  
          }
  
      }
  
  
  
      // palettegen need a whole stream, just add frame to buffer.
  
      if ((_ret = av_buffersrc_add_frame_flags(buffersrc_ctx, picture_rgb24, AV_BUFFERSRC_FLAG_KEEP_REF)) < 0)
  
          throw px::GIF::Error("Failed to 'add_frame' to global buffer with error: " +
  
                               std::string(av_make_error_string(_err_msg, FFMPEG_MSG_LEN, _ret)),
  
                               "GIF::FFMPEG add_frame");
  
  
  
      // Increment the FPS of the picture for the next add-up to the buffer.      
  
      picture_rgb24->pts += m_pts_increment;
  
  
  
      as_frame = true;
  
  }    

  Encoder (final step)

  void px::GIF::FFMPEG::encode()
  
  {
  
      if (!as_frame)
  
          throw px::GIF::Error("Please 'add_frame' before running the Encoding().", "GIF::FFMPEG encode");
  
  
  
      // end of buffer
  
      if ((_ret = av_buffersrc_add_frame_flags(buffersrc_ctx, nullptr, AV_BUFFERSRC_FLAG_KEEP_REF)) < 0)
  
          throw px::GIF::Error("error add frame to buffer source: " + std::string(av_make_error_string(_err_msg, FFMPEG_MSG_LEN, _ret)), "GIF::FFMPEG encode");
  
  
  
      do {
  
          AVFrame* filter_frame = av_frame_alloc();
  
          _ret = av_buffersink_get_frame(buffersink_ctx, filter_frame);
  
          if (_ret == AVERROR(EAGAIN) || _ret == AVERROR_EOF) {
  
              av_frame_unref(filter_frame);
  
              break;
  
          }
  
  
  
          // write the filter frame to output file
  
          muxing_one_frame(filter_frame);
  
  
  
          av_frame_unref(filter_frame);
  
      } while (_ret >= 0);
  
  
  
      av_write_trailer(ofmt_ctx);
  
  }
  
  
  
  void px::GIF::FFMPEG::muxing_one_frame(AVFrame* frame)
  
  {
  
      int ret = avcodec_send_frame(o_codec_ctx, frame);
  
      AVPacket *pkt = av_packet_alloc();
  
      av_init_packet(pkt);
  
  
  
      while (ret >= 0) {
  
          ret = avcodec_receive_packet(o_codec_ctx, pkt);
  
          if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
  
              break;
  
          }
  
  
  
          av_write_frame(ofmt_ctx, pkt);
  
      }
  
      av_packet_unref(pkt);
  
  }

  DTOR, Release and Cancel

  px::GIF::FFMPEG::~FFMPEG()
  
  {
  
      release();
  
  }
  
  
  
  
  
  void px::GIF::FFMPEG::release()
  
  {
  
      // Muxer stuffs
  
      if (ofmt_ctx != nullptr) avformat_free_context(ofmt_ctx);
  
      if (o_codec_ctx != nullptr) avcodec_close(o_codec_ctx);
  
      if (o_codec_ctx != nullptr) avcodec_free_context(&o_codec_ctx);
  
  
  
      ofmt_ctx = nullptr;
  
      o_codec_ctx = nullptr;
  
  
  
      // Filter stuffs
  
      if (buffersrc_ctx != nullptr) avfilter_free(buffersrc_ctx);
  
      if (buffersink_ctx != nullptr) avfilter_free(buffersink_ctx);
  
      if (filter_graph != nullptr) avfilter_graph_free(&filter_graph);
  
  
  
      buffersrc_ctx = nullptr;
  
      buffersink_ctx = nullptr;
  
      filter_graph = nullptr;
  
  
  
      // Conversion image.
  
      if (picture_rgb24 != nullptr) av_frame_free(&picture_rgb24);
  
      picture_rgb24 = nullptr;
  
  }
  
  
  
  void px::GIF::FFMPEG::cancel()
  
  {
  
      // In-case of failure we must close ffmpeg and exit.
  
      av_write_trailer(ofmt_ctx);
  
  
  
      // Release and close all elements.
  
      release();
  
  
  
      // Delete the file on disk.
  
      if (remove(m_filename.c_str()) != 0)
  
          PX_LOG0(PX_LOGLEVEL_ERROR, "GIF::FFMPEG - On 'cancel' failed to remove the file.");
  
  }

• When i used ffmpeg to trim a video ,i observed an error [closed]

  6 mars 2020, par israfilll

  i wanna use ffmpeg to trim a video but when i build app i see this I/System.out : ssssCANNOT LINK EXECUTABLE "/data/user/0/com.example.newapplication/files/ffmpeg" : "/data/data/com.example.newapplication/files/ffmpeg" has text relocations (https://android.googlesource.com/platform/bionic/+/master/androg-’changes-for-ndk-developers.md#Text-Relocations-Enforced-for-API-level-23)

  why didn’t i use this library

  public class MainActivity extends AppCompatActivity {
  
  String outPutFile;
  
  Uri filePath, filePathSecond, photoUri, AudioUri;
  
  ProgressDialog progressDialog;
  
  private int REQUEST_TAKE_GALLERY_VIDEO = 110;
  
  private int REQUEST_TAKE_GALLERY_VIDEO_2 = 115;
  
  private FFmpeg ffmpeg;
  
  
  
  @Override
  
  protected void onCreate(Bundle savedInstanceState) {
  
      super.onCreate(savedInstanceState);
  
      setContentView(R.layout.activity_main);
  
      if(ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE)
  
              != PackageManager.PERMISSION_GRANTED){
  
          ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},1);
  
  
  
  
  
      }
  
      progressDialog = new ProgressDialog(this);
  
      findViewById(R.id.selectVideo).setOnClickListener(new View.OnClickListener() {
  
          @Override
  
          public void onClick(View v) {
  
              Intent intent = new Intent();
  
              intent.setType("video/*");
  
              intent.setAction(Intent.ACTION_GET_CONTENT);
  
              startActivityForResult(Intent.createChooser(intent, "Select Video"), REQUEST_TAKE_GALLERY_VIDEO);
  
          }
  
      });
  
      findViewById(R.id.start).setOnClickListener(new View.OnClickListener() {
  
          @Override
  
          public void onClick(View v) {
  
              if (filePath != null) {
  
                  executeCutVideoCommand(1000, 4 * 1000, filePath);
  
              }
  
          }
  
      });
  
  
  
  
  
  
  
      findViewById(R.id.marge_video).setOnClickListener(new View.OnClickListener() {
  
          @Override
  
          public void onClick(View v) {
  
              if (filePath != null && filePathSecond != null)
  
                  executeMargeVideoCommand(filePath, filePathSecond);
  
          }
  
      });
  
      findViewById(R.id.selectVideo_2).setOnClickListener(new View.OnClickListener() {
  
          @Override
  
          public void onClick(View v) {
  
              Intent intent = new Intent();
  
              intent.setType("video/*");
  
              intent.setAction(Intent.ACTION_GET_CONTENT);
  
              startActivityForResult(Intent.createChooser(intent, "Select Video"), REQUEST_TAKE_GALLERY_VIDEO_2);
  
          }
  
      });
  
  
  
      findViewById(R.id.filter_video).setOnClickListener(new View.OnClickListener() {
  
          @Override
  
          public void onClick(View v) {
  
              if(filePath!=null){
  
                  executeFilterCommand(filePath);
  
              }
  
          }
  
      });
  
      loadFFMpegBinary();
  
  }
  
  
  
  
  
  @Override
  
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
  
      super.onActivityResult(requestCode, resultCode, data);
  
      if (requestCode == REQUEST_TAKE_GALLERY_VIDEO) {
  
          Uri uri = data.getData();
  
          if (uri != null) {
  
              filePath = uri;
  
          }
  
      }
  
      if (requestCode == REQUEST_TAKE_GALLERY_VIDEO_2) {
  
          Uri uri = data.getData();
  
          if (uri != null) {
  
              filePathSecond = uri;
  
          }
  
      }
  
  
  
  
  
  }
  
  
  
  
  
  
  
  // video trim
  
  private void executeCutVideoCommand(int startMs, int endMs, Uri filePath) {
  
      File moviesDir = Environment.getExternalStoragePublicDirectory(
  
              Environment.DIRECTORY_MOVIES
  
      );
  
      String filePrefix = "cut_video";
  
      String fileExtn = ".mp4";
  
      String yourRealPath = getPath(MainActivity.this, filePath);
  
      File dest = new File(moviesDir, filePrefix + fileExtn);
  
      int fileNo = 0;
  
      while (dest.exists()) {
  
          fileNo++;
  
          dest = new File(moviesDir, filePrefix + fileNo + fileExtn);
  
      }
  
     /* Log.d(TAG, "startTrim: src: " + yourRealPath);
  
      Log.d(TAG, "startTrim: dest: " + dest.getAbsolutePath());
  
      Log.d(TAG, "startTrim: startMs: " + startMs);
  
      Log.d(TAG, "startTrim: endMs: " + endMs);*/
  
      outPutFile = dest.getAbsolutePath();
  
      //String[] complexCommand = {"-i", yourRealPath, "-ss", "" + startMs / 1000, "-t", "" + endMs / 1000, dest.getAbsolutePath()};
  
      String[] complexCommand = {"-ss",
  
              "" + (startMs / 1000),
  
              "-y",
  
              "-i",
  
              yourRealPath,
  
              "-t",
  
              "" + ((endMs - startMs) / 1000),
  
              "-vcodec",
  
              "mpeg4",
  
              "-b:v",
  
              "2097152",
  
              "-b:a",
  
              "48000",
  
              "-ac",
  
              "2",
  
              "-ar",
  
              "22050",
  
              outPutFile};
  
      execFFmpegBinary(complexCommand);
  
  }
  
  
  
  private String getPath(final Context context, final Uri uri) {
  
      final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
  
      // DocumentProvider
  
      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
  
          if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
  
              // ExternalStorageProvider
  
              if (isExternalStorageDocument(uri)) {
  
                  final String docId = DocumentsContract.getDocumentId(uri);
  
                  final String[] split = docId.split(":");
  
                  final String type = split[0];
  
                  if ("primary".equalsIgnoreCase(type)) {
  
                      return Environment.getExternalStorageDirectory() + "/" + split[1];
  
                  }
  
                  // TODO handle non-primary volumes
  
              }
  
              // DownloadsProvider
  
              else if (isDownloadsDocument(uri)) {
  
                  final String id = DocumentsContract.getDocumentId(uri);
  
                  final Uri contentUri = ContentUris.withAppendedId(
  
                          Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
  
                  return getDataColumn(context, contentUri, null, null);
  
              }
  
              // MediaProvider
  
              else if (isMediaDocument(uri)) {
  
                  final String docId = DocumentsContract.getDocumentId(uri);
  
                  final String[] split = docId.split(":");
  
                  final String type = split[0];
  
                  Uri contentUri = null;
  
                  if ("image".equals(type)) {
  
                      contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
  
                  } else if ("video".equals(type)) {
  
                      contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
  
                  } else if ("audio".equals(type)) {
  
                      contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
  
                  }
  
                  final String selection = "_id=?";
  
                  final String[] selectionArgs = new String[]{
  
                          split[1]
  
                  };
  
                  return getDataColumn(context, contentUri, selection, selectionArgs);
  
              }
  
          }
  
          // MediaStore (and general)
  
          else if ("content".equalsIgnoreCase(uri.getScheme())) {
  
              return getDataColumn(context, uri, null, null);
  
          }
  
          // File
  
          else if ("file".equalsIgnoreCase(uri.getScheme())) {
  
              return uri.getPath();
  
          }
  
      }
  
      return null;
  
  }
  
  
  
  private boolean isExternalStorageDocument(Uri uri) {
  
      return "com.android.externalstorage.documents".equals(uri.getAuthority());
  
  }
  
  
  
  /**
  
   * @param uri The Uri to check.
  
   * @return Whether the Uri authority is DownloadsProvider.
  
   */
  
  private boolean isDownloadsDocument(Uri uri) {
  
      return "com.android.providers.downloads.documents".equals(uri.getAuthority());
  
  }
  
  
  
  /**
  
   * @param uri The Uri to check.
  
   * @return Whether the Uri authority is MediaProvider.
  
   */
  
  private boolean isMediaDocument(Uri uri) {
  
      return "com.android.providers.media.documents".equals(uri.getAuthority());
  
  }
  
  
  
  private String getDataColumn(Context context, Uri uri, String selection,
  
                               String[] selectionArgs) {
  
      Cursor cursor = null;
  
      final String column = "_data";
  
      final String[] projection = {
  
              column
  
      };
  
      try {
  
          cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
  
                  null);
  
          if (cursor != null && cursor.moveToFirst()) {
  
              final int column_index = cursor.getColumnIndexOrThrow(column);
  
              return cursor.getString(column_index);
  
          }
  
      } finally {
  
          if (cursor != null)
  
              cursor.close();
  
      }
  
      return null;
  
  }
  
  
  
  private void loadFFMpegBinary() {
  
      try {
  
          if (ffmpeg == null) {
  
              ffmpeg = FFmpeg.getInstance(this);
  
          }
  
          ffmpeg.loadBinary(new LoadBinaryResponseHandler() {
  
              @Override
  
              public void onFailure() {
  
              }
  
  
  
              @Override
  
              public void onSuccess() {
  
              }
  
          });
  
      } catch (FFmpegNotSupportedException e) {
  
      } catch (Exception e) {
  
      }
  
  }
  
  
  
  private void execFFmpegBinary(final String[] command) {
  
      progressDialog.show();
  
      try {
  
          ffmpeg.execute(command, new ExecuteBinaryResponseHandler() {
  
              @Override
  
              public void onFailure(String s) {
  
  
  
  
  
                  System.out.println("ssss"+s);
  
              }
  
  
  
              @Override
  
              public void onSuccess(String s) {
  
                  //    Log.d(TAG, "SUCCESS with output : " + s);
  
                  Toast.makeText(MainActivity.this, "SUCCESS" + outPutFile, Toast.LENGTH_LONG).show();
  
              }
  
  
  
              @Override
  
              public void onProgress(String s) {
  
              }
  
  
  
              @Override
  
              public void onStart() {
  
                  progressDialog.setMessage("Processing...");
  
                  progressDialog.show();
  
              }
  
  
  
              @Override
  
              public void onFinish() {
  
                  progressDialog.dismiss();
  
              }
  
          });
  
      } catch (Exception e ) {
  
          Toast.makeText(MainActivity.this, "EXCEPTION", Toast.LENGTH_LONG).show();
  
  
  
          // do nothing for now
  
      }
  
  }
  
  
  
  
  
  private void executeMargeVideoCommand(Uri filePath, Uri filePathSecond) {
  
      File moviesDir = Environment.getExternalStoragePublicDirectory(
  
              Environment.DIRECTORY_MOVIES
  
      );
  
      String filePrefix = "marge_change_video";
  
      String fileExtn = ".mp4";
  
      String yourRealPath = getPath(MainActivity.this, filePath);
  
      String yourRealPath2 = getPath(MainActivity.this, filePathSecond);
  
      File dest = new File(moviesDir, filePrefix + fileExtn);
  
      int fileNo = 0;
  
      while (dest.exists()) {
  
          fileNo++;
  
          dest = new File(moviesDir, filePrefix + fileNo + fileExtn);
  
      }
  
  
  
      outPutFile = dest.getAbsolutePath();
  
      String complexCommand[] = {"-y", "-i", yourRealPath, "-i", yourRealPath2, "-strict", "experimental", "-filter_complex",
  
              "[0:v]scale=iw*min(1920/iw\\,1080/ih):ih*min(1920/iw\\,1080/ih), pad=1920:1080:(1920-iw*min(1920/iw\\,1080/ih))/2:(1080-ih*min(1920/iw\\,1080/ih))/2,setsar=1:1[v0];[1:v] scale=iw*min(1920/iw\\,1080/ih):ih*min(1920/iw\\,1080/ih), pad=1920:1080:(1920-iw*min(1920/iw\\,1080/ih))/2:(1080-ih*min(1920/iw\\,1080/ih))/2,setsar=1:1[v1];[v0][0:a][v1][1:a] concat=n=2:v=1:a=1",
  
              "-ab", "48000", "-ac", "2", "-ar", "22050", "-s", "1920x1080", "-vcodec", "libx264", "-crf", "27",
  
              "-q", "4", "-preset", "ultrafast", outPutFile};
  
      execFFmpegBinary(complexCommand);
  
  }
  
  
  
  
  
  private void executeFilterCommand(Uri filePath) {
  
      File moviesDir = Environment.getExternalStoragePublicDirectory(
  
              Environment.DIRECTORY_MOVIES
  
      );
  
      String filePrefix = "filter_change_video";
  
      String fileExtn = ".mp4";
  
      String yourRealPath = getPath(MainActivity.this, filePath);
  
      File dest = new File(moviesDir, filePrefix + fileExtn);
  
      int fileNo = 0;
  
      while (dest.exists()) {
  
          fileNo++;
  
          dest = new File(moviesDir, filePrefix + fileNo + fileExtn);
  
      }
  
  
  
      outPutFile = dest.getAbsolutePath();
  
      //  String complexCommand[] = {"-i", yourRealPath,"-r", "15", "-aspect" ,""+w+":"+""+h ,"-strict" ,"-2",outPutFile};
  
      String complexCommand[] = { "-i",yourRealPath,"-vf", "split [main][tmp]; [tmp] lutyuv=","y=val*5"," [tmp2]; [main][tmp2] overlay", outPutFile};
  
      execFFmpegBinary(complexCommand);
  
  }

  }

• X264 : How to access NAL units from encoder ?

  18 avril 2014, par user1884325

  When I call

  frame_size = x264_encoder_encode(encoder, &nals, &i_nals, &pic_in, &pic_out);

  and subsequently write each NAL to a file like this :

       if (frame_size >= 0)
  
       {
  
          int i;
  
          int j;
  
  
  
          for (i = 0; i < i_nals; i++)
  
          {
  
             printf("******************* NAL %d (%d bytes) *******************\n", i, nals[i].i_payload);
  
             fwrite(&(nals[i].p_payload[0]), 1, nals[i].i_payload, fid);
  
          }
  
       }

  then I get this

  

  My questions are :

  1) Is it normal that there’s readable parameters in the beginning of the file ?

  2) How do I configure the X264 encoder so that the encoder returns frames that I can send via UDP without the packet getting fragmented (size must be below 1390 or somewhere around that).

  3) With the x264.exe I pass in these options :

  "--threads 1 --profile baseline --level 3.2 --preset ultrafast --bframes 0 --force-cfr --no-mbtree --sync-lookahead 0 --rc-lookahead 0 --keyint 1000 --intra-refresh" 

  How do I map those to the settings in the X264 parameters structure ? (x264_param_t)

  4) I have been told that the x264 static library doesn’t support bitmap input to the encoder and that I have to use libswscale for conversion of the 24bit RGB input bitmap to YUV2. The encoder, supposedly, only takes YUV2 as input ? Is this true ? If so, how do I build libswscale for the x264 static library ?