Recherche avancée

Sur d’autres sites (3960)

• Top 4 CRO Tools to Boost Your Conversion Rates in 2024

  31 octobre 2023, par Erin

  Are you tired of watching potential customers leave your website without converting ? You’ve spent countless hours creating an engaging website, but those high bounce rates keep haunting you.

  The good news ? The solution lies in the transformative power of Conversion Rate Optimisation (CRO) tools. In this guide, we’ll dive deep into the world of CRO tools. We will equip you with strategies to turn those bounces into conversions.

  Why are conversion rate optimisation tools so crucial ?

  CRO tools can be assets in digital marketing, playing a pivotal role in enhancing online businesses’ performance. CRO tools empower businesses to improve website conversion rates by analysing user behaviour. You can then leverage this user data to optimise web elements.

  Improving website conversion rates is paramount because it increases revenue and customer satisfaction. A study by VentureBeat revealed an average return on investment (ROI) of 223% thanks to CRO tools.

  173 marketers out of the surveyed group reported returns exceeding 1,000%. Both of these data points highlight the impact CRO tools can have.

  

  Coupled with CRO tools, certain testing tools and web analytics tools play a crucial role. They offer insight into user behaviour patterns, enabling businesses to choose effective strategies. By understanding what resonates with users, these tools help inform data-driven decisions. This allows businesses to refine online strategies and enhance the customer experience.

  CRO tools enhance user experiences and ensure business sustainability. Integrating these tools is crucial for staying ahead. CRO and web analytics work together to optimise digital presence. 

  Real-world examples of CRO tools in action

  In this section, we’ll explore real case studies showcasing CRO tools in action. See how businesses enhance conversion rates, user experiences, and online performance. These studies reveal the practical impact of data-driven decisions and user-focused strategies.

  

  Case study : How Matomo’s Form Analytics helped Concrete CMS 3x leads

  Concrete CMS, is a content management system provider that helps users build and manage websites. They used Matomo’s Form Analytics to uncover that users were getting stuck at the address input stage of the onboarding process. Using these insights to make adjustments to their onboarding form, Concrete CMS was able to achieve 3 times the amount of leads in just a few days.

  Read the full Concrete CMS case study.

  Best analytics tools for enhancing conversion rate optimisation in 2023

  Jump to the comparison table to see an overview of each tool.

  1. Matomo

  

  Matomo stands out as an all-encompassing tool that seamlessly combines traditional web analytics features (like pageviews and bounce rates) with advanced behavioural analytics capabilities, providing a full spectrum of insights for effective CRO.

  Key features

  • Heatmaps and Session Recordings :
    These features empower businesses to see their websites through the eyes of their visitors. By visually mapping user engagement and observing individual sessions, businesses can make informed decisions, enhance user experience and ultimately increase conversions. These tools are invaluable assets for businesses aiming to create user-friendly websites.

  • Form Analytics :
    Matomo’s Form Analytics offers comprehensive tracking of user interactions within forms. This includes covering input fields, dropdowns, buttons and submissions. Businesses can create custom conversion funnels and pinpoint form abandonment reasons. 

  • Users Flow :
    Matomo’s Users Flow feature tracks visitor paths, drop-offs and successful routes, helping businesses optimise their websites. This insight informs decisions, enhances user experience, and boosts conversion rates.

  • Surveys plugin :
    The Matomo Surveys plugin allows businesses to gather direct feedback from users. This feature enhances understanding by capturing user opinions, adding another layer to the analytical depth Matomo offers.

  • A/B testing :
    The platform allows you to conduct A/B tests to compare different versions of web pages. This helps determine which performs better in conversions. By conducting experiments and analysing the results within Matomo, businesses can iteratively refine their content and design elements.

  • Funnels :
    Matomo’s Funnels feature empower businesses to visualise, analyse and optimise their conversion paths. By identifying drop-off points, tailoring user experiences and conducting A/B tests within the funnel, businesses can make data-driven decisions that significantly boost conversions and enhance the overall user journey on their websites.

  Pros

  • Starting at $19 per month, Matomo is an affordable CRO solution.
  • Matomo guarantees accurate data, eliminating the need to fill gaps with artificial intelligence (AI) or machine learning. 
  • Matomo’s open-source framework ensures enhanced security, privacy, customisation, community support and long-term reliability. 

  Cons

  • The On-Premise (self-hosted) version is free, with additional charges for advanced features.
  • Managing Matomo On-Premise requires servers and technical know-how.

  Try Matomo for Free

  Get the web insights you need, without compromising data accuracy.

  Start for free

  No credit card required

  2. Google Analytics

  

  Google Analytics provides businesses and website owners valuable insights into their online audience. It tracks website traffic, user interactions and analyses conversion data to enhance the user experience.

  While Google Analytics may not provide the extensive CRO-specific features found in other tools on this list, it can still serve as a valuable resource for basic analysis and optimisation of conversion rates.

  Key features

  • Comprehensive Data Tracking :
    Google Analytics meticulously tracks website traffic, user behaviour and conversion rates. These insights form the foundation for CRO efforts. Businesses can identify patterns, user bottlenecks and high-performing areas.

  • Real-Time Reporting :
    Access to real-time data is invaluable for CRO efforts. Monitor current website activity, user interactions, and campaign performance as they unfold. This immediate feedback empowers businesses to make instant adjustments, optimising web elements and content for maximum conversions.

  • User flow analysis
    Visualise and understand how visitors navigate through your website. It provides insights into the paths users take as they move from one page to another, helping you identify the most common routes and potential drop-off points in the user journey.

  • Event-based tracking :
    GA4’s event-based reporting offers greater flexibility and accuracy in data collection. By tracking various interactions, including video views and checkout processes, businesses can gather more precise insights into user behaviour. 

  • Funnels :
    GA4 offers multistep funnels, path analysis, custom metrics that integrate with audience segments. These user behaviour insights help businesses to tailor their websites, marketing campaigns and user experiences.

  Pros

  • Flexible audience management across products, regions or brands allow businesses to analyse data from multiple source properties. 
  • Google Analytics integrates with other Google services and third-party platforms. This enables a comprehensive view of online activities.
  • Free to use, although enterprises may need to switch to the paid version to accommodate higher data volumes.

  Cons

  • Google Analytics raises privacy concerns, primarily due to its tracking capabilities and the extensive data it collects.
  • Limitations imposed by thresholding can significantly hinder efforts to enhance user experience and boost conversions effectively.
  • Property and sampling limits exist. This creates problems when you’re dealing with extensive datasets or high-traffic websites. 
  • The interface is difficult to navigate and configure, resulting in a steep learning curve.

  3. Contentsquare

  

  Contentsquare is a web analytics and CRO platform. It stands out for its in-depth behavioural analytics. Contentsquare offers detailed data on how users interact with websites and mobile applications.

  Key features

  • Heatmaps and Session Replays :
    Users can visualise website interactions through heatmaps, highlighting popular areas and drop-offs. Session replay features enable the playback of user sessions. These provide in-depth insights into individual user experiences.

  • Conversion Funnel Analysis :
    Contentsquare tracks users through conversion funnels, identifying where users drop off during conversion. This helps in optimising the user journey and increasing conversion rates.

  • Segmentation and Personalisation :
    Businesses can segment their audience based on various criteria. Segments help create personalised experiences, tailoring content and offers to specific user groups.

  • Integration Capabilities :
    Contentsquare integrates with various third-party tools and platforms, enhancing its functionality and allowing businesses to leverage their existing tech stack.

  Pros

  • Comprehensive support and resources.
  • User-friendly interface.
  • Personalisation capabilities.

  Cons

  • High price point.
  • Steep learning curve.

  4. Hotjar

  

  Hotjar is a robust tool designed to unravel user behaviour intricacies. With its array of features including visual heatmaps, session recordings and surveys, it goes beyond just identifying popular areas and drop-offs.

  Hotjar provides direct feedback and offers an intuitive interface, enabling seamless experience optimisation.

  Key features

  • Heatmaps :
    Hotjar provides visual heatmaps that display user interactions on your website. Heatmaps show where users click, scroll, and how far they read. This feature helps identify popular areas and points of abandonment.

  • Session Recordings :
    Hotjar allows you to record user sessions and watch real interactions on your site. This insight is invaluable for understanding user behaviour and identifying usability issues.

  • Surveys and Feedback :
    Hotjar offers on-site surveys and feedback forms that can get triggered based on user behaviour. These tools help collect qualitative data from real users, providing valuable insights.

  • Recruitment Tool :
    Hotjar’s recruitment tool lets you recruit participants from your website for user testing. This feature streamlines the process of finding participants for usability studies.

  • Funnel and Form Analysis :
    Hotjar enables the tracking of user journeys through funnels. It provides insights into where users drop off during the conversion process. It also offers form analysis to optimise form completion rates.

  • User Polls :
    You can create customisable polls to engage with visitors. Gather specific feedback on your website, products, or services.

  Pros

  • Starting at $32 per month, Hotjar is a cost-effective solution for most businesses. 
  • Hotjar provides a user-friendly interface that is easy for the majority of users to pick up quickly.

  Cons

  • Does not provide traditional web analytics and requires combining with another tool, potentially creating a less streamlined and cohesive user experience, which can complicate conversion rate optimization efforts.
  • Hotjar’s limited integrations can hinder its ability to seamlessly work with other essential tools and platforms, potentially further complicating CRO.

  Comparison Table

  Please note : We aim to keep this table accurate and up to date. However, if you see any inaccuracies or outdated information, please email us at marketing@matomo.org

  To make comparing these tools even easier, we’ve put together a table for you to compare features and price points :

  

  Conclusion

  CRO tools and web analytics are essential for online success. Businesses thrive by investing wisely, understanding user behaviour and using targeted strategies. The key : generate traffic and convert it into leads and customers. The right tools and strategies lead to remarkable conversions and online success. Each click, each interaction, becomes an opportunity to create an engaging user journey. This careful orchestration of data and insight separates thriving businesses from the rest.

  Are you ready to embark on a journey toward improved conversions and enhanced user experiences ? Matomo offers analytics solutions meticulously designed to complement your CRO strategy. Take the next step in your CRO journey. Start your 21-day free trial today—no credit card required.

  Try Matomo for Free

  21 day free trial. No credit card required.

  
  

  Your email address
  

  Your website address
  

  Your Analytics subdomain will be .matomo.cloud (change)

  Choose your analytics subdomain
  

  .matomo.cloud

  I accept the terms and conditions and data processing agreement (DPA)

  
  Your information will be used to create an account on our cloud service. For more information please consult our privacy policy.
  
  
  

  Start improving your websites now

  

• C - Transcoding to UDP using FFmpeg ?

  30 avril 2013, par golmschenk

  I'm trying to use the FFmpeg libraries to take an existing video file and stream it over a UDP connection. Specifically, I've been looking at the muxing.c and demuxing.c example files in the source code doc/example directory of FFmpeg. The demuxing file presents code which allows an input video to be converted into the video and audio streams. The muxing file presents code which creates fake data and can already be output to a UDP connection as I would like. I've begun work combining the two. Below can be found my code which is basically a copy of the muxing file with some parts replaced/appended with parts of the demuxing file. Unfortunately I'm running into plenty of complications attempting my goal through this approach. Is there an existing source code example which does the transcoding I'm looking for ? Or at least a tutorial on how one might create this ? If not, at least a few pointers might be helpful in directing my work in combing the two files to achieve my goal. Specifically, I'm getting the error :

  [NULL @ 0x23b4040] Unable to find a suitable output format for 'udp://localhost:7777'
  
  Could not deduce output format from file extension: using MPEG.
  
  Output #0, mpeg, to 'udp://localhost:7777':

  Even though the muxing file could accept UDP formats. Any suggestions ? Thank you much !

  #include 
  
  #include 
  
  #include 
  
  #include 
  
  
  
  #include <libavutil></libavutil>mathematics.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  
  
  /* 5 seconds stream duration */
  
  #define STREAM_DURATION   200.0
  
  #define STREAM_FRAME_RATE 25 /* 25 images/s */
  
  #define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
  
  #define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */
  
  
  
  //FROM DE
  
  static AVFormatContext *fmt_ctx = NULL;
  
  static AVCodecContext *video_dec_ctx = NULL, *audio_dec_ctx;
  
  static AVStream *video_stream = NULL, *audio_stream = NULL;
  
  static const char *src_filename = NULL;
  
  static const char *video_dst_filename = NULL;
  
  static const char *audio_dst_filename = NULL;
  
  static FILE *video_dst_file = NULL;
  
  static FILE *audio_dst_file = NULL;
  
  
  
  static uint8_t *video_dst_data[4] = {NULL};
  
  static int      video_dst_linesize[4];
  
  static int video_dst_bufsize;
  
  
  
  static uint8_t **audio_dst_data = NULL;
  
  static int       audio_dst_linesize;
  
  static int audio_dst_bufsize;
  
  
  
  static int video_stream_idx = -1, audio_stream_idx = -1;
  
  static AVFrame *frame = NULL;
  
  static AVPacket pkt;
  
  static int video_frame_count = 0;
  
  static int audio_frame_count = 0;
  
  //END DE
  
  
  
  static int sws_flags = SWS_BICUBIC;
  
  
  
  /**************************************************************/
  
  /* audio output */
  
  
  
  static float t, tincr, tincr2;
  
  static int16_t *samples;
  
  static int audio_input_frame_size;
  
  
  
  /* Add an output stream. */
  
  static AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
  
                              enum AVCodecID codec_id)
  
  {
  
      AVCodecContext *c;
  
      AVStream *st;
  
  
  
      /* find the encoder */
  
      *codec = avcodec_find_encoder(codec_id);
  
      if (!(*codec)) {
  
          fprintf(stderr, "Could not find encoder for &#39;%s&#39;\n",
  
                  avcodec_get_name(codec_id));
  
          exit(1);
  
      }
  
  
  
      st = avformat_new_stream(oc, *codec);
  
      if (!st) {
  
          fprintf(stderr, "Could not allocate stream\n");
  
          exit(1);
  
      }
  
      st->id = oc->nb_streams-1;
  
      c = st->codec;
  
  
  
      switch ((*codec)->type) {
  
      case AVMEDIA_TYPE_AUDIO:
  
          st->id = 1;
  
          c->sample_fmt  = AV_SAMPLE_FMT_S16;
  
          c->bit_rate    = 64000;
  
          c->sample_rate = 44100;
  
          c->channels    = 2;
  
          break;
  
  
  
      case AVMEDIA_TYPE_VIDEO:
  
          c->codec_id = codec_id;
  
  
  
          c->bit_rate = 400000;
  
          /* Resolution must be a multiple of two. */
  
          c->width    = 352;
  
          c->height   = 288;
  
          /* timebase: This is the fundamental unit of time (in seconds) in terms
  
           * of which frame timestamps are represented. For fixed-fps content,
  
           * timebase should be 1/framerate and timestamp increments should be
  
           * identical to 1. */
  
          c->time_base.den = STREAM_FRAME_RATE;
  
          c->time_base.num = 1;
  
          c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
  
          c->pix_fmt       = STREAM_PIX_FMT;
  
          if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
  
              /* just for testing, we also add B frames */
  
              c->max_b_frames = 2;
  
          }
  
          if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
  
              /* Needed to avoid using macroblocks in which some coeffs overflow.
  
               * This does not happen with normal video, it just happens here as
  
               * the motion of the chroma plane does not match the luma plane. */
  
              c->mb_decision = 2;
  
          }
  
      break;
  
  
  
      default:
  
          break;
  
      }
  
  
  
      /* Some formats want stream headers to be separate. */
  
      if (oc->oformat->flags &amp; AVFMT_GLOBALHEADER)
  
          c->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
  
  
      return st;
  
  }
  
  
  
  /**************************************************************/
  
  /* audio output */
  
  
  
  static float t, tincr, tincr2;
  
  static int16_t *samples;
  
  static int audio_input_frame_size;
  
  
  
  static void open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st)
  
  {
  
      AVCodecContext *c;
  
      int ret;
  
  
  
      c = st->codec;
  
  
  
      /* open it */
  
      ret = avcodec_open2(c, codec, NULL);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
  
          exit(1);
  
      }
  
  
  
      /* init signal generator */
  
      t     = 0;
  
      tincr = 2 * M_PI * 110.0 / c->sample_rate;
  
      /* increment frequency by 110 Hz per second */
  
      tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
  
  
  
      if (c->codec->capabilities &amp; CODEC_CAP_VARIABLE_FRAME_SIZE)
  
          audio_input_frame_size = 10000;
  
      else
  
          audio_input_frame_size = c->frame_size;
  
      samples = av_malloc(audio_input_frame_size *
  
                          av_get_bytes_per_sample(c->sample_fmt) *
  
                          c->channels);
  
      if (!samples) {
  
          fprintf(stderr, "Could not allocate audio samples buffer\n");
  
          exit(1);
  
      }
  
  }
  
  
  
  /* Prepare a 16 bit dummy audio frame of &#39;frame_size&#39; samples and
  
   * &#39;nb_channels&#39; channels. */
  
  static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
  
  {
  
      int j, i, v;
  
      int16_t *q;
  
  
  
      q = samples;
  
      for (j = 0; j &lt; frame_size; j++) {
  
          v = (int)(sin(t) * 10000);
  
          for (i = 0; i &lt; nb_channels; i++)
  
              *q++ = v;
  
          t     += tincr;
  
          tincr += tincr2;
  
      }
  
  }
  
  
  
  static void write_audio_frame(AVFormatContext *oc, AVStream *st)
  
  {
  
      AVCodecContext *c;
  
      AVPacket pkt = { 0 }; // data and size must be 0;
  
      AVFrame *frame = avcodec_alloc_frame();
  
      int got_packet, ret;
  
  
  
      av_init_packet(&amp;pkt);
  
      c = st->codec;
  
  
  
      get_audio_frame(samples, audio_input_frame_size, c->channels);
  
      frame->nb_samples = audio_input_frame_size;
  
      avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
  
                               (uint8_t *)samples,
  
                               audio_input_frame_size *
  
                               av_get_bytes_per_sample(c->sample_fmt) *
  
                               c->channels, 1);
  
  
  
      ret = avcodec_encode_audio2(c, &amp;pkt, frame, &amp;got_packet);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
  
          exit(1);
  
      }
  
  
  
      if (!got_packet)
  
          return;
  
  
  
      pkt.stream_index = st->index;
  
  
  
      /* Write the compressed frame to the media file. */
  
      ret = av_interleaved_write_frame(oc, &amp;pkt);
  
      if (ret != 0) {
  
          fprintf(stderr, "Error while writing audio frame: %s\n",
  
                  av_err2str(ret));
  
          exit(1);
  
      }
  
      avcodec_free_frame(&amp;frame);
  
  }
  
  
  
  static void close_audio(AVFormatContext *oc, AVStream *st)
  
  {
  
      avcodec_close(st->codec);
  
  
  
      av_free(samples);
  
  }
  
  
  
  /**************************************************************/
  
  /* video output */
  
  
  
  static AVFrame *frame;
  
  static AVPicture src_picture, dst_picture;
  
  static int frame_count;
  
  
  
  static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
  
  {
  
      int ret;
  
      AVCodecContext *c = st->codec;
  
  
  
      /* open the codec */
  
      ret = avcodec_open2(c, codec, NULL);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
  
          exit(1);
  
      }
  
  
  
      /* allocate and init a re-usable frame */
  
      frame = avcodec_alloc_frame();
  
      if (!frame) {
  
          fprintf(stderr, "Could not allocate video frame\n");
  
          exit(1);
  
      }
  
  
  
      /* Allocate the encoded raw picture. */
  
      ret = avpicture_alloc(&amp;dst_picture, c->pix_fmt, c->width, c->height);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Could not allocate picture: %s\n", av_err2str(ret));
  
          exit(1);
  
      }
  
  
  
      /* If the output format is not YUV420P, then a temporary YUV420P
  
       * picture is needed too. It is then converted to the required
  
       * output format. */
  
      if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
  
          ret = avpicture_alloc(&amp;src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Could not allocate temporary picture: %s\n",
  
                      av_err2str(ret));
  
              exit(1);
  
          }
  
      }
  
  
  
      /* copy data and linesize picture pointers to frame */
  
      *((AVPicture *)frame) = dst_picture;
  
  }
  
  
  
  /* Prepare a dummy image. */
  
  static void fill_yuv_image(AVPicture *pict, int frame_index,
  
                             int width, int height)
  
  {
  
      int x, y, i;
  
  
  
      i = frame_index;
  
  
  
      /* Y */
  
      for (y = 0; y &lt; height; y++)
  
          for (x = 0; x &lt; width; x++)
  
              pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
  
  
  
      /* Cb and Cr */
  
      for (y = 0; y &lt; height / 2; y++) {
  
          for (x = 0; x &lt; width / 2; x++) {
  
              pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
  
              pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
  
          }
  
      }
  
  }
  
  
  
  static void write_video_frame(AVFormatContext *oc, AVStream *st)
  
  {
  
      int ret;
  
      static struct SwsContext *sws_ctx;
  
      AVCodecContext *c = st->codec;
  
  
  
      if (frame_count >= STREAM_NB_FRAMES) {
  
          /* No more frames to compress. The codec has a latency of a few
  
           * frames if using B-frames, so we get the last frames by
  
           * passing the same picture again. */
  
      } else {
  
          if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
  
              /* as we only generate a YUV420P picture, we must convert it
  
               * to the codec pixel format if needed */
  
              if (!sws_ctx) {
  
                  sws_ctx = sws_getContext(c->width, c->height, AV_PIX_FMT_YUV420P,
  
                                           c->width, c->height, c->pix_fmt,
  
                                           sws_flags, NULL, NULL, NULL);
  
                  if (!sws_ctx) {
  
                      fprintf(stderr,
  
                              "Could not initialize the conversion context\n");
  
                      exit(1);
  
                  }
  
              }
  
              fill_yuv_image(&amp;src_picture, frame_count, c->width, c->height);
  
              sws_scale(sws_ctx,
  
                        (const uint8_t * const *)src_picture.data, src_picture.linesize,
  
                        0, c->height, dst_picture.data, dst_picture.linesize);
  
          } else {
  
              fill_yuv_image(&amp;dst_picture, frame_count, c->width, c->height);
  
          }
  
      }
  
  
  
      if (oc->oformat->flags &amp; AVFMT_RAWPICTURE) {
  
          /* Raw video case - directly store the picture in the packet */
  
          AVPacket pkt;
  
          av_init_packet(&amp;pkt);
  
  
  
          pkt.flags        |= AV_PKT_FLAG_KEY;
  
          pkt.stream_index  = st->index;
  
          pkt.data          = dst_picture.data[0];
  
          pkt.size          = sizeof(AVPicture);
  
  
  
          ret = av_interleaved_write_frame(oc, &amp;pkt);
  
      } else {
  
          AVPacket pkt = { 0 };
  
          int got_packet;
  
          av_init_packet(&amp;pkt);
  
  
  
          /* encode the image */
  
          ret = avcodec_encode_video2(c, &amp;pkt, frame, &amp;got_packet);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
  
              exit(1);
  
          }
  
          /* If size is zero, it means the image was buffered. */
  
  
  
          if (!ret &amp;&amp; got_packet &amp;&amp; pkt.size) {
  
              pkt.stream_index = st->index;
  
  
  
              /* Write the compressed frame to the media file. */
  
              ret = av_interleaved_write_frame(oc, &amp;pkt);
  
          } else {
  
              ret = 0;
  
          }
  
      }
  
      if (ret != 0) {
  
          fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
  
          exit(1);
  
      }
  
      frame_count++;
  
  }
  
  
  
  static void close_video(AVFormatContext *oc, AVStream *st)
  
  {
  
      avcodec_close(st->codec);
  
      av_free(src_picture.data[0]);
  
      av_free(dst_picture.data[0]);
  
      av_free(frame);
  
  }
  
  
  
  static int open_codec_context(int *stream_idx,
  
                                AVFormatContext *fmt_ctx, enum AVMediaType type)
  
  {
  
      int ret;
  
      AVStream *st;
  
      AVCodecContext *dec_ctx = NULL;
  
      AVCodec *dec = NULL;
  
  
  
      ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Could not find %s stream in input file &#39;%s&#39;\n",
  
                  av_get_media_type_string(type), src_filename);
  
          return ret;
  
      } else {
  
          *stream_idx = ret;
  
          st = fmt_ctx->streams[*stream_idx];
  
  
  
          /* find decoder for the stream */
  
          dec_ctx = st->codec;
  
          dec = avcodec_find_decoder(dec_ctx->codec_id);
  
          if (!dec) {
  
              fprintf(stderr, "Failed to find %s codec\n",
  
                      av_get_media_type_string(type));
  
              return ret;
  
          }
  
  
  
          if ((ret = avcodec_open2(dec_ctx, dec, NULL)) &lt; 0) {
  
              fprintf(stderr, "Failed to open %s codec\n",
  
                      av_get_media_type_string(type));
  
              return ret;
  
          }
  
      }
  
  
  
      return 0;
  
  }
  
  
  
  /**************************************************************/
  
  /* media file output */
  
  
  
  int main(int argc, char **argv)
  
  {
  
      const char *filename;
  
      AVOutputFormat *fmt;
  
      AVFormatContext *oc;
  
      AVStream *audio_st, *video_st;
  
      AVCodec *audio_codec, *video_codec;
  
      double audio_pts, video_pts;
  
      int ret = 0, got_frame;;
  
  
  
      /* Initialize libavcodec, and register all codecs and formats. */
  
      av_register_all();
  
  
  
      if (argc != 3) {
  
          printf("usage: %s input_file output_file\n"
  
                 "\n", argv[0]);
  
          return 1;
  
      }
  
  
  
      src_filename = argv[1];
  
      filename = argv[2];
  
  
  
      /* allocate the output media context */
  
      avformat_alloc_output_context2(&amp;oc, NULL, NULL, filename);
  
      if (!oc) {
  
          printf("Could not deduce output format from file extension: using MPEG.\n");
  
          avformat_alloc_output_context2(&amp;oc, NULL, "mpeg", filename);
  
      }
  
      if (!oc) {
  
          return 1;
  
      }
  
      fmt = oc->oformat;
  
  
  
      /* Add the audio and video streams using the default format codecs
  
       * and initialize the codecs. */
  
      video_stream = NULL;
  
      audio_stream = NULL;
  
  
  
      //FROM DE
  
      /* open input file, and allocate format context */
  
      if (avformat_open_input(&amp;fmt_ctx, src_filename, NULL, NULL) &lt; 0) {
  
          fprintf(stderr, "Could not open source file %s\n", src_filename);
  
          exit(1);
  
      }
  
  
  
      /* retrieve stream information */
  
      if (avformat_find_stream_info(fmt_ctx, NULL) &lt; 0) {
  
          fprintf(stderr, "Could not find stream information\n");
  
          exit(1);
  
      }
  
      if (open_codec_context(&amp;video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
  
          video_stream = fmt_ctx->streams[video_stream_idx];
  
          video_dec_ctx = video_stream->codec;
  
  
  
          /* allocate image where the decoded image will be put */
  
          ret = av_image_alloc(video_dst_data, video_dst_linesize,
  
                               video_dec_ctx->width, video_dec_ctx->height,
  
                               video_dec_ctx->pix_fmt, 1);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Could not allocate raw video buffer\n");
  
              goto end;
  
          }
  
          video_dst_bufsize = ret;
  
      }
  
  
  
      if (open_codec_context(&amp;audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
  
          int nb_planes;
  
  
  
          audio_stream = fmt_ctx->streams[audio_stream_idx];
  
          audio_dec_ctx = audio_stream->codec;
  
  
  
          nb_planes = av_sample_fmt_is_planar(audio_dec_ctx->sample_fmt) ?
  
              audio_dec_ctx->channels : 1;
  
          audio_dst_data = av_mallocz(sizeof(uint8_t *) * nb_planes);
  
          if (!audio_dst_data) {
  
              fprintf(stderr, "Could not allocate audio data buffers\n");
  
              ret = AVERROR(ENOMEM);
  
              goto end;
  
          }
  
      }
  
      //END DE
  
  
  
      /* Now that all the parameters are set, we can open the audio and
  
       * video codecs and allocate the necessary encode buffers. */
  
      if (video_stream)
  
          open_video(oc, video_codec, video_stream);
  
      if (audio_stream)
  
          open_audio(oc, audio_codec, audio_stream);
  
  
  
      av_dump_format(oc, 0, filename, 1);
  
  
  
      /* open the output file, if needed */
  
      if (!(fmt->flags &amp; AVFMT_NOFILE)) {
  
          ret = avio_open(&amp;oc->pb, filename, AVIO_FLAG_WRITE);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Could not open &#39;%s&#39;: %s\n", filename,
  
                      av_err2str(ret));
  
              return 1;
  
          }
  
      }
  
  
  
      /* Write the stream header, if any. */
  
      ret = avformat_write_header(oc, NULL);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Error occurred when opening output file: %s\n",
  
                  av_err2str(ret));
  
          return 1;
  
      }
  
  
  
      if (frame)
  
          frame->pts = 0;
  
      for (;;) {
  
          /* Compute current audio and video time. */
  
          if (audio_stream)
  
              audio_pts = (double)audio_stream->pts.val * audio_stream->time_base.num / audio_stream->time_base.den;
  
          else
  
              audio_pts = 0.0;
  
  
  
          if (video_stream)
  
              video_pts = (double)video_stream->pts.val * video_stream->time_base.num /
  
                          video_stream->time_base.den;
  
          else
  
              video_pts = 0.0;
  
  
  
          if ((!audio_stream || audio_pts >= STREAM_DURATION) &amp;&amp;
  
              (!video_stream || video_pts >= STREAM_DURATION))
  
              break;
  
  
  
          /* write interleaved audio and video frames */
  
          if (!video_stream || (video_stream &amp;&amp; audio_st &amp;&amp; audio_pts &lt; video_pts)) {
  
              write_audio_frame(oc, audio_stream);
  
          } else {
  
              write_video_frame(oc, video_stream);
  
              frame->pts += av_rescale_q(1, video_stream->codec->time_base, video_stream->time_base);
  
          }
  
      }
  
  
  
      /* Write the trailer, if any. The trailer must be written before you
  
       * close the CodecContexts open when you wrote the header; otherwise
  
       * av_write_trailer() may try to use memory that was freed on
  
       * av_codec_close(). */
  
      av_write_trailer(oc);
  
  
  
      /* Close each codec. */
  
      if (video_st)
  
          close_video(oc, video_st);
  
      if (audio_st)
  
          close_audio(oc, audio_st);
  
  
  
      if (!(fmt->flags &amp; AVFMT_NOFILE))
  
          /* Close the output file. */
  
          avio_close(oc->pb);
  
  
  
      /* free the stream */
  
      avformat_free_context(oc);
  
  
  
  end:
  
      if (video_dec_ctx)
  
          avcodec_close(video_dec_ctx);
  
      if (audio_dec_ctx)
  
          avcodec_close(audio_dec_ctx);
  
      avformat_close_input(&amp;fmt_ctx);
  
      if (video_dst_file)
  
          fclose(video_dst_file);
  
      if (audio_dst_file)
  
          fclose(audio_dst_file);
  
      av_free(frame);
  
      av_free(video_dst_data[0]);
  
      av_free(audio_dst_data);
  
  
  
      return 0;
  
  }

• CRO Audit : Increase Your Conversions in 10 Simple Steps

  25 mars 2024, par Erin

  You have two options if you’re unhappy with your website’s conversion rates.

  The first is to implement a couple of random tactics you heard on that marketing podcast, which worked for a business completely unrelated to yours. 

  The other is to take a more systematic, measured approach. An approach that finds specific problems with the pages on your site and fixes them one by one. 

  You’re choosing the second option, right ?

  Good, then let’s explain what a conversion rate optimisation audit is and how you can complete one using our step-by-step process.

  What is a CRO audit ?

  A conversion rate optimisation audit (CRO audit) systematically evaluates your website. It identifies opportunities to enhance your website’s performance and improve conversion rates. 

  During the audit, you’ll analyse your website’s entire customer journey, collect valuable user behaviour data and cross reference that with web analytics to find site elements (forms, calls-to-actions, etc.) that you can optimise.

  

  It’s one (and usually the first) part of a wider CRO strategy. 

  For example, an online retailer might run a CRO audit to discover why cart abandonment rates are high. The audit may throw up several potential problems (like a confusing checkout form and poor navigation), which the retailer can then spend time optimising using A/B tests. 

  Why run a CRO audit ?

  A CRO audit can be a lot of work, but it’s well worth the effort. Here are the benefits you can expect from running one.

  Generate targeted and relevant insights

  You’ve probably already tested some “best practice” conversion rate optimisations, like changing the colour of your CTA button, adding social proof or highlighting benefits to your headlines. 

  These are great, but they aren’t tailored to your audience. Running a CRO audit will ensure you find (and rectify) the conversion bottlenecks and barriers that impact your users, not someone else’s.

  Improve conversion rates

  Ultimately, CRO audits are about improving conversion rates and increasing revenue. Finding and eliminating barriers to conversion makes it much more likely that users will convert. 

  But that’s not all. CRO audits also improve the user experience and customer satisfaction. The audit process will help you understand how users behave on your website, allowing you to create a more user-friendly customer experience. 

  A 10-step process for running your first CRO audit 

  Want to conduct your first CRO audit ? Follow the ten-step process we outline below :

  

  1. Define your goals

  Start your CRO audit by setting conversion goals that marry with the wider goals of your business. The more clearly you define your goals, the easier it will be to evaluate your website for opportunities. 

  Your goals could include :

  • Booking more trials
  • Getting more email subscribers
  • Reducing cart abandonments

  You should also define the specific actions users need to take for you to achieve these goals. For example, users will have to click on your call-to-action and complete a form to book more trials. On the other hand, reducing cart abandonments requires users to add items to their cart and click through all of the forms during the checkout process. 

  If you’re unsure where to start, we recommend reading our CRO statistics roundup to see how your site compares to industry averages for metrics like conversion and click-through rates. 

  You’ll also want to ensure you track these conversion goals in your web analytics software. In Matomo, it only takes a few minutes to set up a new conversion goal, and the goals dashboard makes it easy to see your performance at a glance. 

  Try Matomo for Free

  Get the web insights you need, without compromising data accuracy.

  Start for free

  No credit card required

  2. Review your analytics

  With your goals in mind, the next step is to dive into your website analytics and identify pages that need improvement.

  Consider the following conversion metrics when analysing pages :

  • Conversion rate
  • Average time on page
  • Average order value
  • Click-through rate

  Ensure you’re analysing metrics aligning with the goals you set in step one. Average order value could be a great metric to track if you want to reduce cart abandonments, for example, but it’s unsuitable to get more email subscribers.

  3. Research the user experience

  Next, you’ll want to gather user experience data to better understand how potential customers use your website and why they aren’t converting as often as you’d like. 

  You can use several tools for user behaviour analysis, but we recommend heatmaps and session recordings.

  Heatmaps visually represent how users click, move and scroll your website. It will show where visitors place their attention and which page elements are ignored. 

  Take a look at this example below from our website. As you can see, the navigation, headline and CTA get the most attention. If we weren’t seeing as many conversions as we liked and our CTAs were getting ignored, that might be a sign to change their colour or placement. 

  

  Session recordings capture the actions users take as they browse your website. They let you watch a video playback of how visitors behave, capturing clicks and scrolls so you can see each visitor’s steps in order. 

  Session recordings will show you how users navigate and where they drop off. 

  4. Analyse your forms

  Whether your forms are too confusing or too long, there are plenty of reasons for users to abandon your forms. 

  But how many forms are they abandoning exactly and which forms are there ?

  That’s what form analysis is for. 

  Running a form analysis will highlight which forms need work and reveal whether forms could be contributing to a page’s poor conversion rate. It’s how Concrete CMS tripled its leads in just a few days.

  Matomo’s Form Analytics feature makes running form analysis easy.

  

  Just open up the forms dashboard to get a snapshot of your forms’ key metrics, including average hesitation time, starter rate and submission rates. 

  Try Matomo for Free

  Get the web insights you need, without compromising data accuracy.

  Start for free

  No credit card required

  5. Analyse your conversion funnel

  Next, analyse the conversion funnel to see if there’s an obvious bottleneck or several pages where visitors abandon your desired action. Common conversion abandonment points are shopping carts and forms.

  

  For example, you could find there is a drop-off in conversions between checking out and making a purchase or between booking a demo and signing up for a subscription. Understanding where these drop-offs occur lets you dig deeper and make targeted improvements.

  Don’t worry if you’ve got a very long funnel. Start at the bottom and work backward. Problems with the pages at the very end of your funnel tasked with converting customers (landing pages, checkout pages, etc.) will have the biggest impact on your conversion rate. So, it makes sense to start there. 

  6. Analyse campaigns and traffic sources (marketing attribution)

  It’s now time to analyse traffic quality to ensure you’re powering your conversion optimisation efforts with the best traffic possible. 

  This can also help you find your best customers so you can focus on acquiring more of them and tailoring your optimisation efforts to their preferences. 

  Run a marketing attribution report to see which traffic sources generate the most conversions and have the highest conversion rates. 

  

  Using marketing attribution is crucial here because it gives a fuller picture of how customers move through their journey, recognising the impact of various touchpoints in making a decision, unlike last-click attribution, which only credits the final touchpoint before a conversion.

  7. Use surveys and other qualitative data sources

  Increase the amount of qualitative data you have access to by speaking directly to customers. Surveys, interviews and other user feedback methods add depth and context to your user behaviour research.

  Sure, you aren’t getting feedback from hundreds of customers like you do with heatmaps or session recordings, but the information can sometimes be much richer. Users will often tell you outright why they didn’t take a specific action in a survey response (or what convinced them to convert). 

  Running surveys is now even easier in Matomo, thanks to the Matomo Surveys third-party plugin. This lets you add a customisable survey popup to your site, the data from which is automatically added to Matomo and can be combined with Matomo segments.

  8. Develop a conversion hypothesis

  Using all of the insights you’ve gathered up to this point, you can now hypothesise what’s wrong and how you can fix it. 

  Here’s a template you can use :

  

  This could end up looking something like the following :

  Based on evidence gathered from web analytics and heatmaps, moving our signup form above the fold will fix our lack of free trial signups, improving signups by 50%.

  

  Make sure you write your hypothesis down somewhere. Matomo lets you document your hypothesis when creating an A/B test, so it’s easy to reflect on when the test finishes. 

  9. Run A/B tests

  Now, it’s time to put your theory into practice by running an A/B test.

  Create an experiment using a platform like Matomo that creates two different versions of your page : the original and one with the change you mentioned in your hypothesis. 

  There’s no set time for you to run an A/B test. Just keep running it until the outcome is statistically significant. This is something your A/B testing platform should do automatically. 

  A statistically significant result means it would be very unlikely the outcome doesn’t happen in the long term.

  

  As you can see in the image above, the wide header variation has significantly outperformed both the original and the other variation. So we can be pretty confident about making the change permanent. 

  If the outcome of your A/B test also validates your conversion hypothesis, you can implement the change. If not, analyse the data, brainstorm another hypothesis and run another A/B test. 

  Try Matomo for Free

  Get the web insights you need, without compromising data accuracy.

  Start for free

  No credit card required

  10. Monitor and iterate

  You need to develop a culture of continuous improvement to succeed with conversion rate optimisation. That means constantly monitoring your conversion goals and running tests to improve your metrics. 

  While you don’t need to run a conversion audit every month, you should run audits regularly throughout the year.

  How often should you conduct a CRO audit ? 

  You should conduct a CRO audit fairly regularly. 

  We recommend creating a CRO schedule that sees you run a CRO audit every six to 12 months. That will ensure you continue identifying problem pages and keeping your conversion rates competitive. 

  Regular CRO audits will also account for evolving consumer behaviours, changes in your industry and your own business goals, all of which can impact your approach conversion rate optimisation. 

  Run your CRO audit with Matomo

  A CRO audit process is the only way you can identify conversion optimisation methods that will work for your site and your target audience. It’s a methodical, data-backed strategy for making targeted improvements to send conversion rates soaring. 

  There are a lot of steps to complete, but you don’t need dozens of tools to run a CRO audit process. 

  Just one : Matomo.

  Unlike other web analytics platforms, like Google Analytics, Matomo has the built-in tools and plugins to help with every step of the CRO audit process, from web analytics to conversion funnel analysis and A/B testing. With its accurate, unsampled data and privacy-friendly tracking, Matomo is the ideal choice for optimising conversions. 

  Learn how to increase your conversions with Matomo, and start a free 21-day trial today. No credit card required.

  Try Matomo for Free

  21 day free trial. No credit card required.

  
  

  Your email address
  

  Your website address
  

  Your Analytics subdomain will be .matomo.cloud (change)

  Choose your analytics subdomain
  

  .matomo.cloud

  I accept the terms and conditions and data processing agreement (DPA)

  
  Your information will be used to create an account on our cloud service. For more information please consult our privacy policy.
  
  
  

  Start improving your websites now