Recherche avancée
Médias (1)
-
Sintel MP4 Surround 5.1 Full
13 mai 2011, par
Mis à jour : Février 2012
Langue : English
Type : Video
Autres articles (96)
-
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 (...) -
Multilang : améliorer l’interface pour les blocs multilingues
18 février 2011, parMultilang est un plugin supplémentaire qui n’est pas activé par défaut lors de l’initialisation de MediaSPIP.
Après son activation, une préconfiguration est mise en place automatiquement par MediaSPIP init permettant à la nouvelle fonctionnalité d’être automatiquement opérationnelle. Il n’est donc pas obligatoire de passer par une étape de configuration pour cela. -
Gestion des droits de création et d’édition des objets
8 février 2011, parPar défaut, beaucoup de fonctionnalités sont limitées aux administrateurs mais restent configurables indépendamment pour modifier leur statut minimal d’utilisation notamment : la rédaction de contenus sur le site modifiables dans la gestion des templates de formulaires ; l’ajout de notes aux articles ; l’ajout de légendes et d’annotations sur les images ;
Sur d’autres sites (5276)
-
What is Audience Segmentation ? The 5 Main Types & Examples
16 novembre 2023, par Erin — Analytics TipsThe days of mass marketing with the same message for millions are long gone. Today, savvy marketers instead focus on delivering the most relevant message to the right person at the right time.
They do this at scale by segmenting their audiences based on various data points. This isn’t an easy process because there are many types of audience segmentation. If you take the wrong approach, you risk delivering irrelevant messages to your audience — or breaking their trust with poor data management.
In this article, we’ll break down the most common types of audience segmentation, share examples highlighting their usefulness and cover how you can segment campaigns without breaking data regulations.
What is audience segmentation ?
Audience segmentation is when you divide your audience into multiple smaller specific audiences based on various factors. The goal is to deliver a more targeted marketing message or to glean unique insights from analytics.
It can be as broad as dividing a marketing campaign by location or as specific as separating audiences by their interests, hobbies and behaviour.
Audience segmentation inherently makes a lot of sense. Consider this : an urban office worker and a rural farmer have vastly different needs. By targeting your marketing efforts towards agriculture workers in rural areas, you’re honing in on a group more likely to be interested in farm equipment.
Audience segmentation has existed since the beginning of marketing. Advertisers used to select magazines and placements based on who typically read them. They would run a golf club ad in a golf magazine, not in the national newspaper.
How narrow you can make your audience segments by leveraging multiple data points has changed.
Why audience segmentation matters
In a survey by McKinsey, 71% of consumers said they expected personalisation, and 76% get frustrated when a vendor doesn’t deliver.
These numbers reflect expectations from consumers who have actively engaged with a brand — created an account, signed up for an email list or purchased a product.
They expect you to take that data and give them relevant product recommendations — like a shoe polishing kit if you bought nice leather loafers.
If you don’t do any sort of audience segmentation, you’re likely to frustrate your customers with post-sale campaigns. If, for example, you just send the same follow-up email to all customers, you’d damage many relationships. Some might ask : “What ? Why would you think I need that ?” Then they’d promptly opt out of your email marketing campaigns.
To avoid that, you need to segment your audience so you can deliver relevant content at all stages of the customer journey.
5 key types of audience segmentation
To help you deliver the right content to the right person or identify crucial insights in analytics, you can use five types of audience segmentation : demographic, behavioural, psychographic, technographic and transactional.
Demographic segmentation
Demographic segmentation is when you segment a larger audience based on demographic data points like location, age or other factors.
The most basic demographic segmentation factor is location, which is easy to leverage in marketing efforts. For example, geographic segmentation can use IP addresses and separate marketing efforts by country.
But more advanced demographic data points are becoming increasingly sensitive to handle. Especially in Europe, GDPR makes advanced demographics a more tentative subject. Using age, education level and employment to target marketing campaigns is possible. But you need to navigate this terrain thoughtfully and responsibly, ensuring meticulous adherence to privacy regulations.
Potential data points :
- Location
- Age
- Marital status
- Income
- Employment
- Education
Example of effective demographic segmentation :
A clothing brand targeting diverse locations needs to account for the varying weather conditions. In colder regions, showcasing winter collections or insulated clothing might resonate more with the audience. Conversely, in warmer climates, promoting lightweight or summer attire could be more effective.
Here are two ads run by North Face on Facebook and Instagram to different audiences to highlight different collections :
Each collection is featured differently and uses a different approach with its copy and even the media. With social media ads, targeting people based on advanced demographics is simple enough — you can just single out the factors when making your campaign. But if you don’t want to rely on these data-mining companies, that doesn’t mean you have no options for segmentation.
Consider allowing people to self-select their interests or preferences by incorporating a short survey within your email sign-up form. This simple addition can enhance engagement, decrease bounce rates, and ultimately improve conversion rates, offering valuable insights into audience preferences.
This is a great way to segment ethically and without the need of data-mining companies.
Behavioural segmentation
Behavioural segmentation segments audiences based on their interaction with your website or app.
You use various data points to segment your target audience based on their actions.
Potential data points :
- Page visits
- Referral source
- Clicks
- Downloads
- Video plays
- Goal completion (e.g., signing up for a newsletter or purchasing a product)
Example of using behavioural segmentation to improve campaign efficiency :
One effective method involves using a web analytics tool such as Matomo to uncover patterns. By segmenting actions like specific clicks and downloads, pinpoint valuable trends—identifying actions that significantly enhance visitor conversions.
For instance, if a case study video substantially boosts conversion rates, elevate its prominence to capitalise on this success.
Then, you can set up a conditional CTA within the video player. Make it pop up after the user has watched the entire video. Use a specific form and sign them up to a specific segment for each case study. This way, you know the prospect’s ideal use case without surveying them.
This is an example of behavioural segmentation that doesn’t rely on third-party cookies.
Psychographic segmentation
Psychographic segmentation is when you segment audiences based on your interpretation of their personality or preferences.
Potential data points :
- Social media patterns
- Follows
- Hobbies
- Interests
Example of effective psychographic segmentation :
Here, Adidas segments its audience based on whether they like cycling or rugby. It makes no sense to show a rugby ad to someone who’s into cycling and vice versa. But to rugby athletes, the ad is very relevant.
If you want to avoid social platforms, you can use surveys about hobbies and interests to segment your target audience in an ethical way.
Technographic segmentation
Technographic segmentation is when you single out specific parts of your audience based on which hardware or software they use.
Potential data points :
- Type of device used
- Device model or brand
- Browser used
Example of segmenting by device type to improve user experience :
Upon noticing a considerable influx of tablet users accessing their platform, a leading news outlet decided to optimise their tablet browsing experience. They overhauled the website interface, focusing on smoother navigation and better readability for tablet users. These changes offered tablet users a seamless and enjoyable reading experience tailored precisely to their device.
Transactional segmentation
Transactional segmentation is when you use your customers’ purchase history to better target your marketing message to their needs.
When consumers prefer personalisation, they typically mean based on their actual transactions, not their social media profiles.
Potential data points :
- Average order value
- Product categories purchased within X months
- X days since the last purchase of a consumable product
Example of effective transactional segmentation :
A pet supply store identifies a segment of customers consistently purchasing cat food but not other pet products. They create targeted email campaigns offering discounts or loyalty rewards specifically for cat-related items to encourage repeat purchases within this segment.
If you want to improve customer loyalty and increase revenue, the last thing you should do is send generic marketing emails. Relevant product recommendations or coupons are the best way to use transactional segmentation.
B2B-specific : Firmographic segmentation
Beyond the five main segmentation types, B2B marketers often use “firmographic” factors when segmenting their campaigns. It’s a way to segment campaigns that go beyond the considerations of the individual.
Potential data points :
- Company size
- Number of employees
- Company industry
- Geographic location (office)
Example of effective firmographic segmentation :
Companies of different sizes won’t need the same solution — so segmenting leads by company size is one of the most common and effective examples of B2B audience segmentation.
The difference here is that B2B campaigns are often segmented through manual research. With an account-based marketing approach, you start by researching your potential customers. You then separate the target audience into smaller segments (or even a one-to-one campaign).
Start segmenting and analysing your audience more deeply with Matomo
Segmentation is a great place to start if you want to level up your marketing efforts. Modern consumers expect to get relevant content, and you must give it to them.
But doing so in a privacy-sensitive way is not always easy. You need the right approach to segment your customer base without alienating them or breaking regulations.
That’s where Matomo comes in. Matomo champions privacy compliance while offering comprehensive insights and segmentation capabilities. With robust privacy controls and cookieless configuration, it ensures GDPR and other regulations are met, empowering data-driven decisions without compromising user privacy.
Take advantage of our 21-day free trial to get insights that can help you improve your marketing strategy and better reach your target audience. No credit card required.
-
Getting and decoding video by RTP H264
29 novembre 2023, par AlekseiKraevParsing RTP H264.
WINAPI C. A queue from C++ has been applied, I repent.


RTP is generated using FFMPEG with the following command :
ffmpeg.exe -f gdigrab -framerate 25 -i desktop -s 853x480 -b:v 120000 -c:v libx264 -f rtp rtp ://127.0.0.1:8080


Parsing the incoming RTP/h264 stream and converting it to an RGB matrix.


video_H264_decode.h


#pragma once
#ifndef _VIDEO_H264_DECODE_SEND_H // Блокируем повторное включение этого модуля
#define _VIDEO_H264_DECODE_SEND_H
//******************************************************************************
// Section include
//******************************************************************************
#include "main.h"
#include 
//******************************************************************************
// Constants
//******************************************************************************

//******************************************************************************
// Type
//******************************************************************************
typedef struct {
 unsigned char* data;
 int size;
}RTPData_DType;

typedef struct 
{
 union
 {
 struct
 {
 char V:2; //Версия
 char P:1; //заполнение
 char X:1; //расширение
 char CC:4; //количество CSRC

 char M:1; //маркер (флаг последнего пакета AU),
 char PT:7; //полезная нагрузка (тип данных носителя полезной нагрузки RTP, H264 = 96)

 short sequence_number; //Порядковый номер: порядковый номер пакета RTP, увеличенный на 1.
 int time_stamp; //временная метка выборки медиа. 
 int SSRC; //Пакет данных имеет одинаковое происхождение.
 };
 unsigned char data[12];
 };
}RTPHeader_DType;
//******************************************************************************
// Global var
//******************************************************************************

//******************************************************************************
// Local function prototype
//******************************************************************************
UCHAR rtp_H264_recive_init(void);
UCHAR RTPStop(void);
//******************************************************************************
// Macros
//******************************************************************************
#define BYTE2_SWAP(X) ((((short)(X) & 0xff00) >> 8) |(((short)(X) & 0x00ff) << 8))
#endif
//******************************************************************************
// ENF OF FILE
//******************************************************************************


video_H264_decode.c


//******************************************************************************
//include
//******************************************************************************
#include "main.h"
/*#include "video_H264_decode.h"
#include 
#include 
#include <chrono>
#include 

#pragma comment(lib, "ws2_32.lib")
#include */
#include <iostream>
#include <queue>

extern "C" {
#include "libavformat/avformat.h"
#include "libavfilter/avfilter.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
#include "libswresample/swresample.h"
#include "libpostproc/postprocess.h"
#include "libavcodec/avcodec.h"
}

#pragma comment(lib,"avcodec.lib")
#pragma comment(lib,"avdevice.lib")
#pragma comment(lib,"avfilter.lib")
#pragma comment(lib,"avformat.lib")
#pragma comment(lib,"avutil.lib")
#pragma comment(lib,"postproc.lib")
#pragma comment(lib,"swresample.lib")
#pragma comment(lib,"swscale.lib")

#pragma warning(disable: 4996)
//******************************************************************************
// Section for determining the variables used in the module
//******************************************************************************
//------------------------------------------------------------------------------
// Global
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
// Local
//------------------------------------------------------------------------------
const int inteval = 0x01000000;
BOOL FlagRTPActive = TRUE;

HANDLE hMutexRTPRecive;
HANDLE hSemaphoreRTP;
HANDLE hTreadRTPRecive;
HANDLE hTreadRTPDecode;


SOCKET RTPSocket; //socket UDP RTP
RTPData_DType packet;
RTPData_DType FU_buffer = { 0 };

std::queue q;
std::set<int> seq;

AVFormatContext* pAVFormatContext;
AVCodecContext* pAVCodecContext;
const AVCodec* pAVCodec;
AVFrame* pAVFrame;
AVFrame* AVFrameRGG;
SwsContext* pSwsContext;
AVPacket *pAVPacket;
AVCodecParserContext* pAVCodecParserContext;

UINT port;
//******************************************************************************
// Section of prototypes of local functions
//******************************************************************************
DWORD WINAPI rtp_H264_recive_Procedure(CONST LPVOID lpParam);
DWORD WINAPI rtp_decode_Procedure(CONST LPVOID lpParam);
char RTPSocketInit(void);
void RTPPacketParser(void);
char RTPSocketRecive(void);
void Decode_NaluToAVFrameRGG();
//******************************************************************************
// Section of the description of functions
//******************************************************************************
UCHAR rtp_H264_recive_init(void)
{
 hSemaphoreRTP = CreateSemaphore(
 NULL, // default security attributes
 0, // initial count
 1, // maximum count
 NULL); // unnamed semaphore

 hMutexRTPRecive = CreateMutex(
 NULL, // default security attributes
 FALSE, // initially not owned
 NULL); // unnamed mutex

 hTreadRTPRecive = CreateThread(NULL, NULL, rtp_H264_recive_Procedure, NULL, NULL, NULL);
 hTreadRTPDecode = CreateThread(NULL, NULL, rtp_decode_Procedure, NULL, NULL, NULL);

 return 0;
}
//------------------------------------------------------------------------------
UCHAR RTPStop(void)
{
 FlagRTPActive = FALSE;

 if (hSemaphoreRTP) CloseHandle(hSemaphoreRTP);
 if (hMutexRTPRecive) CloseHandle(hMutexRTPRecive);
 if (hTreadRTPRecive) CloseHandle(hTreadRTPRecive);

 closesocket(RTPSocket); 

 return 0;
}
//------------------------------------------------------------------------------
DWORD WINAPI rtp_H264_recive_Procedure(CONST LPVOID lpParam)
{
 while (RTPSocketInit() == 0)
 Sleep(2000);
 
 while (1)
 {
 RTPSocketRecive();
 RTPPacketParser();
 ReleaseSemaphore(hSemaphoreRTP, 1, NULL);
 }
}
//------------------------------------------------------------------------------
DWORD WINAPI rtp_decode_Procedure(CONST LPVOID lpParam)
{
 port = param.Option.VideoPort;

 pAVPacket = av_packet_alloc();
 if (!pAVPacket)
 {
 MessageBox(NULL, L"ERROR Could not allocate pAVPacket", L"Init decoder error", MB_OK | MB_ICONERROR);
 exit(1);
 }
 av_init_packet(pAVPacket);

 /* find the MPEG-1 video decoder */
 pAVCodec = avcodec_find_decoder(AV_CODEC_ID_H264);
 if (!pAVCodec)
 {
 MessageBox(NULL, L"ERROR Codec not found", L"Init decoder error", MB_OK | MB_ICONERROR);
 exit(1);
 }

 pAVCodecParserContext = av_parser_init(pAVCodec->id);
 if (!pAVCodecParserContext)
 {
 MessageBox(NULL, L"ERROR Parser not found", L"Init decoder error", MB_OK | MB_ICONERROR);
 exit(1);
 }

 pAVCodecContext = avcodec_alloc_context3(pAVCodec);
 if (!pAVCodecContext) 
 {
 MessageBox(NULL, L"ERROR Could not allocate video codec context", L"Init decoder error", MB_OK | MB_ICONERROR);
 exit(1);
 }
 
 if (avcodec_open2(pAVCodecContext, pAVCodec, NULL) < 0)
 {
 MessageBox(NULL, L"ERROR Could not open codec", L"Init decoder error", MB_OK | MB_ICONERROR);
 exit(1);
 }

 pAVFrame = av_frame_alloc();
 if (!pAVFrame) 
 {
 MessageBox(NULL, L"ERROR Could not allocate video frame", L"Init decoder error", MB_OK | MB_ICONERROR);
 exit(1);
 } 
 
 while (FlagRTPActive)
 {
 if(port != param.Option.VideoPort)
 closesocket(RTPSocket);

 WaitForSingleObject(hSemaphoreRTP, 500); 
 Decode_NaluToAVFrameRGG();
 }

 avformat_free_context(pAVFormatContext);
 av_frame_free(&pAVFrame);
 avcodec_close(pAVCodecContext);
 av_packet_free(&pAVPacket);

 
 if (hTreadRTPDecode) CloseHandle(hTreadRTPDecode);

 return 0;
}

//------------------------------------------------------------------------------
char RTPSocketInit(void)
{ 
 sockaddr_in RTPSocketAddr;
 
 RTPSocketAddr.sin_family = AF_INET;
 RTPSocketAddr.sin_addr.s_addr = htonl(INADDR_ANY);
 RTPSocketAddr.sin_port = htons(param.Option.VideoPort);

 RTPSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 if (RTPSocket == INVALID_SOCKET)
 {
 MessageBox(NULL, L"ERROR Invalid RTP Socket", L"UDP Socket", MB_OK | MB_ICONERROR);
 return 0;
 }

 int option = 12000;
 if (setsockopt(RTPSocket, SOL_SOCKET, SO_RCVBUF, (char*)&option, sizeof(option)) < 0)
 {
 printf("setsockopt failed\n");

 }

 /*option = TRUE;
 if (setsockopt(RTPSocket, SOL_SOCKET, SO_CONDITIONAL_ACCEPT, (char*)&option, sizeof(option)) < 0)
 {
 printf("setsockopt failed\n");

 }*/

 if (bind(RTPSocket, (sockaddr*)&RTPSocketAddr, sizeof(RTPSocketAddr)) == SOCKET_ERROR)
 {
 MessageBox(NULL, L"ERROR bind", L"UDP Socket", MB_OK | MB_ICONERROR);
 closesocket(RTPSocket);
 return 0;
 }
 return 1;
}

//------------------------------------------------------------------------------
char RTPSocketRecive(void)
{
 static char RecvBuf[2000];
 static int BufLen = 2000;

 int iResult = 0;
 struct sockaddr_in SenderAddr;
 int SenderAddrSize = sizeof(SenderAddr);
 TCHAR szErrorMsg[100];

 iResult = recvfrom(RTPSocket, RecvBuf, BufLen, 0, NULL, NULL);
 if (iResult == SOCKET_ERROR && FlagRTPActive == TRUE)
 {
 StringCchPrintf(szErrorMsg, 100, L"ERROR recvfrom Ошибка:%d", WSAGetLastError());
 MessageBox(NULL, szErrorMsg, L"UDP Socket", MB_OK | MB_ICONERROR);
 return -1;
 }

 packet.data = (unsigned char*)RecvBuf;
 packet.size = iResult;

 return 1;
}

//------------------------------------------------------------------------------
void RTPPacketParser(void)
{
 RTPHeader_DType RTPHeader;
 RTPData_DType NALU;
 unsigned char* buffer = packet.data;
 int pos = 0;
 static int count = 0;
 static short lastSequenceNumber = 0xFFFF;
 short type;
 char payload_header;

 //read rtp header
 memcpy(&RTPHeader, buffer, sizeof(RTPHeader));
 RTPHeader.sequence_number = BYTE2_SWAP(RTPHeader.sequence_number);
 pos += 12; 
 
 if (RTPHeader.X) {
 //profile extension
 short define;
 short length;
 length = buffer[pos + 3];//suppose not so long extension
 pos += 4;
 pos += (length * 4);
 }

 payload_header = buffer[pos];
 type = payload_header & 0x1f; //Тип полезной нагрузки RTP
 pos++;
 
 //STAP-A
 if (type == 24)
 { 
 while (pos < packet.size)
 {
 unsigned short NALU_size;
 memcpy(&NALU_size, buffer + pos, 2);
 NALU_size = BYTE2_SWAP(NALU_size);
 pos += 2;
 char NAL_header = buffer[pos];
 short NAL_type = NAL_header & 0x1f;

 if (NAL_type == 7) 
 {
 count++;
 //cout<<"SPS, sequence number: "</cout<<"PPS, sequence number: "</cout<<"end of sequence, sequence number: "< 0) 
 {
 NALU.data = (unsigned char*) malloc(NALU_size + 4);
 NALU.size = NALU_size + 4;
 memcpy(NALU.data, &inteval, 4);
 memcpy(NALU.data + 4, &buffer[pos], NALU_size);

 WaitForSingleObject(hMutexRTPRecive, INFINITE);
 q.push(NALU);
 ReleaseMutex(hMutexRTPRecive);
 }

 pos += NALU_size;
 }
 }
 //FU-A Fragmentation unit
 else if (type == 28)
 { 
 //FU header
 char FU_header = buffer[pos];
 bool fStart = FU_header & 0x80;
 bool fEnd = FU_header & 0x40;

 //NAL header
 char NAL_header = (payload_header & 0xe0) | (FU_header & 0x1f);
 short NAL_type = FU_header & 0x1f;
 if (NAL_type == 7) 
 {
 count++;
 //SPS
 }
 else if (NAL_type == 8) 
 {
 //PPS
 }
 else if (NAL_type == 10) 
 {
 //end of sequence
 }
 pos++;

 int size = packet.size - pos;
 
 if (count > 0)
 {
 if (fStart) 
 {
 if (FU_buffer.size != 0)
 {
 free(FU_buffer.data);
 FU_buffer.size = 0;
 }
 FU_buffer.data = (unsigned char*)malloc(size + 5);
 if (FU_buffer.data == NULL)
 return;
 FU_buffer.size = size + 5;
 memcpy(FU_buffer.data, &inteval, 4);
 memcpy(FU_buffer.data + 4, &NAL_header, 1);
 memcpy(FU_buffer.data + 5, buffer + pos, size);
 }
 else
 {
 unsigned char* temp = (unsigned char*)malloc(FU_buffer.size + size);
 memcpy(temp, FU_buffer.data, FU_buffer.size);
 memcpy(temp + FU_buffer.size, buffer + pos, size);
 if (FU_buffer.size != 0) free(FU_buffer.data);
 FU_buffer.data = temp;
 FU_buffer.size += size;
 }

 if (fEnd)
 {
 NALU.data = (unsigned char*)malloc(FU_buffer.size);
 NALU.size = FU_buffer.size;
 memcpy(NALU.data, FU_buffer.data, FU_buffer.size);

 WaitForSingleObject(hMutexRTPRecive, INFINITE);
 q.push(NALU);
 ReleaseMutex(hMutexRTPRecive);

 free(FU_buffer.data);
 FU_buffer.size = 0;
 }
 }
 
 }
 else 
 {
 //other type
 short NAL_type = type;
 if (NAL_type == 7) 
 {
 count++;
 //SPS
 }
 else if (NAL_type == 8) 
 {
 //PPS
 }
 else if (NAL_type == 10) 
 {
 //end of sequence
 }

 int size = packet.size - pos + 1;
 if (count > 0)
 {
 NALU.data = (unsigned char*)malloc(size+4);
 NALU.size = size + 4;
 memcpy(NALU.data, &inteval, 4);
 memcpy(NALU.data + 4, &buffer[12], size);

 WaitForSingleObject(hMutexRTPRecive, INFINITE);
 q.push(NALU);
 ReleaseMutex(hMutexRTPRecive);
 }
 }
}

//------------------------------------------------------------------------------
void Decode_NaluToAVFrameRGG()
{
 unsigned char cntNALU;
 int len = 0;
 static int size = 0;
 unsigned char* data = NULL;
 int ret;
 RTPData_DType NALU;

 av_frame_unref(pAVFrame);
 av_packet_unref(pAVPacket);

 while(1)
 {
 WaitForSingleObject(hMutexRTPRecive, INFINITE);
 if (q.empty())
 {
 ReleaseMutex(hMutexRTPRecive);
 break;
 }
 NALU = q.front();
 q.pop();
 ReleaseMutex(hMutexRTPRecive);

 data = NALU.data;
 size = NALU.size;

 while(size)
 { 
 len = av_parser_parse2(pAVCodecParserContext, pAVCodecContext, &pAVPacket->data, &pAVPacket->size,
 (uint8_t*)data, size,
 AV_NOPTS_VALUE, AV_NOPTS_VALUE, AV_NOPTS_VALUE);

 data = len ? data + len : data;
 size -= len;
 
 if (pAVPacket->size)
 {
 ret = avcodec_send_packet(pAVCodecContext, pAVPacket);

 if(ret == AVERROR_EOF)
 MessageBox(NULL, L"the codec has been fully flushed, and there will be no more output frames", L"avcodec_send_packet", MB_OK | MB_ICONERROR);

 if (ret < 0)
 {
 MessageBox(NULL, L"ERROR sending a packet for decoding", L"Decode", MB_OK | MB_ICONERROR);
 //exit(1);
 }

 while (ret >= 0) 
 {
 ret = avcodec_receive_frame(pAVCodecContext, pAVFrame);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 break;
 else if (ret < 0) {
 MessageBox(NULL, L"ERROR during decoding", L"Decode", MB_OK | MB_ICONERROR);
 //exit(1);
 }
 
 AVFrameRGG = av_frame_alloc(); 
 pSwsContext = sws_getContext(pAVCodecContext->width, pAVCodecContext->height, pAVCodecContext->pix_fmt,
 pAVCodecContext->width, pAVCodecContext->height, AV_PIX_FMT_RGB24, SWS_SPLINE,
 0, 0, 0);

 sws_scale_frame(pSwsContext, AVFrameRGG, pAVFrame);
 
 ImgBufferSet(AVFrameRGG->data[0], pAVCodecContext->height, pAVCodecContext->width, AVFrameRGG->linesize[0]);

 sws_freeContext(pSwsContext);
 av_frame_free(&AVFrameRGG);
 }
 }
 }
 free(NALU.data);
 NALU.size = 0;
 } 
}

</int></queue></iostream></chrono>

It's DECIDED


-
Clickstream Data : Definition, Use Cases, and More
15 avril 2024, par ErinGaining a deeper understanding of user behaviour — customers’ different paths, digital footprints, and engagement patterns — is crucial for providing a personalised experience and making informed marketing decisions.
In that sense, clickstream data, or a comprehensive record of a user’s online activities, is one of the most valuable sources of actionable insights into users’ behavioural patterns.
This article will cover everything marketing teams need to know about clickstream data, from the basic definition and examples to benefits, use cases, and best practices.
What is clickstream data ?
As a form of web analytics, clickstream data focuses on tracking and analysing a user’s online activity. These digital breadcrumbs offer insights into the websites the user has visited, the pages they viewed, how much time they spent on a page, and where they went next.
Your clickstream pipeline can be viewed as a “roadmap” that can help you recognise consistent patterns in how users navigate your website.
With that said, you won’t be able to learn much by analysing clickstream data collected from one user’s session. However, a proper analysis of large clickstream datasets can provide a wealth of information about consumers’ online behaviours and trends — which marketing teams can use to make informed decisions and optimise their digital marketing strategy.
Clickstream data collection can serve numerous purposes, but the main goal remains the same — gaining valuable insights into visitors’ behaviours and online activities to deliver a better user experience and improve conversion likelihood.
Depending on the specific events you’re tracking, clickstream data can reveal the following :
- How visitors reach your website
- The terms they type into the search engine
- The first page they land on
- The most popular pages and sections of your website
- The amount of time they spend on a page
- Which elements of the page they interact with, and in what sequence
- The click path they take
- When they convert, cancel, or abandon their cart
- Where the user goes once they leave your website
As you can tell, once you start collecting this type of data, you’ll learn quite a bit about the user’s online journey and the different ways they engage with your website — all without including any personal details about your visitors.
Types of clickstream data
While all clickstream data keeps a record of the interactions that occur while the user is navigating a website or a mobile application — or any other digital platform — it can be divided into two types :
- Aggregated (web traffic) data provides comprehensive insights into the total number of visits and user interactions on a digital platform — such as your website — within a given timeframe
- Unaggregated data is broken up into smaller segments, focusing on an individual user’s online behaviour and website interactions
One thing to remember is that to gain valuable insights into user behaviour and uncover sequential patterns, you need a powerful tool and access to full clickstream datasets. Matomo’s Event Tracking can provide a comprehensive view of user interactions on your website or mobile app — everything from clicking a button and completing a form to adding (or removing) products from their cart.
On that note, based on the specific events you’re tracking when a user visits your website, clickstream data can include :
- Web navigation data : referring URL, visited pages, click path, and exit page
- User interaction data : mouse movements, click rate, scroll depth, and button clicks
- Conversion data : form submissions, sign-ups, and transactions
- Temporal data : page load time, timestamps, and the date and time of day of the user’s last login
- Session data : duration, start, and end times and number of pages viewed per session
- Error data : 404 errors and network or server response issues
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Clickstream data benefits and use cases
Given the actionable insights that clickstream data collection provides, it can serve a wide range of use cases — from identifying behavioural patterns and trends and examining competitors’ performance to helping marketing teams map out customer journeys and improve ROI.
According to the global Clickstream Analytics Market Report 2024, some key applications of clickstream analytics include click-path optimisation, website and app optimisation, customer analysis, basket analysis, personalisation, and traffic analysis.
The behavioural patterns and user preferences revealed by clickstream analytics data can have many applications — we’ve outlined the prominent use cases below.
Customer journey mapping
Clickstream data allows you to analyse the e-commerce customer’s online journey and provides insights into how they navigate your website. With such a comprehensive view of their click path, it becomes easier to understand user behaviour at each stage — from initial awareness to conversion — identify the most effective touchpoints and fine-tune that journey to improve their conversion likelihood.
Identifying customer trends
Clickstream data analytics can also help you identify trends and behavioural patterns — the most common sequences and similarities in how users reached your website and interacted with it — especially when you can access data from many website visitors.
Think about it — there are many ways in which you can use these insights into the sequence of clicks and interactions and recurring patterns to your team’s advantage.
Here’s an example :
It can reveal that some pieces of content and CTAs are performing well in encouraging visitors to take action — which shows how you should optimise other pages and what you should strive to create in the future, too.
Preventing site abandonment
Cart abandonment remains a serious issue for online retailers :
According to a recent report, the global cart abandonment rate in the fourth quarter of 2023 was at 83%.
That means that roughly eight out of ten e-commerce customers will abandon their shopping carts — most commonly due to additional costs, slow website loading times and the requirement to create an account before purchasing.
In addition to cart abandonment predictions, clickstream data analytics can reveal the pages where most visitors tend to leave your website. These drop-off points are clear indicators that something’s not working as it should — and once you can pinpoint them, you’ll be able to address the issue and increase conversion likelihood.
Improving marketing campaign ROI
As previously mentioned, clickstream data analysis provides insights into the customer journey. Still, you may not realise that you can also use this data to keep track of your marketing effectiveness.
Global digital ad spending continues to grow — and is expected to reach $836 billion by 2026. It’s easy to see why relying on accurate data is crucial when deciding which marketing channels to invest in.
You want to ensure you’re allocating your digital marketing and advertising budget to the channels — be it SEO, pay-per-click (PPC) ads, or social media campaigns — that impact driving conversions.
When you combine clickstream e-commerce data with conversion rates, you’ll find the latter in Matomo’s goal reports and have a solid, data-driven foundation for making better marketing decisions.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Delivering a better user experience (UX)
Clickstream data analysis allows you to identify specific “pain points” — areas of the website that are difficult to use and may cause customer frustration.
It’s clear how this would be beneficial to your business :
Once you’ve identified these pain points, you can make the necessary changes to your website’s layout and address any technical issues that users might face, improving usability and delivering a smoother experience to potential customers.
Collecting clickstream data : Tools and legal implications
Your team will need a powerful tool capable of handling clickstream analytics to reap the benefits we’ve discussed previously. But at the same time, you need to respect users’ online privacy throughout clickstream data collection.
Generally speaking, there are two ways to collect data about users’ online activity — web analytics tools and server log files.
Web analytics tools are the more commonly used solution. Specifically designed to collect and analyse website data, these tools rely on JavaScript tags that run in the browser, providing actionable insights about user behaviour. Server log files can be a gold mine of data, too — but that data is raw and unfiltered, making it much more challenging to interpret and analyse.
That brings us to one of the major clickstream challenges to keep in mind as you move forward — compliance.
While Google remains a dominant player in the web analytics market, there’s one area where Matomo has a significant advantage — user privacy.
Matomo operates according to privacy laws — including the General Data Protection Regulation (GDPR) and California Consumer Privacy Act (CCPA), making it an ethical alternative to Google Analytics.
It should go without saying, but compliance with data privacy laws — the most talked-about one being the GDPR framework introduced by the EU — isn’t something you can afford to overlook.
The GDPR was first implemented in the EU in 2018. Since then, several fines have been issued for non-compliance — including the record fine of €1.2 billion that Meta Platforms, Inc. received in 2023 for transferring personal data of EU-based users to the US.
Clickstream analytics data best practices
As valuable as it might be, processing large amounts of clickstream analytics data can be a complex — and, at times, overwhelming — process.
Here are some best practices to keep in mind when it comes to clickstream analysis :
Define your goals
It’s essential to take the time to define your goals and objectives.
Once you have a clear idea of what you want to learn from a given clickstream dataset and the outcomes you hope to see, it’ll be easier to narrow down your scope — rather than trying to tackle everything at once — before moving further down the clickstream pipeline.
Here are a few examples of goals and objectives you can set for clickstream analysis :
- Understanding and predicting users’ behavioural patterns
- Optimising marketing campaigns and ROI
- Attributing conversions to specific marketing touchpoints and channels
Analyse your data
Collecting clickstream analytics data is only part of the equation ; what you do with raw data and how you analyse it matters. You can have the most comprehensive dataset at your disposal — but it’ll be practically worthless if you don’t have the skill set to analyse and interpret it.
In short, this is the stage of your clickstream pipeline where you uncover common sequences and consistent patterns in user behaviour.
Clickstream data analytics can extract actionable insights from large datasets using various approaches, models, and techniques.
Here are a few examples :
- If you’re working with clickstream e-commerce data, you should perform funnel or conversion analyses to track conversion rates as users move through your sales funnel.
- If you want to group and analyse users based on shared characteristics, you can use Matomo for cohort analysis.
- If your goal is to predict future trends and outcomes — conversion and cart abandonment prediction, for example — based on available data, prioritise predictive analytics.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Organise and visualise your data
As you reach the end of your clickstream pipeline, you need to start thinking about how you will present and communicate your data. And what better way to do that than to transform that data into easy-to-understand visualisations ?
Here are a few examples of easily digestible formats that facilitate quick decision-making :
- User journey maps, which illustrate the exact sequence of interactions and user flow through your website
- Heatmaps, which serve as graphical — and typically colour-coded — representations of a website visitor’s activity
- Funnel analysis, which are broader at the top but get increasingly narrower towards the bottom as users flow through and drop off at different stages of the pipeline
Collect clickstream data with Matomo
Clickstream data is hard to beat when tracking the website visitor’s journey — from first to last interaction — and understanding user behaviour. By providing real-time insights, your clickstream pipeline can help you see the big picture, stay ahead of the curve and make informed decisions about your marketing efforts.
Matomo accurate data and compliance with GDPR and other data privacy regulations — it’s an all-in-one, ethical platform that can meet all your web analytics needs. That’s why over 1 million websites use Matomo for their web analytics.
Try Matomo free for 21 days. No credit card required.
Try Matomo for Free
21 day free trial. No credit card required.
Syndiquer tout le site
