Recherche avancée
Médias (91)
-
MediaSPIP Simple : futur thème graphique par défaut ?
26 septembre 2013, par
Mis à jour : Octobre 2013
Langue : français
Type : Video
-
avec chosen
13 septembre 2013, par
Mis à jour : Septembre 2013
Langue : français
Type : Image
-
sans chosen
13 septembre 2013, par
Mis à jour : Septembre 2013
Langue : français
Type : Image
-
config chosen
13 septembre 2013, par
Mis à jour : Septembre 2013
Langue : français
Type : Image
-
SPIP - plugins - embed code - Exemple
2 septembre 2013, par
Mis à jour : Septembre 2013
Langue : français
Type : Image
-
GetID3 - Bloc informations de fichiers
9 avril 2013, par
Mis à jour : Mai 2013
Langue : français
Type : Image
Autres articles (25)
-
Selection of projects using MediaSPIP
2 mai 2011, parThe examples below are representative elements of MediaSPIP specific uses for specific projects.
MediaSPIP farm @ Infini
The non profit organizationInfini develops hospitality activities, internet access point, training, realizing innovative projects in the field of information and communication technologies and Communication, and hosting of websites. It plays a unique and prominent role in the Brest (France) area, at the national level, among the half-dozen such association. Its members (...) -
Keeping control of your media in your hands
13 avril 2011, parThe vocabulary used on this site and around MediaSPIP in general, aims to avoid reference to Web 2.0 and the companies that profit from media-sharing.
While using MediaSPIP, you are invited to avoid using words like "Brand", "Cloud" and "Market".
MediaSPIP is designed to facilitate the sharing of creative media online, while allowing authors to retain complete control of their work.
MediaSPIP aims to be accessible to as many people as possible and development is based on expanding the (...) -
Sélection de projets utilisant MediaSPIP
29 avril 2011, parLes exemples cités ci-dessous sont des éléments représentatifs d’usages spécifiques de MediaSPIP pour certains projets.
Vous pensez avoir un site "remarquable" réalisé avec MediaSPIP ? Faites le nous savoir ici.
Ferme MediaSPIP @ Infini
L’Association Infini développe des activités d’accueil, de point d’accès internet, de formation, de conduite de projets innovants dans le domaine des Technologies de l’Information et de la Communication, et l’hébergement de sites. Elle joue en la matière un rôle unique (...)
Sur d’autres sites (4428)
-
Resampling audio with FFMPEG LibAV
22 septembre 2020, par FennecFixWell, since FFMPEG documentation and code examples are absolute garbage, I guess my only choise is to go here and aks.


So what I'm trying to do is simply record audio from microphione and write it to the file. So I initialize my input and out formats, I get an audio packet decode it, resample, encode and write. But everytime I try to play and audio there's only a stub of data. It seems like for some reason it writes only a start packet. Which is still very strange and let me explain why :


if((response = swr_config_frame(resampleContext, audioOutputFrame, frame) < 0)) qDebug() << "can't configure frame!" << av_make_error(response);

if((response = swr_convert_frame(resampleContext, audioOutputFrame, frame) < 0)) qDebug() << "can't resample frame!" << av_make_error(response);


Here's the code I'm using to resample. My
framehas data butswr_convert_framewrites empty data toaudioOutputFrame

How do I fix that ? FFMPEG literally driving me crazy.


Here's the full code of my class


VideoReader.h


#ifndef VIDEOREADER_H
#define VIDEOREADER_H

extern "C"
{
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libswscale></libswscale>swscale.h>
#include <libavdevice></libavdevice>avdevice.h>
#include "libavutil/audio_fifo.h"
#include "libavformat/avio.h"
#include "libswresample/swresample.h"
#include 
}

#include <qstring>
#include <qelapsedtimer>

class VideoReader
{
public:
 VideoReader();

 bool open(const char* filename);
 bool fillFrame();
 bool readFrame(uint8_t *&frameData);
 void close();

 int width, height;

private:
 bool configInput();
 bool configOutput(const char *filename);
 bool configResampler();

 bool encode(AVFrame *frame, AVCodecContext *encoderContext, AVPacket *outputPacket, int streamIndex, QString type);

 int audioStreamIndex = -1;
 int videoStreamIndex = -1;

 int64_t videoStartPts = 0;
 int64_t audioStartPts = 0;

 AVFormatContext* inputFormatContext = nullptr;
 AVFormatContext* outputFormatContext = nullptr;

 AVCodecContext* videoDecoderContext = nullptr;
 AVCodecContext* videoEncoderContext = nullptr;

 AVCodecContext* audioDecoderContext = nullptr;
 AVCodecContext* audioEncoderContext = nullptr;

 AVFrame* videoInputFrame = nullptr;
 AVFrame* audioInputFrame = nullptr;

 AVFrame* videoOutputFrame = nullptr;
 AVFrame* audioOutputFrame = nullptr;

 AVPacket* inputPacket = nullptr;

 AVPacket* videoOutputPacket = nullptr;
 AVPacket* audioOutputPacket = nullptr;

 SwsContext* innerScaleContext = nullptr;
 SwsContext* outerScaleContext = nullptr;

 SwrContext *resampleContext = nullptr;
};

#endif // VIDEOREADER_H
</qelapsedtimer></qstring>

VideoReader.cpp


#include "VideoReader.h"

#include <qdebug>

static const char* av_make_error(int errnum)
{
 static char str[AV_ERROR_MAX_STRING_SIZE];
 memset(str, 0, sizeof(str));
 return av_make_error_string(str, AV_ERROR_MAX_STRING_SIZE, errnum);
}

VideoReader::VideoReader()
{

}

bool VideoReader::open(const char *filename)
{
 if(!configInput()) return false;
 if(!configOutput(filename)) return false;
 if(!configResampler()) return false;

 return true;
}

bool VideoReader::fillFrame()
{
 auto convertToYUV = [=](AVFrame* frame)
 {
 int response = 0;

 if((response = sws_scale(outerScaleContext, frame->data, frame->linesize, 0, videoEncoderContext->height, videoOutputFrame->data, videoOutputFrame->linesize)) < 0) qDebug() << "can't rescale" << av_make_error(response);
 };

 auto convertAudio = [this](AVFrame* frame)
 {
 int response = 0;

 auto& out = audioOutputFrame;
 qDebug() << out->linesize[0] << out->nb_samples;
 if((response = swr_convert_frame(resampleContext, audioOutputFrame, frame)) < 0) qDebug() << "can't resample frame!" << av_make_error(response);
 qDebug() << "poop";
 };

 auto decodeEncode = [=](AVPacket* inputPacket, AVFrame* inputFrame, AVCodecContext* decoderContext,
 AVPacket* outputPacket, AVFrame* outputFrame, AVCodecContext* encoderContext,
 std::function<void> convertFunc,
 int streamIndex, int64_t startPts, QString type)
 {
 int response = avcodec_send_packet(decoderContext, inputPacket);
 if(response < 0) { qDebug() << "failed to send" << type << "packet!" << av_make_error(response); return false; }

 response = avcodec_receive_frame(decoderContext, inputFrame);
 if(response == AVERROR(EAGAIN) || response == AVERROR_EOF) { av_packet_unref(inputPacket); return false; }
 else if (response < 0) { qDebug() << "failed to decode" << type << "frame!" << response << av_make_error(response); return false; }

 if(encoderContext)
 {
 outputFrame->pts = inputPacket->pts - startPts;

 convertFunc(inputFrame);
 if(!encode(outputFrame, encoderContext, outputPacket, streamIndex, type)) return false;
 }

 av_packet_unref(inputPacket);

 return true;
 };

 while(av_read_frame(inputFormatContext, inputPacket) >= 0) //actually read packet
 {
 if(inputPacket->stream_index == videoStreamIndex)
 {
 if(!videoStartPts) videoStartPts = inputPacket->pts;
 if(decodeEncode(inputPacket, videoInputFrame, videoDecoderContext, videoOutputPacket, videoOutputFrame, videoEncoderContext, convertToYUV, videoStreamIndex, videoStartPts, "video")) break;
 }
 else if(inputPacket->stream_index == audioStreamIndex)
 {
 if(!audioStartPts) audioStartPts = inputPacket->pts;
 if(decodeEncode(inputPacket, audioInputFrame, audioDecoderContext, audioOutputPacket, audioOutputFrame, audioEncoderContext, convertAudio, audioStreamIndex, audioStartPts, "audio")) break;
 }
 }

 return true;
}

bool VideoReader::readFrame(uint8_t *&frameData)
{
 if(!fillFrame()) { qDebug() << "readFrame method failed!"; return false; };

 const int bytesPerPixel = 4;

 uint8_t* destination[bytesPerPixel] = {frameData, NULL, NULL, NULL};
 int destinationLinesize[bytesPerPixel] = { videoInputFrame->width * bytesPerPixel, 0, 0, 0};

 sws_scale(innerScaleContext, videoInputFrame->data, videoInputFrame->linesize, 0, videoInputFrame->height, destination, destinationLinesize);

 return true;
}

void VideoReader::close()
{
 encode(NULL, videoEncoderContext, videoOutputPacket, videoStreamIndex, "video");
 encode(NULL, audioEncoderContext, audioOutputPacket, audioStreamIndex, "audio");

 if(av_write_trailer(outputFormatContext) < 0) { qDebug() << "failed to write trailer"; };

 avformat_close_input(&outputFormatContext);
 avformat_free_context(outputFormatContext);
 avformat_close_input(&inputFormatContext);
 avformat_free_context(inputFormatContext);

 av_frame_free(&videoInputFrame);
 av_frame_free(&audioInputFrame);

 av_frame_free(&videoOutputFrame);
 av_frame_free(&audioOutputFrame);

 av_packet_free(&inputPacket);

 av_packet_free(&videoOutputPacket);
 av_packet_free(&audioOutputPacket);

 avcodec_free_context(&videoDecoderContext);
 avcodec_free_context(&videoEncoderContext);

 avcodec_free_context(&audioDecoderContext);
 avcodec_free_context(&audioEncoderContext);

 sws_freeContext(innerScaleContext);
 sws_freeContext(outerScaleContext);

 swr_free(&resampleContext);
}

bool VideoReader::configInput()
{
 avdevice_register_all();

 inputFormatContext = avformat_alloc_context();

 if(!inputFormatContext) { qDebug() << "can't create context!"; return false; }

 const char* inputFormatName = "dshow";/*"gdigrab"*/
 AVInputFormat* inputFormat = av_find_input_format(inputFormatName);

 if(!inputFormat){ qDebug() << "Can't find" << inputFormatName; return false; }

 AVDictionary* options = NULL;
 av_dict_set(&options, "framerate", "30", 0);
 av_dict_set(&options, "video_size", "1920x1080", 0);

 if(avformat_open_input(&inputFormatContext, "video=HD USB Camera:audio=Microphone (High Definition Audio Device)" /*"desktop"*/, inputFormat, &options) != 0) { qDebug() << "can't open video file!"; return false; }

 AVCodecParameters* videoCodecParams = nullptr;
 AVCodecParameters* audioCodecParams = nullptr;
 AVCodec* videoDecoder = nullptr;
 AVCodec* audioDecoder = nullptr;

 for (uint i = 0; i < inputFormatContext->nb_streams; ++i)
 {
 auto stream = inputFormatContext->streams[i];
 auto codecParams = stream->codecpar;

 if(codecParams->codec_type == AVMEDIA_TYPE_AUDIO) { audioStreamIndex = i; audioDecoder = avcodec_find_decoder(codecParams->codec_id); audioCodecParams = codecParams; }
 if(codecParams->codec_type == AVMEDIA_TYPE_VIDEO) { videoStreamIndex = i; videoDecoder = avcodec_find_decoder(codecParams->codec_id); videoCodecParams = codecParams; }

 if(audioStreamIndex != -1 && videoStreamIndex != -1) break;
 }

 if(audioStreamIndex == -1) { qDebug() << "failed to find audio stream inside file"; return false; }
 if(videoStreamIndex == -1) { qDebug() << "failed to find video stream inside file"; return false; }

 auto configureCodecContext = [=](AVCodecContext*& context, AVCodec* decoder, AVCodecParameters* params, AVFrame*& frame, QString type)
 {
 context = avcodec_alloc_context3(decoder);
 if(!context) { qDebug() << "failed to create" << type << "decoder context!"; return false; }

 if(avcodec_parameters_to_context(context, params) < 0) { qDebug() << "can't initialize input" << type << "decoder context"; return false; }

 if(avcodec_open2(context, decoder, NULL) < 0) { qDebug() << "can't open" << type << "decoder"; return false; }

 frame = av_frame_alloc();
 if(!frame) { qDebug() << "can't allocate" << type << "frame"; return false; }

 return true;
 };

 if(!configureCodecContext(videoDecoderContext, videoDecoder, videoCodecParams, videoInputFrame, "video")) return false;
 if(!configureCodecContext(audioDecoderContext, audioDecoder, audioCodecParams, audioInputFrame, "audio")) return false;

 audioDecoderContext->channel_layout = AV_CH_LAYOUT_STEREO;
 audioInputFrame->channel_layout = audioDecoderContext->channel_layout;

 inputPacket = av_packet_alloc();
 if(!inputPacket) { qDebug() << "can't allocate input packet!"; return false; }

 //first frame, needed fo initialization
 if(!fillFrame()) { qDebug() << "Failed to fill frame on init!"; return false; };

 width = videoDecoderContext->width;
 height = videoDecoderContext->height;

 innerScaleContext = sws_getContext(width, height, videoDecoderContext->pix_fmt,
 width, height, AV_PIX_FMT_RGB0,
 SWS_FAST_BILINEAR,
 NULL,
 NULL,
 NULL);

 outerScaleContext = sws_getContext(width, height, videoDecoderContext->pix_fmt,
 width, height, AV_PIX_FMT_YUV420P,
 SWS_FAST_BILINEAR,
 NULL,
 NULL,
 NULL);


 if(!innerScaleContext) { qDebug() << "failed to initialize scaler context"; return false; }

 return true;
}

bool VideoReader::configOutput(const char *filename)
{
 avformat_alloc_output_context2(&outputFormatContext, NULL, NULL, filename);
 if(!outputFormatContext) { qDebug() << "failed to create output context"; return false; }

 AVOutputFormat* outputFormat = outputFormatContext->oformat;

 auto prepareOutputContext = [=](AVCodecContext*& encoderContext,
 std::function<void> configureContextFunc,
 std::function<void> configureFrameFunc,
 AVCodecID codecId, AVFrame*& frame, AVPacket*& packet, QString type)
 {
 auto stream = avformat_new_stream(outputFormatContext, NULL);
 if(!stream) { qDebug() << "failed to allocate output" << type << "stream"; return false; }

 AVCodec* encoder = avcodec_find_encoder(codecId);
 if(!encoder) { qDebug() << "failed to find" << type << "encoder!"; return false; }

 encoderContext = avcodec_alloc_context3(encoder);
 if(!encoderContext) { qDebug() << "failed to create video encoder context!"; return false; }

 configureContextFunc(encoderContext, encoder);

 int result = avcodec_open2(encoderContext, encoder, NULL);
 if(result < 0) { qDebug() << "failed to open audio encoder" << av_make_error(result); return false; }
 if(avcodec_parameters_from_context(stream->codecpar, encoderContext) < 0) { qDebug() << "failed to copy parameters to audio output stream"; return false; }

 packet = av_packet_alloc();
 if(!packet) {qDebug() << "failed allocate output" << type << "packet"; return false;}

 frame = av_frame_alloc();
 if(!frame) { qDebug() << "can't allocate output" << type << "frame"; return false; }

 configureFrameFunc(frame);

 av_frame_get_buffer(frame, 0);

 return true;
 };

 auto configureAudioFrame = [=](AVFrame* frame)
 {
 frame->nb_samples = audioEncoderContext->frame_size;
 frame->format = audioEncoderContext->sample_fmt;
 frame->sample_rate = audioEncoderContext->sample_rate;
 frame->channel_layout = av_get_default_channel_layout(audioDecoderContext->channels);
 };

 auto configureAudioEncoderContext = [=](AVCodecContext* encoderContext, AVCodec* encoder)
 {
 encoderContext->bit_rate = 64000;
 encoderContext->sample_fmt = encoder->sample_fmts[0];
 encoderContext->sample_rate = 44100;
 encoderContext->codec_type = AVMEDIA_TYPE_AUDIO;
 encoderContext->channel_layout = AV_CH_LAYOUT_STEREO;
 encoderContext->channels = av_get_channel_layout_nb_channels(encoderContext->channel_layout);
 };

 auto configureVideoFrame = [=](AVFrame* frame)
 {
 frame->format = videoEncoderContext->pix_fmt;
 frame->width = videoEncoderContext->width;
 frame->height = videoEncoderContext->height;
 };

 auto configureVideoEncoderContext = [=](AVCodecContext* encoderContext, AVCodec* encoder)
 {
 encoderContext->width = videoDecoderContext->width;
 encoderContext->height = videoDecoderContext->height;
 encoderContext->pix_fmt = encoder->pix_fmts[0];
 encoderContext->gop_size = 10;
 encoderContext->max_b_frames = 1;
 encoderContext->framerate = AVRational{30, 1};
 encoderContext->time_base = AVRational{1, 30};

 av_opt_set(encoderContext->priv_data, "preset", "ultrafast", 0);
 av_opt_set(encoderContext->priv_data, "tune", "zerolatency", 0);
 };

 if(!prepareOutputContext(videoEncoderContext, configureVideoEncoderContext, configureVideoFrame, outputFormat->video_codec, videoOutputFrame, videoOutputPacket, "video")) return false;
 if(!prepareOutputContext(audioEncoderContext, configureAudioEncoderContext, configureAudioFrame, outputFormat->audio_codec, audioOutputFrame, audioOutputPacket, "audio")) return false;

 if(outputFormat->flags & AVFMT_GLOBALHEADER) outputFormat->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

 int result = 0;
 if(!(outputFormat->flags & AVFMT_NOFILE))
 if((result = avio_open(&outputFormatContext->pb, filename, AVIO_FLAG_WRITE)) < 0)
 { qDebug() << "failed to open file" << av_make_error(result); return false; }

 result = avformat_write_header(outputFormatContext, NULL);
 if(result < 0) {qDebug() << "failed to write header!" << av_make_error(result); return false; }

 return true;
}

bool VideoReader::configResampler()
{

 resampleContext = swr_alloc_set_opts(NULL,
 av_get_default_channel_layout(audioEncoderContext->channels),
 audioEncoderContext->sample_fmt,
 audioEncoderContext->sample_rate,
 av_get_default_channel_layout(audioDecoderContext->channels),
 audioDecoderContext->sample_fmt,
 audioDecoderContext->sample_rate,
 0, NULL);
 if (!resampleContext) { qDebug() << "Could not allocate resample context"; return false; }

 int error;
 if ((error = swr_init(resampleContext)) < 0) { qDebug() << "Could not open resample context"; swr_free(&resampleContext); return false; }

 return true;
}

bool VideoReader::encode(AVFrame* frame, AVCodecContext* encoderContext, AVPacket* outputPacket, int streamIndex, QString type)
{
 int response;

 response = avcodec_send_frame(encoderContext, frame);
 if(response < 0) { qDebug() << "failed to send" << type << "frame" << av_make_error(response); return false; }

 while(response >= 0)
 {
 response = avcodec_receive_packet(encoderContext, outputPacket);
 if(response == AVERROR(EAGAIN) || response == AVERROR_EOF) { av_packet_unref(outputPacket); continue; }
 else if (response < 0) { qDebug() << "failed to encode" << type << "frame!" << response << av_make_error(response); return false; }

 outputPacket->stream_index = streamIndex;

 AVStream *inStream = inputFormatContext->streams[streamIndex];
 AVStream *outStream = outputFormatContext->streams[streamIndex];

 av_packet_rescale_ts(outputPacket, inStream->time_base, outStream->time_base);

 if((response = av_interleaved_write_frame(outputFormatContext, outputPacket)) != 0) { qDebug() << "Failed to write" << type << "packet!" << av_make_error(response); av_packet_unref(outputPacket); return false; }

 av_packet_unref(outputPacket);
 }

 return true;
}
</void></void></void></qdebug>

I could try to write down shorter example if needed


-
CRO Program : Best Practices and KPIs to Track [2024]
8 mai 2024, par ErinDriving traffic to your website is only one part of the equation ; the second part is getting those visitors to convert by completing a desired action — creating an account, signing up for a newsletter or completing a purchase.
But if you fail to optimise your website for conversions, you’ll have a hard time guiding visitors further down the funnel and turning them into customers.
That’s where a CRO program (or conversion rate optimisation) can help.
This article will cover conversion rate optimisation best practices and outline key metrics and KPIs to start tracking to see an improvement in your conversion rates.
What is a CRO program ?
In the simplest terms, a CRO program — also called a CRO plan — is a digital marketing strategy. It focuses on implementing different tactics that can lead to an increase in conversion rate and maximising revenue.
One thing to remember is that the definition of “conversion” varies from business to business. The most obvious type of conversion would be a financial transaction or a completed form — but it comes down to what you consider a valuable action.
Many different actions can count as conversions, depending on your marketing goals.
Besides making a purchase, other common examples of key conversion moments include creating a new account, signing up for a free trial, booking a demo and subscribing to an email newsletter.
Another thing worth noting is that while the average conversion rate on e-commerce websites is 3.76%, it might fluctuate across different industries and device types. Case in point — desktop devices have higher conversion rates than mobile devices, clocking in at 4.79% and 3.32%, respectively.
So, in addition to defining your key conversion moments, you should also go over conversion insights relevant to your specific industry.
The importance of conversion rate optimisation
You’d be right to assume that the ultimate goal of a conversion rate optimisation process is to drive revenue through higher conversion rates — but don’t focus solely on the numbers. The core principle of a CRO program is improving the customer experience. Once you’ve achieved that, the increase in conversion rate will follow.
According to a recent report, global conversion rate optimisation (CRO) software sales are expected to reach $3.7 billion by 2032 — up from $1.1 billion in 2021.
This growth indicates the increasing interest in strategies and tools that can help optimise the conversion funnel. Businesses are looking for ways to keep potential customers engaged and improve the average conversion rate — without necessarily increasing their spending.
Here are a few reasons why a CRO program deserves a spot in your broader digital marketing strategies :
- It can lower your cost per acquisition (CPA) : A CRO program is about optimising your conversion funnel by leveraging existing assets and website traffic rather than increasing your spending — which lowers the costs of acquiring new customers and, in turn, drives ROI.
- It can maximise customer lifetime value (CLV) : If you can turn one-time buyers into repeat customers, you’ll be one step closer to building a loyal user base and increasing your CLV.
- It can lead to increased sales and boost your revenue : Higher conversion rates typically mean higher revenue ; that’s arguably the most obvious benefit of implementing a CRO program.
- It improves the overall user experience : The goal is to make your site more accessible, easier to navigate and more engaging. Delivering the experience people want — and expect — when navigating your website is one of the core principles of a CRO program.
- It helps you to get to know your customers better : You can’t meet your customers’ needs without taking the time to know them, create user personas and understand their preferences, pain points and conversion barriers they may be facing.
Conversion optimisation gives you a competitive edge in revenue and brand reputation.
5 CRO best practices
Here are five conversion rate optimisation strategies and best practices that can make a real difference in the customer experience — and drive potential conversions.
Create a CRO roadmap in advance
First and foremost, you’ll need a well-defined “game plan” that aligns with and reflects your conversion goals.
A CRO roadmap is a detailed manual that outlines how to implement different elements of your CRO-related efforts. Marketing teams can refer to this step-by-step framework for test planning, prioritisation and resource allocation while optimising their marketing strategy.
While conversion rate optimisation can be a complex process — especially when you don’t know what to tackle first — we’ve found that there are three things you need to consider when setting the foundations of a successful CRO program :
- The “why” behind your website traffic : You’re likely using different online marketing strategies — from SEO to pay-per-click (PPC). So, it’s best to start by gathering channel-specific conversion insights through marketing attribution. Then identify which of these efforts have the biggest impact on your target audience.
- The so-called “conversion blockers” that tell you where and why visitors tend to leave without completing a desired action : Funnel analysis might reveal problematic pages — drop-off points where you tend to lose most of your visitors.
- Your “hooks” : User feedback can be of great help here ; you can learn a lot by simply asking your customers to fill out a quick online survey and tell you what motivated them to take action.
Before working on that “game plan,” perform a pre-test analysis.
Matomo combines web analytics and user behaviour analytics with features like Heatmaps, Session Recordings, Form Analytics, Funnel Analytics, A/B Testing and User Flow. It can give you those initial benchmarks for measuring progress and a potential increase in conversion rate.
Validate your ideas with A/B and multivariate testing
Conversion rate optimisation is an iterative process. So, it shouldn’t come as a surprise that A/B testing variants of page layouts, CTAs, headlines, copy and other elements is a big part of it.
Multivariate and A/B testing allows you to test a wide range of elements across your site and identify what works — and, more importantly, what doesn’t — in terms of driving conversions.
On that note, Matomo’s A/B Testing feature can support your conversion rate optimisation process by identifying variants that perform better based on statistical significance.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Get to know your website visitors
Driving conversions comes down to understanding potential customer’s pain points and needs — and delivering an experience that positions you as the solution and gets them to take action.
Here are a few things that can help you understand your website visitors better :
- Collecting customer feedback through surveys and using it to identify main areas for improvement
- Creating detailed customer personas and optimising your website design and messaging based on your target audience’s pain points, needs and wants
- Using heatmaps — colour-coded data visualisation tools that illustrate user interactions — and scroll maps to get a comprehensive overview of online sessions and identify the most engaging elements and those that stand out as potential conversion barriers
Matomo’s Heatmaps can help you identify the most-clicked elements on the page and show how far users scroll — providing powerful user insights you can use to optimise these pages.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Remove friction points
As we previously discussed, identifying friction points and barriers to conversion — issues that prevent visitors from converting — is one of the crucial aspects of developing a CRO plan.
Many different “conversion blockers” are worth looking into, including :
- Lengthy or otherwise complex checkout processes
- No guest checkout feature
- Device type, browser and OS compatibility issues
- Slow site speed and other technical issues
- Lack of free shipping and limited payment methods
- Absence of social proof (customer reviews and testimonials) and trust badges
Once you’ve identified what’s slowing down or completely discouraging users from reaching key conversion moments, take the time to address it.
Switch to text-based CTAs
Calls-to-action (CTAs) play a crucial role in guiding customers from interest to action. However, sometimes they fail to do their job — encouraging website visitors to proceed to the next step — effectively.
The most obvious reason is that your CTAs aren’t visually engaging or clear enough. In that case, you can try using action-oriented language and stronger visual elements and aligning the CTA copy with the context of the page.
But more often than not, the issue comes down to a phenomenon called “banner blindness” — the tendency of website visitors to ignore (either intentionally or unintentionally) elements on a page that resemble banner ads.
And if that’s what’s preventing visitors from converting, consider switching to text-based CTAs.
Conversion rate optimisation metrics and KPIs
At this point, you should know the outcomes you hope to achieve. Your next step should be to figure out how you’re going to measure and analyse results — and identify the changes that made the most impact on your conversion funnel.
After all, your CRO action plan should be based on data — assumptions and “gut feelings” will rarely lead to a notable increase in conversion rates.
That brings us to key performance indicators (KPIs) :
Tracking CRO metrics and website KPIs can help you understand the customer’s journey and path to purchase, identify opportunities for improving the user experience (UX) and determine how to optimise conversions.
That said, you shouldn’t try to track every metric in the book ; think about your ultimate goal and identify the metrics and KPIs most relevant to your business.
We’ll assume that you’re already tracking macro- and micro-conversions. However, we’ve outlined a few additional key conversion rate optimisation metrics you should keep an eye on to make sure that your CRO program is performing as intended :
- Cost-per-conversion : By measuring how much you spend on each successful conversion — again, completed forms, sign-ups and sales all count as key conversion moments — you’ll be in a better position to assess the cost-effectiveness of your online marketing strategies.
- Starter rate : This metric tells you the number of people who start filling out the form, after seeing it. This metric is particularly important for companies that rely on getting leads from forms.
- Average order value (AOV) : This metric is important for e-commerce sites to understand the value of their transactions. AOV calculates the average monetary value of each order.
That’s not all ; you can also use a web analytics tool like Matomo to gain granular insights into visitors :
- Unique, new and returning visitors : Tracking the number of new and returning visitors your website gets within a given timeframe will help you understand your user base and determine if your content resonates with them. While you want a constant stream of new traffic, don’t overlook the importance of returning visitors ; they’re the foundation of a loyal customer base.
- User flows : By analysing the user flows, you’ll have a visual representation of how visitors use your website, which will help you understand their journey and the specific path they take.
- Bounce rate : This metric tells you how many users viewed a single page on your site and ended up leaving before they took any kind of action. As such, it’s a clear indicator of how good your content, CTAs and website layout are at keeping users engaged.
- Exit rate : Another key metric to track is the exit rate — the percentage of users who drop off at a specific page. High-exit pages usually lack important information and CTAs, cause frustration or otherwise fail to meet users’ expectations. Keep in mind that there’s a difference between bounce rate and exit rate — the latter involves users who viewed at least one other page.
There are many other user engagement metrics you should keep an eye on in addition to the ones mentioned above — including time on-page, actions per visit, scroll depth and traffic source. You’ll find all this information — and more — in Matomo’s Page Analytics Report.
Conclusion
Implementing a CRO program can be a time-consuming and iterative process. However, it’s vital for guiding your marketing efforts and making data-driven decisions that’ll ultimately help you drive growth and reach your business goals.
It’s best to start by identifying where your website visitors come from and what contributes to — or prevents them from — taking further action. But that’s easier said than done. You’ll need to leverage web analytics tools like Matomo to gather powerful user insights and monitor your website’s performance.
As an all-in-one, privacy-friendly web analytics solution, Matomo combines traditional web analytics and advanced behavioural analytics — delivering a consistent experience based on 100% accurate, unsampled data.
Join the 1 million websites that have chosen Matomo as their web analytics platform. Start your 21-day free trial today — and see how Matomo can help you improve your website’s conversion rates. No credit card required.
Try Matomo for Free
21 day free trial. No credit card required.
-
Web Analytics Reports : 10 Key Types and How to Use Them
29 janvier 2024, par ErinYou can’t optimise your website to drive better results if you don’t know how visitors are engaging with your site.
But how do you correctly analyse data and identify patterns ? With the right platform, you can use a wide range of web analytics reports to dive deep into the data.
In this article, we’ll discuss what website analytics reports are, different types, why you need them, and how to use reports to find the insights you need.
What is web analytics ?
Website analytics is the process of gathering, processing, and analysing data that shows what users are doing when they visit your website.
You typically achieve this with web analytics tools by adding a tracking code that shares data with the analytics platform when someone visits the site.
The visitors trigger the tracking code, which collects data on how they act while on your site and then sends that information to the analytics platform. You can then see the data in your analytics solution and create reports based on this data.
While there are a lot of web analytics solutions available, this article will specifically demonstrate reports using Matomo.
What are web analytics reports ?
Web analytics reports are analyses that focus on specific data points within your analytics platform.
For example, this channel report in Matomo shows the top referring channels of a website.
Your marketing team can use this report to determine which channels drive the best results. In the example above, organic search drives almost double the visits and actions of social campaigns.
If you’re investing the same amount of money, you’d want to move more of your budget from social to search.
Why you need to get familiar with specific web analytics reports
The default web analytics dashboard offers an overview of high-level trends in performance. However, it usually does not give you specific insights that can help you optimise your marketing campaigns.
For example, you can see that your conversions are down month over month. But, at a glance, you do not understand why that is.
To understand why, you need to go granular and wider — looking into qualifying data that separates different types of visitors from each other.
Gartner predicts that 70% of organisations will focus on “small and wide” data by 2025 over “big data.” Most companies lack the data volume to simply let big data and algorithms handle the optimising.
What you can do instead is dive deep into each visitor. Figure out how they engage with your site, and then you can adjust your campaigns and page content accordingly.
Common types of web analytics reports
There are dozens of different web analytics reports, but they usually fall into four separate categories :
- Referral sources : These reports show where your visitors come from. They range from channel reports — search, social media — to specific campaigns and ads.
- Engagement (on-site actions) : These reports dive into what visitors are doing on your site. They break down clicks, scrolling, completed conversion goals, and more.
- E-commerce performance : These reports show the performance of your e-commerce store. They’ll help you dive into the sales of individual products, trends in cart abandonment and more.
- Demographics : These reports help you understand more about your visitors — where they’re visiting from, their browser language, device, and more.
You can even combine insights across all four using audience segmentation and custom reports. (We’ll cover this in more detail later.)
How to use 10 important website analytics reports
The first step is to install the website analytics code on your website. (We include more detailed information in our guide on how to track website visitors.)
Then, you need to wait until you have a few days (or, if you have limited traffic, a few weeks) of data. Without sufficient website visitor data, none of the reports will be meaningful.
Visitor Overview report
First, let’s take a look at the Visitor Overview report. It’s a general report that breaks down the visits over a given time period.
What this report shows :
- Trends in unique visits month over month
- Basic engagement trends like the average visit length and bounce rate
- The number of actions taken per page
In general, this report is more of a high-level indicator you can use to explore certain areas more thoroughly. For example, if most of your traffic comes from organic traffic or social media, you can dive deeper into those channels.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Location report
Next up, we have the most basic type of demographic report — the Location report. It shows where your visitors tend to access your website from.
What this report shows :
- The country, state or city your visitors access your website from
This report is most useful for identifying regional trends. You may notice that your site is growing in popularity in a country. You can take advantage of this by creating a regional campaign to double down on a high performing audience.
Device report
Next, we have the Device report, which breaks down your visitors’ devices.
What this report shows :
- Overall device types used by your visitors
- Specific device models used
Today, most websites are responsive or use mobile-first design. So, just seeing that many people access your site through smartphones probably isn’t all that surprising.
But you should ensure your responsive design doesn’t break down on popular devices. The design may not work effectively because many phones have different screen resolutions.
Users Flow report
The Users Flow report dives deeper into visitor engagement — how your visitors act on your site. It shows common landing pages — the first page visitors land on — and how they usually navigate your site from there.
What this report shows :
- Popular landing pages
- How your visitors most commonly navigate your site
You can use this report to determine which intermediary pages are crucial to keeping visitors engaged. For example, you can prioritise optimisation and rewriting for case study pages that don’t get a lot of direct search or campaign traffic.
Improving this flow can improve conversion rates and the impact of your marketing efforts.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Exit Pages report
The Exit Pages report complements the Users Flow report well. It highlights the most common pages visitors leave your website from.
What this report shows :
- The most common exit pages on your website
- The exit rates of these pages
Pages with high exit rates fall into two categories. The first are pages where it makes sense that visitors leave, like a post-purchase thank-you page. The second are pages where you’d want your visitors to stay and keep flowing down the funnel. When the rates are unusually high on product pages, category pages, or case study pages, you may have found a problem.
By combining insights from the Users Flow and Exit Pages reports, you can find valuable candidates for optimisation. This is a key aspect of effective conversion rate optimisation.
Traffic Acquisition Channel report
The Acquisition Channels report highlights the channels that drive the most visitors to your site.
What this report shows :
- Top referring traffic sources by channel type
- The average time on site, bounce rates, and actions taken by the source
Because of increasingly privacy-sensitive browsers and apps, the best way to reliably track traffic sources is to use campaign tracking URL. Matomo offers an easy-to-use campaign tracking URL builder to simplify this process.
Search Engines and Keywords report
The Search Engines and Keywords report shows which keywords are driving the most organic search traffic and from what search engines.
What this report shows :
- Search engine keywords that drive traffic
- The different search engines that refer visitors
One of the best ways to use this report is to identify low-hanging fruit. You want to find keywords driving some traffic where your page isn’t ranked in the top three results. If the keyword has high traffic potential, you should then work to optimise that page to rank higher and get more traffic. This technique is an efficient way to improve your SEO performance.
Ecommerce Products report
If you sell products directly on your website, the Ecommerce Products report is a lifesaver. It shows you exactly how all your products are performing.
What this report shows :
- How your products are selling
- The average sale price (with coupons) and quantity
This report could help an online retailer identify top-selling items, adjust pricing based on average sale prices, and strategically allocate resources to promote or restock high-performing products for maximum profitability.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Ecommerce Log report
If you want to explore every single ecommerce interaction, the Ecommerce Log report is for you. It breaks down the actions of visitors who add products to their cart in real time.
What this report shows :
- The full journey of completed purchases and abandoned carts
- The exact actions your potential customers take and how long their journeys last
If you suspect that the user experience of your online store isn’t perfect, this report helps you confirm or deny that suspicion. By closely examining individual interactions, you can identify common exit pages or other issues.
Syndiquer tout le site
