Recherche avancée

Sur d’autres sites (5683)

• lavfi/fspp : Simplify a macro.

  18 avril 2019, par Carl Eugen Hoyos

  lavfi/fspp : Simplify a macro.
  Silences a warning with clang :
  
  warning : implicit conversion from 'int' to 'int16_t' (aka 'short') changes value from 44130 to -21406
  

  • [DH] libavfilter/vf_fspp.h

• ffmpeg : Trying to access Ebur128Context->integrated_loudness but unsuccessful

  12 avril 2019, par Sourabh Jain

  [FFMPEG] Trying to access Ebur128Context->integrated_loudness but unsuccessful

  I am trying to run ebur128Filter on audio file . similar to be doing
  [http://ffmpeg.org/doxygen/2.6/f__ebur128_8c_source.html#l00135]

  ffmpeg -i sample.wav -filter_complex ebur128=peak=true -f null -

  result of which is :

  [Parsed_ebur128_0 @ 0x7f9d38403ec0] Summary:
  
  
  
  Integrated loudness:
  
  I: -15.5 LUFS
  
  Threshold: -25.6 LUFS
  
  
  
  Loudness range:
  
  LRA: 1.5 LU
  
  Threshold: -35.5 LUFS
  
  LRA low: -16.3 LUFS
  
  LRA high: -14.8 LUFS
  
  
  
  True peak:
  
  Peak: -0.4 dBFS 

  /*
  
   * Copyright (c) 2010 Nicolas George
  
   * Copyright (c) 2011 Stefano Sabatini
  
   * Copyright (c) 2012 Clément Bœsch
  
   *
  
   * 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
  
   * API example for audio decoding and filtering
  
   * @example filtering_audio.c
  
   */
  
  
  
  #include 
  
  
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libavfilter></libavfilter>buffersink.h>
  
  #include <libavfilter></libavfilter>buffersrc.h>
  
  #include <libavutil></libavutil>opt.h>
  
  
  
  #define MAX_CHANNELS 63
  
  
  
  
  
  
  
  static const char *filter_descr = "ebur128=peak=true";
  
  
  
  static AVFormatContext *fmt_ctx;
  
  static AVCodecContext *dec_ctx;
  
  AVFilterContext *buffersink_ctx;
  
  AVFilterContext *buffersrc_ctx;
  
  AVFilterGraph *filter_graph;
  
  static int audio_stream_index = -1;
  
  
  
  struct rect { int x, y, w, h; };
  
  
  
  
  
  struct hist_entry {
  
      int count;                      ///&lt; how many times the corresponding value occurred
  
      double energy;                  ///&lt; E = 10^((L + 0.691) / 10)
  
      double loudness;                ///&lt; L = -0.691 + 10 * log10(E)
  
  };
  
  
  
  
  
  struct integrator {
  
      double *cache[MAX_CHANNELS];    ///&lt; window of filtered samples (N ms)
  
      int cache_pos;                  ///&lt; focus on the last added bin in the cache array
  
      double sum[MAX_CHANNELS];       ///&lt; sum of the last N ms filtered samples (cache content)
  
      int filled;                     ///&lt; 1 if the cache is completely filled, 0 otherwise
  
      double rel_threshold;           ///&lt; relative threshold
  
      double sum_kept_powers;         ///&lt; sum of the powers (weighted sums) above absolute threshold
  
      int nb_kept_powers;             ///&lt; number of sum above absolute threshold
  
      struct hist_entry *histogram;   ///&lt; histogram of the powers, used to compute LRA and I
  
  };
  
  
  
  typedef struct EBUR128Context {
  
      const AVClass *class;           ///&lt; AVClass context for log and options purpose
  
  
  
      /* peak metering */
  
      int peak_mode;                  ///&lt; enabled peak modes
  
      double *true_peaks;             ///&lt; true peaks per channel
  
      double *sample_peaks;           ///&lt; sample peaks per channel
  
      double *true_peaks_per_frame;   ///&lt; true peaks in a frame per channel
  
  #if CONFIG_SWRESAMPLE
  
      SwrContext *swr_ctx;            ///&lt; over-sampling context for true peak metering
  
      double *swr_buf;                ///&lt; resampled audio data for true peak metering
  
      int swr_linesize;
  
  #endif
  
  
  
      /* video  */
  
      int do_video;                   ///&lt; 1 if video output enabled, 0 otherwise
  
      int w, h;                       ///&lt; size of the video output
  
      struct rect text;               ///&lt; rectangle for the LU legend on the left
  
      struct rect graph;              ///&lt; rectangle for the main graph in the center
  
      struct rect gauge;              ///&lt; rectangle for the gauge on the right
  
      AVFrame *outpicref;             ///&lt; output picture reference, updated regularly
  
      int meter;                      ///&lt; select a EBU mode between +9 and +18
  
      int scale_range;                ///&lt; the range of LU values according to the meter
  
      int y_zero_lu;                  ///&lt; the y value (pixel position) for 0 LU
  
      int y_opt_max;                  ///&lt; the y value (pixel position) for 1 LU
  
      int y_opt_min;                  ///&lt; the y value (pixel position) for -1 LU
  
      int *y_line_ref;                ///&lt; y reference values for drawing the LU lines in the graph and the gauge
  
  
  
      /* audio */
  
      int nb_channels;                ///&lt; number of channels in the input
  
      double *ch_weighting;           ///&lt; channel weighting mapping
  
      int sample_count;               ///&lt; sample count used for refresh frequency, reset at refresh
  
  
  
      /* Filter caches.
  
       * The mult by 3 in the following is for X[i], X[i-1] and X[i-2] */
  
      double x[MAX_CHANNELS * 3];     ///&lt; 3 input samples cache for each channel
  
      double y[MAX_CHANNELS * 3];     ///&lt; 3 pre-filter samples cache for each channel
  
      double z[MAX_CHANNELS * 3];     ///&lt; 3 RLB-filter samples cache for each channel
  
  
  
  #define I400_BINS  (48000 * 4 / 10)
  
  #define I3000_BINS (48000 * 3)
  
      struct integrator i400;         ///&lt; 400ms integrator, used for Momentary loudness  (M), and Integrated loudness (I)
  
      struct integrator i3000;        ///&lt;    3s integrator, used for Short term loudness (S), and Loudness Range      (LRA)
  
  
  
      /* I and LRA specific */
  
      double integrated_loudness;     ///&lt; integrated loudness in LUFS (I)
  
      double loudness_range;          ///&lt; loudness range in LU (LRA)
  
      double lra_low, lra_high;       ///&lt; low and high LRA values
  
  
  
      /* misc */
  
      int loglevel;                   ///&lt; log level for frame logging
  
      int metadata;                   ///&lt; whether or not to inject loudness results in frames
  
      int dual_mono;                  ///&lt; whether or not to treat single channel input files as dual-mono
  
      double pan_law;                 ///&lt; pan law value used to calculate dual-mono measurements
  
      int target;                     ///&lt; target level in LUFS used to set relative zero LU in visualization
  
      int gauge_type;                 ///&lt; whether gauge shows momentary or short
  
      int scale;                      ///&lt; display scale type of statistics
  
  } EBUR128Context;
  
  
  
  void dump_ebur128_context(void *priv);
  
  
  
  static int open_input_file(const char *filename)
  
  {
  
      int ret;
  
      AVCodec *dec;
  
  
  
      if ((ret = avformat_open_input(&amp;fmt_ctx, filename, NULL, NULL)) &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
  
          return ret;
  
      }
  
  
  
      if ((ret = avformat_find_stream_info(fmt_ctx, NULL)) &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
  
          return ret;
  
      }
  
  
  
      /* select the audio stream */
  
      ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, &amp;dec, 0);
  
      if (ret &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot find an audio stream in the input file\n");
  
          return ret;
  
      }
  
      audio_stream_index = ret;
  
  
  
      /* create decoding context */
  
      dec_ctx = avcodec_alloc_context3(dec);
  
      if (!dec_ctx)
  
          return AVERROR(ENOMEM);
  
      avcodec_parameters_to_context(dec_ctx, fmt_ctx->streams[audio_stream_index]->codecpar);
  
  
  
      /* init the audio decoder */
  
      if ((ret = avcodec_open2(dec_ctx, dec, NULL)) &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot open audio decoder\n");
  
          return ret;
  
      }
  
  
  
      return 0;
  
  }
  
  
  
  static int init_filters(const char *filters_descr)
  
  {
  
      char args[512];
  
      int ret = 0;
  
      const AVFilter *abuffersrc  = avfilter_get_by_name("abuffer");
  
      const AVFilter *abuffersink = avfilter_get_by_name("abuffersink");
  
      AVFilterInOut *outputs = avfilter_inout_alloc();
  
      AVFilterInOut *inputs  = avfilter_inout_alloc();
  
      static const enum AVSampleFormat out_sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 };
  
      static const int64_t out_channel_layouts[] = { AV_CH_LAYOUT_MONO, -1 };
  
      static const int out_sample_rates[] = { 8000, -1 };
  
      const AVFilterLink *outlink;
  
      AVRational time_base = fmt_ctx->streams[audio_stream_index]->time_base;
  
  
  
      filter_graph = avfilter_graph_alloc();
  
      if (!outputs || !inputs || !filter_graph) {
  
          ret = AVERROR(ENOMEM);
  
          goto end;
  
      }
  
  
  
      /* buffer audio source: the decoded frames from the decoder will be inserted here. */
  
      if (!dec_ctx->channel_layout)
  
          dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);
  
      snprintf(args, sizeof(args),
  
              "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
  
               time_base.num, time_base.den, dec_ctx->sample_rate,
  
               av_get_sample_fmt_name(dec_ctx->sample_fmt), dec_ctx->channel_layout);
  
      ret = avfilter_graph_create_filter(&amp;buffersrc_ctx, abuffersrc, "in",
  
                                         args, NULL, filter_graph);
  
      if (ret &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
  
          goto end;
  
      }
  
  
  
      /* buffer audio sink: to terminate the filter chain. */
  
      ret = avfilter_graph_create_filter(&amp;buffersink_ctx, abuffersink, "out",
  
                                         NULL, NULL, filter_graph);
  
      if (ret &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
  
          goto end;
  
      }
  
  
  
      ret = av_opt_set_int_list(buffersink_ctx, "sample_fmts", out_sample_fmts, -1,
  
                                AV_OPT_SEARCH_CHILDREN);
  
      if (ret &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
  
          goto end;
  
      }
  
  
  
      ret = av_opt_set_int_list(buffersink_ctx, "channel_layouts", out_channel_layouts, -1,
  
                                AV_OPT_SEARCH_CHILDREN);
  
      if (ret &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
  
          goto end;
  
      }
  
  
  
      ret = av_opt_set_int_list(buffersink_ctx, "sample_rates", out_sample_rates, -1,
  
                                AV_OPT_SEARCH_CHILDREN);
  
      if (ret &lt; 0) {
  
          av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
  
          goto end;
  
      }
  
  
  
      /*
  
       * Set the endpoints for the filter graph. The filter_graph will
  
       * be linked to the graph described by filters_descr.
  
       */
  
  
  
      /*
  
       * The buffer source output must be connected to the input pad of
  
       * the first filter described by filters_descr; since the first
  
       * filter input label is not specified, it is set to "in" by
  
       * default.
  
       */
  
      outputs->name       = av_strdup("in");
  
      outputs->filter_ctx = buffersrc_ctx;
  
      outputs->pad_idx    = 0;
  
      outputs->next       = NULL;
  
  
  
      /*
  
       * The buffer sink input must be connected to the output pad of
  
       * the last filter described by filters_descr; since the last
  
       * filter output label is not specified, it is set to "out" by
  
       * default.
  
       */
  
      inputs->name       = av_strdup("out");
  
      inputs->filter_ctx = buffersink_ctx;
  
      inputs->pad_idx    = 0;
  
      inputs->next       = NULL;
  
  
  
      if ((ret = avfilter_graph_parse_ptr(filter_graph, filters_descr,
  
                                          &amp;inputs, &amp;outputs, NULL)) &lt; 0)
  
          goto end;
  
  
  
      if ((ret = avfilter_graph_config(filter_graph, NULL)) &lt; 0)
  
          goto end;
  
  
  
      /* Print summary of the sink buffer
  
       * Note: args buffer is reused to store channel layout string */
  
      outlink = buffersink_ctx->inputs[0];
  
      av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout);
  
      av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n",
  
             (int)outlink->sample_rate,
  
             (char *)av_x_if_null(av_get_sample_fmt_name(outlink->format), "?"),
  
             args);
  
  
  
  end:
  
      avfilter_inout_free(&amp;inputs);
  
      avfilter_inout_free(&amp;outputs);
  
  
  
      return ret;
  
  }
  
  
  
  static void print_frame(const AVFrame *frame)
  
  {
  
  //    const int n = frame->nb_samples * av_get_channel_layout_nb_channels(frame->channel_layout);
  
  //    const uint16_t *p     = (uint16_t*)frame->data[0];
  
  //    const uint16_t *p_end = p + n;
  
  //
  
  //    while (p &lt; p_end) {
  
  //        fputc(*p    &amp; 0xff, stdout);
  
  //        fputc(*p>>8 &amp; 0xff, stdout);
  
  //        p++;
  
  //    }
  
  //    fflush(stdout);
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      av_log_set_level(AV_LOG_DEBUG);
  
      int ret;
  
      AVPacket packet;
  
      AVFrame *frame = av_frame_alloc();
  
      AVFrame *filt_frame = av_frame_alloc();
  
  
  
      if (!frame || !filt_frame) {
  
          perror("Could not allocate frame");
  
          exit(1);
  
      }
  
  
  
  
  
      if ((ret = open_input_file(argv[1])) &lt; 0)
  
          goto end;
  
      if ((ret = init_filters(filter_descr)) &lt; 0)
  
          goto end;
  
  
  
      /* read all packets */
  
      while (1) {
  
          if ((ret = av_read_frame(fmt_ctx, &amp;packet)) &lt; 0)
  
              break;
  
  
  
          if (packet.stream_index == audio_stream_index) {
  
              ret = avcodec_send_packet(dec_ctx, &amp;packet);
  
              if (ret &lt; 0) {
  
                  av_log(NULL, AV_LOG_ERROR, "Error while sending a packet to the decoder\n");
  
                  break;
  
              }
  
  
  
              while (ret >= 0) {
  
                  ret = avcodec_receive_frame(dec_ctx, frame);
  
                  if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
  
                      break;
  
                  } else if (ret &lt; 0) {
  
                      av_log(NULL, AV_LOG_ERROR, "Error while receiving a frame from the decoder\n");
  
                      goto end;
  
                  }
  
  
  
                  if (ret >= 0) {
  
                      /* push the audio data from decoded frame into the filtergraph */
  
                      if (av_buffersrc_add_frame_flags(buffersrc_ctx, frame, AV_BUFFERSRC_FLAG_KEEP_REF) &lt; 0) {
  
                          av_log(NULL, AV_LOG_ERROR, "Error while feeding the audio filtergraph\n");
  
                          break;
  
                      }
  
  
  
                      /* pull filtered audio from the filtergraph */
  
                      while (1) {
  
                          ret = av_buffersink_get_frame(buffersink_ctx, filt_frame);
  
                          if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  
                              break;
  
                          if (ret &lt; 0)
  
                              goto end;
  
                          print_frame(filt_frame);
  
                          av_frame_unref(filt_frame);
  
                      }
  
                      av_frame_unref(frame);
  
                  }
  
              }
  
          }
  
          av_packet_unref(&amp;packet);
  
      }
  
      if(filter_graph->nb_filters){
  
      av_log(filter_graph, AV_LOG_INFO, "hello : %d \n",
  
                  filter_graph->nb_filters);
  
      int i;
  
      for (int i = 0; i &lt; filter_graph->nb_filters; i++){
  
          av_log(filter_graph, AV_LOG_INFO, "name : %s \n",
  
                          filter_graph->filters[i]->name);
  
      }
  
      }
  
  
  
      av_log(filter_graph, AV_LOG_INFO, "name : %s \n",
  
                              filter_graph->filters[2]->name);
  
      void* priv = filter_graph->filters[2]->priv;
  
  
  
      dump_ebur128_context(&amp;priv);
  
  
  
  end:
  
  
  
  
  
      avfilter_graph_free(&amp;filter_graph);
  
      avcodec_free_context(&amp;dec_ctx);
  
      avformat_close_input(&amp;fmt_ctx);
  
      av_frame_free(&amp;frame);
  
      av_frame_free(&amp;filt_frame);
  
  
  
      if (ret &lt; 0 &amp;&amp; ret != AVERROR_EOF) {
  
          fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
  
          exit(1);
  
      }
  
  
  
      exit(0);
  
  }
  
  
  
  void dump_ebur128_context(void *priv){
  
      EBUR128Context *ebur128 = priv;
  
  
  
      av_log(ebur128, AV_LOG_INFO, "integrated_loudness : %5.1f \n",
  
                              ebur128->integrated_loudness);
  
      av_log(ebur128, AV_LOG_INFO, "lra_low : %5.1f \n",
  
                                  ebur128->lra_low);
  
      av_log(ebur128, AV_LOG_INFO, "lra_high : %5.1f \n",
  
                                  ebur128->lra_high);
  
  
  
  
  
  }

  program fails while accessing integrated loudness in dump_ebur128_context.

  can someone guide me about , how I should proceed in here.

• How to overlay two audio with ffmpeg ?

  20 février 2019, par Mai Lê Nhật Huy

  Im trying mix two audio with these codes :

  for %a in ("audio\*.mp3") do ffmpeg -y -i "%a" -i "background\back.mp3" -filter_complex "[0:0]volume=1[a];[1:0]volume=0.1[b];[a][b]amix=inputs=2:duration=first" "source\%~na.mp3"

  my "back.mp3" is short and i need it repeats until the first mp3 file ends.

  How can i do that ?