Recherche avancée

Sur d’autres sites (7556)

• Does FFMPEG apply a blur filter after scaling ?

  2 mars 2018, par Pedro Pereira

  So I am implementing my own version of bilinear scaling and comparing results with FFMPEG and ImageMagick. These tools create a scaled version of my image but it seems the results are not obtained only by applying the interpolation operations, it seems the result suffer a blur to smooth out jaggyness after the scaling.
  Here is what I mean.

  This is the original image (6x6 yuv422p) :

  https://snag.gy/Z5pa8f.jpg

  As you can see, there are only black and white columns.
  After my scaling operation with a bilinear filter I get gray columns between the black and white ones, which is expected. This is my result :

  My image (12x12 yuv422p) :

  https://snag.gy/deMJy1.jpg

  Now the problem is the result of FFMPEG. As I will show next, the FFMPEG creates an image with only a black and white column, the rest are only shades of grey which does not makes sense with bilinear filtering.

  FFMPEG image (12x12 yuv422p) :

  https://snag.gy/prz54g.jpg

  Can someone please enlight me about what FFMPEG does in this conditions ?

      // Iterate through each line
  
      for(int lin = 0; lin < dstHeight; lin++){
  
          // Get line in original image
  
          int linOrig = lin / scaleHeightRatio;
  
          float linOrigRemainder = fmod(lin, scaleHeightRatio);
  
          float linDist = linOrigRemainder / scaleHeightRatio;
  
  
  
          // For border pixels
  
          int linIndexA = linOrig;
  
          int linIndexB = linOrig + 1;
  
          if(linIndexB >= srcHeight)
  
              linIndexB = linIndexA;
  
          linIndexA *= srcWidth;
  
          linIndexB *= srcWidth;
  
  
  
          // Iterate through each column
  
          for(int col = 0; col < dstWidth; col++){
  
              // Get column in original image
  
              int colOrig = col / scaleWidthRatio;
  
              float colOrigRemainder = fmod(col, scaleWidthRatio);
  
              float colDist = colOrigRemainder / scaleWidthRatio;
  
  
  
              // If same position as an original pixel
  
              if(linOrigRemainder == 0 && colOrigRemainder == 0){
  
                  // Original pixel to the result
  
                  dstSlice[0][lin * dstWidth + col] = srcSlice[0][linOrig * srcWidth + colOrig];
  
                  dstSlice[1][lin * dstWidth + col] = srcSlice[1][linOrig * srcWidth + colOrig];
  
                  dstSlice[2][lin * dstWidth + col] = srcSlice[2][linOrig * srcWidth + colOrig];
  
  
  
                  // Continue processing following pixels
  
                  continue;
  
              }
  
  
  
              // For border pixels
  
              int colIndexA = colOrig;
  
              int colIndexB = colOrig + 1;
  
              if(colIndexB >= srcWidth)
  
                  colIndexB = colIndexA;
  
  
  
              // Perform interpolation
  
          }
  
      }

• very low latency streaminig with ffmpeg using a webcam

  5 avril, par userDtrm

  I'm trying to configure ffmpeg to do a real-time video streaming using a webcam. The ffmpeg encoder command I use is as follows.

  



  ffmpeg -f v4l2 -input_format yuyv422 -s 640x480 -i /dev/video0 -c:v libx264 -profile:v baseline -trellis 0 -subq 1 -level 32 -preset superfast -tune zerolatency -me_method epzs -crf 30 -threads 0 -bufsize 1 -refs 4 -coder 0 -b_strategy 0 -bf 0 -sc_threshold 0 -x264-params vbv-maxrate=2000:slice-max-size=1500:keyint=30:min-keyint=10: -pix_fmt yuv420p -an -f mpegts udp://192.168.1.8:5001


  



  The ffplay command used to display the video feed is,

  



  ffplay -analyzeduration 1 -fflags -nobuffer -i udp://192.168.1.8:5001


  



  However, I'm experiencing a latency of 0.5 - 1.0s latency in the video stream. Is there a way to reduce this to a number less than 100ms. Also, when I replace the v4l2 camera capture with a screen capture using x11grab, the stream is almost real-time and I experience no noticeable delays. Moreover, changing the encoder from x264 to mpeg2 had no effect on the latency. In addition, the statistics from the ffmpeg shows that the encoder is performing at a 30fps rate, which I believe indicates that the encoding is real-time. This leaves me with only one reason for the experienced delay.

  



  

  • Is there a significant delay in buffers when using v4l2 during video capturing in a webcam ?

  


  • I don't think the transmission delay is in effect in this case as I see no latencies when screen capture is used under the same conditions.

  


  • Can this latency be further reduced ?. Can someone think of a different encoder configuration to be used instead of the one that I've been using ?

  


  


• how can I copy file frame by frame to get exactly the same file ? (FFmpeg)

  14 février 2018, par user3360601

  I was using an ffmpeg example from original source remuxing.c to copy file by frames. It works, but the result file has another structure inside.

  From the left is original file. It has "framerate" field. Moreover, the copy file has smaller size. On 18 bytes less.

  Question : how can I copy file frame by frame to get exactly the same file ? Including "framerate" field and total size ?

  Code from the source site.

      /*
  
   * Copyright (c) 2013 Stefano Sabatini
  
   *
  
   * Permission is hereby granted, free of charge, to any person obtaining a copy
  
   * of this software and associated documentation files (the "Software"), to deal
  
   * in the Software without restriction, including without limitation the rights
  
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  
   * copies of the Software, and to permit persons to whom the Software is
  
   * furnished to do so, subject to the following conditions:
  
   *
  
   * The above copyright notice and this permission notice shall be included in
  
   * all copies or substantial portions of the Software.
  
   *
  
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  
   * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  
   * THE SOFTWARE.
  
   */
  
  
  
  /**
  
   * @file
  
   * libavformat/libavcodec demuxing and muxing API example.
  
   *
  
   * Remux streams from one container format to another.
  
   * @example remuxing.c
  
   */
  
  
  
  #include <libavutil></libavutil>timestamp.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  
  
  static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt, const char *tag)
  
  {
  
      AVRational *time_base = &amp;fmt_ctx->streams[pkt->stream_index]->time_base;
  
  
  
      printf("%s: pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",
  
             tag,
  
             av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, time_base),
  
             av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, time_base),
  
             av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, time_base),
  
             pkt->stream_index);
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      AVOutputFormat *ofmt = NULL;
  
      AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
  
      AVPacket pkt;
  
      const char *in_filename, *out_filename;
  
      int ret, i;
  
      int stream_index = 0;
  
      int *stream_mapping = NULL;
  
      int stream_mapping_size = 0;
  
  
  
      if (argc &lt; 3) {
  
          printf("usage: %s input output\n"
  
                 "API example program to remux a media file with libavformat and libavcodec.\n"
  
                 "The output format is guessed according to the file extension.\n"
  
                 "\n", argv[0]);
  
          return 1;
  
      }
  
  
  
      in_filename  = argv[1];
  
      out_filename = argv[2];
  
  
  
      av_register_all();
  
  
  
      if ((ret = avformat_open_input(&amp;ifmt_ctx, in_filename, 0, 0)) &lt; 0) {
  
          fprintf(stderr, "Could not open input file '%s'", in_filename);
  
          goto end;
  
      }
  
  
  
      if ((ret = avformat_find_stream_info(ifmt_ctx, 0)) &lt; 0) {
  
          fprintf(stderr, "Failed to retrieve input stream information");
  
          goto end;
  
      }
  
  
  
      av_dump_format(ifmt_ctx, 0, in_filename, 0);
  
  
  
      avformat_alloc_output_context2(&amp;ofmt_ctx, NULL, NULL, out_filename);
  
      if (!ofmt_ctx) {
  
          fprintf(stderr, "Could not create output context\n");
  
          ret = AVERROR_UNKNOWN;
  
          goto end;
  
      }
  
  
  
      stream_mapping_size = ifmt_ctx->nb_streams;
  
      stream_mapping = av_mallocz_array(stream_mapping_size, sizeof(*stream_mapping));
  
      if (!stream_mapping) {
  
          ret = AVERROR(ENOMEM);
  
          goto end;
  
      }
  
  
  
      ofmt = ofmt_ctx->oformat;
  
  
  
      for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
          AVStream *out_stream;
  
          AVStream *in_stream = ifmt_ctx->streams[i];
  
          AVCodecParameters *in_codecpar = in_stream->codecpar;
  
  
  
          if (in_codecpar->codec_type != AVMEDIA_TYPE_AUDIO &amp;&amp;
  
              in_codecpar->codec_type != AVMEDIA_TYPE_VIDEO &amp;&amp;
  
              in_codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
  
              stream_mapping[i] = -1;
  
              continue;
  
          }
  
  
  
          stream_mapping[i] = stream_index++;
  
  
  
          out_stream = avformat_new_stream(ofmt_ctx, NULL);
  
          if (!out_stream) {
  
              fprintf(stderr, "Failed allocating output stream\n");
  
              ret = AVERROR_UNKNOWN;
  
              goto end;
  
          }
  
  
  
          ret = avcodec_parameters_copy(out_stream->codecpar, in_codecpar);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Failed to copy codec parameters\n");
  
              goto end;
  
          }
  
          out_stream->codecpar->codec_tag = 0;
  
      }
  
      av_dump_format(ofmt_ctx, 0, out_filename, 1);
  
  
  
      if (!(ofmt->flags &amp; AVFMT_NOFILE)) {
  
          ret = avio_open(&amp;ofmt_ctx->pb, out_filename, AVIO_FLAG_WRITE);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Could not open output file '%s'", out_filename);
  
              goto end;
  
          }
  
      }
  
  
  
      ret = avformat_write_header(ofmt_ctx, NULL);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Error occurred when opening output file\n");
  
          goto end;
  
      }
  
  
  
      while (1) {
  
          AVStream *in_stream, *out_stream;
  
  
  
          ret = av_read_frame(ifmt_ctx, &amp;pkt);
  
          if (ret &lt; 0)
  
              break;
  
  
  
          in_stream  = ifmt_ctx->streams[pkt.stream_index];
  
          if (pkt.stream_index >= stream_mapping_size ||
  
              stream_mapping[pkt.stream_index] &lt; 0) {
  
              av_packet_unref(&amp;pkt);
  
              continue;
  
          }
  
  
  
          pkt.stream_index = stream_mapping[pkt.stream_index];
  
          out_stream = ofmt_ctx->streams[pkt.stream_index];
  
          log_packet(ifmt_ctx, &amp;pkt, "in");
  
  
  
          /* copy packet */
  
          pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
          pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
          pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);
  
          pkt.pos = -1;
  
          log_packet(ofmt_ctx, &amp;pkt, "out");
  
  
  
          ret = av_interleaved_write_frame(ofmt_ctx, &amp;pkt);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Error muxing packet\n");
  
              break;
  
          }
  
          av_packet_unref(&amp;pkt);
  
      }
  
  
  
      av_write_trailer(ofmt_ctx);
  
  end:
  
  
  
      avformat_close_input(&amp;ifmt_ctx);
  
  
  
      /* close output */
  
      if (ofmt_ctx &amp;&amp; !(ofmt->flags &amp; AVFMT_NOFILE))
  
          avio_closep(&amp;ofmt_ctx->pb);
  
      avformat_free_context(ofmt_ctx);
  
  
  
      av_freep(&amp;stream_mapping);
  
  
  
      if (ret &lt; 0 &amp;&amp; ret != AVERROR_EOF) {
  
          fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
  
          return 1;
  
      }
  
  
  
      return 0;
  
  }