Recherche avancée

Sur d’autres sites (3996)

• APPLY Strong to Buffer rule. Quit Switching Bit rates MPEG DASH

  14 juillet 2015, par Vinay

  I am using mpeg dash for adaptive bit rate streaming of video from my server.

  I have used ffmpeg and MP4Box to generate 4 different quality video files from my source .mp4

  The .mpd file generated has the below code

  <?xml version="1.0"?>
  
  
  
  <mpd xmlns="urn:mpeg:dash:schema:mpd:2011" minbuffertime="PT1.500000S" type="static" mediapresentationduration="PT0H3M1.42S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011">
  
   <programinformation moreinformationurl="http://gpac.sourceforge.net">
  
    
  
   </programinformation>
  
  
  
   <period duration="PT0H3M1.42S">
  
    <adaptationset segmentalignment="true" maxwidth="1920" maxheight="1080" maxframerate="24" par="16:9" lang="und" subsegmentstartswithsap="1">
  
     <representation mimetype="video/mp4" codecs="avc1.64000d" width="320" height="240" framerate="24" sar="1:1" startwithsap="1" bandwidth="375715">
  
      <baseurl>400_dashinit.mp4</baseurl>
  
      <segmentbase indexrangeexact="true" indexrange="904-1403">
  
        <initialization range="0-903"></initialization>
  
      </segmentbase>
  
     </representation>
  
     <representation mimetype="video/mp4" codecs="avc1.640015" width="420" height="270" framerate="24" sar="1:1" startwithsap="1" bandwidth="644824">
  
      <baseurl>700_dashinit.mp4</baseurl>
  
      <segmentbase indexrangeexact="true" indexrange="905-1404">
  
        <initialization range="0-904"></initialization>
  
      </segmentbase>
  
     </representation>
  
     <representation mimetype="video/mp4" codecs="avc1.64001f" width="1024" height="576" framerate="24" sar="1:1" startwithsap="1" bandwidth="1349484">
  
      <baseurl>1500_dashinit.mp4</baseurl>
  
      <segmentbase indexrangeexact="true" indexrange="905-1404">
  
        <initialization range="0-904"></initialization>
  
      </segmentbase>
  
     </representation>
  
     <representation mimetype="video/mp4" codecs="avc1.64001f" width="1280" height="720" framerate="24" sar="1:1" startwithsap="1" bandwidth="2264379">
  
      <baseurl>2500_dashinit.mp4</baseurl>
  
      <segmentbase indexrangeexact="true" indexrange="905-1404">
  
        <initialization range="0-904"></initialization>
  
      </segmentbase>
  
     </representation>
  
     <representation mimetype="video/mp4" codecs="avc1.640028" width="1920" height="1080" framerate="24" sar="1:1" startwithsap="1" bandwidth="3633049">
  
      <baseurl>4000_dashinit.mp4</baseurl>
  
      <segmentbase indexrangeexact="true" indexrange="906-1405">
  
        <initialization range="0-905"></initialization>
  
      </segmentbase>
  
     </representation>
  
    </adaptationset>
  
   </period>
  
  </mpd>

  I am using video.js along with dash.js to playback the mpeg dash content on client side. The issue is that the video doesn’t playback perfectly when i simulate network conditions from chrome dev tools.

  It works at times and it doesn’t at others. For ex the stream starts with bit rate of 400kbps and then detects enough bandwidth available so it switches to 2500kbps. Then when i bring down my bandwidth to 400kbps again then the video freezes at some point of time.

  At times the video freezes after few initial seconds of playback when it tries to switch the stream. I think there might be some command line parameter that i am missing while generating my video files via ffmpeg or generating .mpd file via MP4Box.

  below are the commands i use for ffmpeg and MP4Box

  ffmpeg -y -i inputfile -c:a libfdk_aac -ac 2 -ab 128k -c:v libx264 -r 24 – g 24 -b:v 1500k -maxrate 1500k -bufsize 1000k -vf "scale=-1:720" outputfile.mp4
  
  
  
  
  
  MP4Box -dash [DURATION] -rap -frag-rap -profile [PROFILE] -out [path/to/outpout.file] [path/to/input1.file] [path/to/input2.file] [path/to/input3.file]

  Also while i am generating .mpd files via MP4Box i am getting below warning in console

  [DASH]: Files have non-proportional track layouts (320x240 vs 420x270) but sample size and aspect ratio match, assuming precision issue
  
  [DASH]: Files have non-proportional track layouts (320x240 vs 1024x576) but sample size and aspect ratio match, assuming precision issue
  
  [DASH]: Files have non-proportional track layouts (320x240 vs 1280x720) but sample size and aspect ratio match, assuming precision issue
  
  [DASH]: Files have non-proportional track layouts (320x240 vs 1920x1080) but sample size and aspect ratio match, assuming precision issue

  Whenever the video stops playing the chrome console has these logs

  Number of times the buffer has run dry: 25
  
  Apply STRONG to buffer rule.
  
  Quit switching bit rates.

  I don’t have any clue as to why the buffers run dry and it stops switching the bit rates.

  Anything that is predominantly wrong in the process ?

• AAC encoder : fix wrong gain sacalefactor being set

  26 novembre 2015, par Claudio Freire

  AAC encoder : fix wrong gain sacalefactor being set
  In some conditions, where the first band was being zeroed
  
  mainly, the wrong global gain scalefactor would be written
  
  to the stream since it’s always taken from the first band
  
  regardless of whether it’s been marked as zero or not.
  So, always make sure it contians something useful.
  

  • [DH] libavcodec/aaccoder_twoloop.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.