Recherche avancée

Sur d’autres sites (7234)

• Announcing the first free software Blu-ray encoder

  25 avril 2010, par Dark Shikari — blu-ray, x264

  For many years it has been possible to make your own DVDs with free software tools. Over the course of the past decade, DVD creation evolved from the exclusive domain of the media publishing companies to something basically anyone could do on their home computer.

  But Blu-ray has yet to get that treatment. Despite the “format war” between Blu-ray and HD DVD ending over two years ago, free software has lagged behind. “Professional” tools for Blu-ray video encoding can cost as much as $100,000 and are often utter garbage. Here are two actual screenshots from real Blu-rays : I wish I was making this up.

  But today, things change. Today we take the first step towards a free software Blu-ray creation toolkit.

  Thanks to tireless work by Kieran Kunyha, Alex Giladi, Lamont Alston, and the Doom9 crowd, x264 can now produce Blu-ray-compliant video. Extra special thanks to The Criterion Collection for sponsoring the final compliance test to confirm x264′s Blu-ray compliance.

  With x264′s powerful compression, as demonstrated by the incredibly popular BD-Rebuilder Blu-ray backup software, it’s quite possible to author Blu-ray disks on DVD9s (dual-layer DVDs) or even DVD5s (single-layer DVDs) with a reasonable level of quality. With a free software encoder and less need for an expensive Blu-ray burner, we are one step closer to putting HD optical media creation in the hands of the everyday user.

  To celebrate this achievement, we are making available for download a demo Blu-ray encoded with x264, containing entirely free content !

  On this Blu-ray are the Open Movie Project films Big Buck Bunny and Elephant’s Dream, available under a Creative Commons license. Additionally, Microsoft has graciously provided about 6 minutes of lossless HD video and audio (from part of a documentary project) under a very liberal license. This footage rounds out the Blu-ray by adding some difficult live-action content in addition to the relatively compressible CGI footage from the Open Movie Project. Finally, we used this sound sample, available under a Creative Commons license.

  You may notice that the Blu-ray image is only just over 2GB. This is intentional ; we have encoded all the content on the disk at appropriate bitrates to be playable from an ordinary 4.7GB DVD. This should make it far easier to burn a copy of the Blu-ray, since Blu-ray burners and writable media are still relatively rare. Most Blu-ray players will treat a DVD containing Blu-ray data as a normal Blu-ray disc. A few, such as the Playstation 3, will not, but you can still play it as a data disc.

  Finally, note that (in accordance with the Blu-ray spec) the disc image file uses the UDF 2.5 filesystem, which may be incompatible with some older virtual drive and DVD burning applications. You’ll also need to play it on an actual Blu-ray player if you want to get the menus and such working correctly. If you’re looking to play it on a PC, a free trial of Arcsoft TMT is available here.

  What are you waiting for ? Grab a copy today !

  UPDATE : Here is an AVCHD-compliant version of the above, which should work better when burned on a DVD-5 instead of a BD-R. (mirror)
  

  What’s left before we have a fully free software Blu-ray creation toolkit ? Audio is already dealt with ; AC3 audio (aka Dolby Digital), the format used in DVD, is still supported by Blu-ray, and there are many free software AC3 encoders. The primary missing application is a free software Blu-ray authoring tool, to combine the video and audio streams to create a Blu-ray file structure with the menus, chapters, and so forth that we have all come to expect. But the hardest part is dealt with : we can now create compatible video and audio streams.

  In the meantime, x264 can be used to create streams to be authored using Blu-Print, Scenarist, Encore or other commercial authoring tools.

  More detailed documentation on the new Blu-ray support and how to use it can be found in the official commit message. Do keep in mind that you have to export to raw H.264 (not MKV or MP4) or else the buffering information will be slightly incorrect. Finally, also note that the encoding settings given as an example are not a good choice for general-purpose encoding : they are intentionally crippled by Blu-ray restrictions, which will significantly reduce compression for ordinary non-Blu-ray encoding.

  In addition to Blu-ray support, the aforementioned commit comes with a lot of fun extras :

  x264 now has native variable-framerate ratecontrol, which makes sure your encodes get a correct target bitrate and proper limiting of maximum bitrate even if the duration of every frame is different and the “framerate” is completely unknown. This helps a lot when encoding from variable-framerate container formats such as FLV and WMV, along with variable-framerate content such as anime.

  x264 now supports pulldown (telecine) in much the same fashion as it is handled in MPEG-2. The calling application can pass in flags representing how to display a frame, allowing easy transcoding from MPEG-2 sources with pulldown, such as broadcast television. The x264 commandline app contains some examples of these (such as the common 3:2 pulldown pattern).

  x264 now also exports HRD timing information, which is critical for compliant transport stream muxing. There is currently an active project to write a fully DVB-compatible free software TS muxer that will be able to interface with x264 for a seamless free software broadcast system. It will likely also be possible to repurpose this muxer as part of a free software Blu-ray authoring package.

  All of this is now available in the latest x264.

  http://mirror05.x264.nl/Dark/bluray%20fail.png

• Hung out to dry

  31 mai 2013, par Mans — Law and liberty

  Outrage was the general reaction when Google recently announced their dropping of XMPP server-to-server federation from Hangouts, as the search giant’s revamped instant messaging platform is henceforth to be known. This outrage is, however, largely unjustified ; Google’s decision is merely a rational response to issues of a more fundamental nature. To see why, we need to step back and look at the broader instant messaging landscape.

  A brief history of IM

  The term instant messaging (IM) gained popularity in the mid-1990s along with the rise of chat clients such as ICQ, AOL Instant Messenger, and later MSN Messenger. These all had one thing in common : they were closed systems. Although global in the sense of allowing access from anywhere on the Internet, communication was possible only within each network, and only using the officially sanctioned client software. Contrast this with email, where users are free to choose any service provider as well as client software, inter-server communication over open protocols delivering messages to their proper destinations.

  The email picture has, however, not always been so rosy. During the 1970s and 80s a multitude of incompatible email systems (e.g. UUCP and X.400) were in more or less widespread use on various networks. As these networks gave way to the ARPANET/Internet, so did their mail systems to the SMTP email we all use today. A similar consolidation has yet to occur in the area of instant messaging.

  Over the years, a few efforts towards a cross-domain instant messaging have been undertaken. One early example is the Zephyr system created as part of Project Athena at MIT in the late 1980s. While it never saw significant uptake, it is still in use at a few universities. A more successful story is that of XMPP. Conceived under the name Jabber in the late 1990s, XMPP is an open standard specified in a set of IETF RFCs. In addition to being open, a distinguishing feature of XMPP compared to other contemporary IM systems is its decentralised nature, server-to-server connections allowing communication between users with accounts on different systems. Just like email.

  The social network

  A more recent emergence on the Internet is the social network. Although not the first of its kind, Facebook was the first to achieve its level of penetration, both geographically and across social groups. A range of messaging options, including email-style as well as instant messaging (chat), are available, all within the same web interface. What it does not allow is communication outside the Facebook network. Other social networks operate in the same spirit.

  The popularity of social networks, to the extent that they for many constitute the primary means of communication, has in a sense brought back fragmented networks of the 1980s. Even though they share infrastructure, up to and including the browser application, the social networks create walled-off regions of the Internet between which little or no exchange is possible.

  The house that Google built

  In 2005, Google launched Talk, an XMPP-based instant messaging service allowing users to connect using either Google’s official client application or any third-party XMPP client. Soon after, server-to-server federation was activated, enabling anyone with a Google account to exchange instant messages with users of any other federated XMPP service. An in-browser chat interface was also added to Gmail.

  It was arguably only with the 2011 introduction of Google+ that Google, despite its previous endeavours with Orkut and Buzz, had a viable contender in the social networking space. Since its inception, Google+ has gone through a number of changes where features have been added or reworked. Instant messaging within Google+ was until recently available only in mobile clients. On the desktop, the sole messaging option was Hangouts which, although featuring text chat, cannot be considered instant messaging in the usual sense.

  With a sprawling collection of messaging systems (Talk, Google+ Messenger, Hangouts), some action to consolidate them was a logical step. What we got was a unification under the Hangouts name. A redesigned Google+ now sports in-browser instant messaging similar the the Talk interface already present in Gmail. At the same time, the standalone desktop Talk client is discontinued, as is the Messenger feature in mobile Google+. All together, the changes make for a much less confusing user experience.

  The sky is falling down

  Along with the changes to the messaging platform, one announcement stoked anger on the Internet : Google’s intent to discontinue XMPP federation (as of this writing, it is still operational). Google, the (self-described) champions of openness on the Internet were seen to be closing their doors to the outside world. The effects of the change are, however, not quite so earth-shattering. Of the other major messaging networks to offer XMPP at all (Facebook, Skype, and the defunct Microsoft Messenger), none support federation ; a Google user has never been able to chat with a Facebook user.

  XMPP federation appears to be in use mainly by non-profit organisations or individuals running their own servers. The number of users on these systems is hard to assess, though it seems fair to assume it is dwarfed by the hundreds of millions using Google or Facebook. As such, the overall impact of cutting off communication with the federated servers is relatively minor, albeit annoying for those affected.

  A fragmented world

  Rather than chastising Google for making a low-impact, presumably founded, business decision, we should be asking ourselves why instant messaging is still so fragmented in the first place, whereas email is not. The answer can be found by examining the nature of entities providing these services.

  Ever since the commercialisation of the Internet started in the 1990s, email has been largely seen as being part of the Internet. Access to email was a major selling point for Internet service providers ; indeed, many still use the email facilities of their ISP. Instant messaging, by contrast, has never come as part of the basic offering, rather being a third-party service running on top of the Internet.

  Users wishing to engage in instant messaging have always had to seek out and sign up with a provider of such a service. As the IM networks were isolated, most would choose whichever service their friends were already using, and a small number of networks, each with a sustainable number of users, came to dominate. In the early days, dedicated IM services such as ICQ were popular. Today, social networks have taken their place with Facebook currently in the dominant position. With the new Hangouts, Google offers its users the service they want in the way they have come to expect.

  Follow the money

  We now have all the pieces necessary to see why inter-domain instant messaging has never taken off, and the answer is simple : the major players have no commercial incentive to open access to their IM networks. In fact, they have good reason to keep the networks closed. Ensuring that a person leaving the network loses contact with his or her friends, increases user retention by raising the cost of switching to another service. Monetising users is also better facilitated if they are forced to remain on, say, Facebook’s web pages while using its services rather than accessing them indirectly, perhaps even through a competing (Google, say) frontend. The users do not generally care much, since all their friends are already on the same network as themselves.

  While Google Talk was a standalone service, only loosely coupled to other Google products, these aspects were of lesser importance. After all, Google still had access to all the messages passing through the system and could analyse them for advert targeting purposes. Now that messaging is an integrated part of Google+, and thus serves as a direct competitor to the likes of Facebook, the situation has changed. All the reasons for Facebook not to open its network now apply equally to Google as well.

• 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.