Recherche avancée
Autres articles (61)
-
Websites made with MediaSPIP
2 mai 2011, parThis page lists some websites based on MediaSPIP.
-
Configuration spécifique d’Apache
4 février 2011, parModules spécifiques
Pour la configuration d’Apache, il est conseillé d’activer certains modules non spécifiques à MediaSPIP, mais permettant d’améliorer les performances : mod_deflate et mod_headers pour compresser automatiquement via Apache les pages. Cf ce tutoriel ; mode_expires pour gérer correctement l’expiration des hits. Cf ce tutoriel ;
Il est également conseillé d’ajouter la prise en charge par apache du mime-type pour les fichiers WebM comme indiqué dans ce tutoriel.
Création d’un (...) -
Creating farms of unique websites
13 avril 2011, parMediaSPIP platforms can be installed as a farm, with a single "core" hosted on a dedicated server and used by multiple websites.
This allows (among other things) : implementation costs to be shared between several different projects / individuals rapid deployment of multiple unique sites creation of groups of like-minded sites, making it possible to browse media in a more controlled and selective environment than the major "open" (...)
Sur d’autres sites (6059)
-
What Is Incrementality & Why Is It Important in Marketing ?
26 mars 2024, par ErinImagine this : you just launched your latest campaign and it was a major success.
You blew last month’s results out of the water.
You combined a variety of tactics, channels and ad creatives to make it work.
Now, it’s time to build the next campaign.
The only issue ?
You don’t know what made it successful or how much your recent efforts impacted the results.
You’ve been building your brand for years. You’ve built up a variety of marketing pillars that are working for you. So, how do you know how much of your campaign is from years of effort or a new tactic you just implemented ?
The key is incrementality.
This is a way to properly attribute the right weight to your marketing tactics.
In this article, we break down what incrementality is in marketing, how it differs from traditional attribution and how you can calculate and track it to grow your business.
What is incrementality in marketing ?
Incrementality in marketing is growth that can be directly credited to a marketing effort above and beyond the success of the branding.
It looks at how much a specific tactic positively impacted a campaign on top of overall branding and marketing strategies.
For example, this could be how much a specific tactic, campaign or channel helped increase conversions, email sign-ups or organic traffic.
The primary purpose of incrementally in marketing is to more accurately determine the impact a single marketing variable had on the success of a project.
It removes every other factor and isolates the specific method to help marketers double down on that strategy or move on to new tactics.
With Matomo, you can track conversions simply. With our last non-direct channel attribution system, you’ll be able to quickly see what channels are converting (and which aren’t) so you can gain insights into incrementality.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
How incrementality differs from attribution
In marketing and advertising, it’s crucial to understand what tactics and activities drive growth.
Incrementality and attribution help marketers and business owners understand what efforts impact their results.
But they’re not the same.
Here’s how they differ :
Incrementality explained
Incrementality measures how much a specific marketing campaign or activity drives additional sales or growth.
Simply put, it’s analysing the difference between having never implemented the campaign (or tactic or channel) in the first place versus the impact of the activity.
In other words, how much revenue would you have generated this month without campaign A ?
And how much additional revenue did you generate directly due to campaign A ?
The reality is that dozens of factors impact revenue and growth.
You aren’t just pouring your marketing into one specific channel or campaign at a time.
Chances are, you’ve got your hands on several marketing initiatives like SEO, PPC, organic social media, paid search, email marketing and more.
Beyond that, you’ve built a brand with a not-so-tangible impact on your recurring revenue.
So, the question is, if you took away your new campaign, would you still be generating the same amount of revenue ?
And, if you add in that campaign, how much additional revenue and growth did it directly create ?
That is incrementality. It’s how much a campaign went above and beyond to add new revenue that wouldn’t have been there otherwise.
So, how does attribution play into all of this ?
Attribution explained
Attribution is simply the process of assigning credit for a conversion to a particular marketing touchpoint.
While incrementality is about narrowing down the overall revenue impact from a particular campaign, attribution seeks to point to a specific channel to attribute a sale.
For example, in any given marketing campaign, you have a few marketing tactics.
Let’s say you’re launching a limited-time product.
You might have :
- Paid ads via Facebook and Instagram
- A blog post sharing how the product works
- Organic social media posts on Instagram and TikTok
- Email waitlist campaign building excitement around the upcoming product
- SMS campaigns to share a limited-time discount
So, when the time comes for the sale launch, and you generate $30,000 in revenue, what channel gets the credit ?
Do you give credit to the paid ads on Facebook ? What about Instagram ? They got people to follow you and got them on the email waitlist.
Do you give credit to email for reminding people of the upcoming sale ? What about your social media posts that reminded people there ?
Or do you credit your SMS campaign that shared a limited-time discount ?
Which channel is responsible for the sale ?
This is what attribution is all about.
It’s about giving credit where credit is due.
The reason you want to attribute credit ? So you know what’s working and can double down your efforts on the high-impact marketing activities and channels.
Leveraging incrementality and attribution together
Incrementality and attribution aren’t competing methods of analysing what’s working.
They’re complementary to one another and go hand in hand.
You can (and should) use attribution and incrementality in your marketing to help understand what activities, campaigns and channels are making the biggest incremental impact on your business growth.
Why it’s important to measure incrementality
Incrementality is crucial to measure if you want to pour your time, money and effort into the right marketing channels and tactics.
Here are a few reasons why you need to measure incrementality if you want to be successful with your marketing and grow your business :
1. Accurate data
If you want to be an effective marketer, you need to be accurate.
You can’t blindly start marketing campaigns in hopes that you will sell many products or services.
That’s not how it works.
Sure, you’ll probably make some sales here and there. But to truly be effective with your work, you must measure your activities and channels correctly.
Incrementality helps you see how each channel, tactic or campaign made a difference in your marketing.
Matomo gives you 100% accurate data on your website activities. Unlike Google Analytics, we don’t use data sampling which limits how much data is analysed.
2. Helps you to best determine the right tactics for success
How can you plan your marketing strategy if you don’t know what’s working ?
Think about it.
You’ll be blindly sailing the seas without a compass telling you where to go.
Measuring incrementality in your marketing tactics and channels helps you understand the best tactics.
It shows you what’s moving the needle (and what’s not).
Once you can see the most impactful tactics and channels, you can forge future campaigns that you know will work.
3. Allows you to get the most out of your marketing budget
Since incrementality sheds light on what’s moving your business forward, you can confidently implement your efforts on the right tactics and channels.
Guess what happens when you start doubling down on the most impactful activities ?
You start increasing revenue, decreasing ad spend and getting a higher return on investment.
The result is that you will get more out of your marketing budget.
Not only will you boost revenue, but you’ll also be able to boost profit margins since you’re not wasting money on ineffective tactics.
4. Increase traffic
When you see what’s truly working in your business, you can figure out what channels and tactics you should be working.
Incrementality helps you understand not only what your best revenue tactics are but also what channels and campaigns are bringing in the most traffic.
When you can increase traffic, you can increase your overall marketing impact.
5. Increase revenue
Finally, with increased traffic, the inevitable result is more conversions.
More conversions mean more revenue.
Incrementality gives you a vision of the tactics and channels that are converting the best.
If you can see that your SMS campaigns are driving the best ROI, then you know that you’ll grow your revenue by pouring more into acquiring SMS leads.
By calculating incrementality regularly, you can rest assured that you’re only investing time and money into the most impactful activities in terms of revenue generation.
How to calculate and test incrementality in marketing
Now that you understand how incrementality works and why it’s important to calculate, the question is :
How do you calculate and conduct incrementality tests ?
Given the ever-changing marketing landscape, it’s crucial to understand how to calculate and test incrementally in your business.
If you’re not sure how incrementality testing works, then follow these simple steps :
Your first step to get an incrementality measurement is to conduct what’s referred to as a “holdout test.”
It’s not a robust test, but it’s an easy way to get the ball rolling with incrementality.
Here’s how it works :
- Choose your target audience.
With Matomo’s segmentation feature, you can get pretty specific with your target audience, such as :
- Visitors from the UK
- Returning visitors
- Mobile users
- Visitors who clicked on a specific ad
- Split your audience into two groups :
- Control group (60% of the segment)
- Test group (40% of the segment)
- Target the control group with your marketing tactic (the simpler the tactic, the better).
- Target the test group with a different marketing tactic.
- Analyse the results. The difference between the control and test groups is the incremental lift in results. The new marketing tactic is either more effective or not.
- Repeat the test with a new control group (with an updated tactic) and a new test group (with a new tactic).
Matomo can help you analyse the results of your campaigns in our Goals feature. Set up business objectives so you can easily track different goals like conversions.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Here’s an example of how this incrementality testing could look in real life.
Imagine a fitness retailer wants to start showing Facebook ads in their marketing mix.
The marketing manager decided to conduct a holdout test. If we match our example below with the steps above, this is how the holdout test might look.
- They choose people who’ve purchased free weights in the past as their target audience (see how that segmentation works ?).
- They split this segment into a control group and a test group.
- For this test, they direct their regular marketing campaign to the control group (60% of the segment). The campaign includes promoting a 20% off sale on organic social media posts, email marketing, and SMS.
- They direct their regular marketing campaign plus Facebook ads to the test group (40% of the segment).
- They ran the campaign for three weeks with the goal for sale conversions and noticed :
- The control group had a 1.5% conversion rate.
- The test group (with Facebook ads) had a 2.1% conversion rate.
- In this scenario, they could see the group who saw the Facebook ads convert better.
- They created the following formula to measure the incremental lift of the Facebook ads :
- Here’s how the calculation works out : (2.1% – 1.5%) / 1.5% = 40%
The Facebook ads had a positive 40% incremental lift in conversions during the sale.
Incrementality testing isn’t a one-and-done process, though.
While this first test is a great sign for the marketing manager, it doesn’t mean they should immediately throw all their money into Facebook ads.
They should continue conducting tests to verify the initial test.
Use Matomo to track incrementality today
Incrementality can give you insights into exactly what’s working in your marketing (and what’s not) so you can design proven strategies to grow your business.
If you want more help tracking your marketing efforts, try Matomo today.
Our web analytics and behaviour analytics platform gives you firsthand data on your website visitors you can use to craft effective marketing strategies.
Matomo provides 100% accurate data. Unlike other major web analytics platforms, we don’t do data sampling. What you see is what’s really going on in your website. That way, you can make more informed decisions for better results.
At Matomo, we take privacy very seriously and include several advanced privacy protections to ensure you are in full control.
As a fully compliant web analytics solution, we’re fully compliant with some of the world’s strictest privacy regulations like GDPR. With Matomo, you get peace of mind knowing you can make data-driven decisions while also being compliant.
If you’re ready to launch a data-driven marketing strategy today and grow your business, get started with our 21-day free trial now. No credit card required.
Try Matomo for Free
21 day free trial. No credit card required.
-
CRO Audit : Increase Your Conversions in 10 Simple Steps
25 mars 2024, par ErinYou 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.
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.
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.
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.
-
Display real time frames from several RTSP streams
13 février 2024, par MraxI have this class, it uses ffmpeg library for rtsp live streaming :


#include <iostream>
#include <string>
#include <vector>
#include <mutex>

extern "C"
{
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavformat></libavformat>avio.h>
}

class ryMediaSource
{
public:
 ryMediaSource() {}
 ryMediaSource(const ryMediaSource& other);
 ~ryMediaSource();

 bool ryOpenMediaSource(const std::string&);

private:
 mediaSource pMediaSource;
 AVFormatContext* pFormatCtx;
 mutable std::mutex pMutex;
};
</mutex></vector></string></iostream>

And inside my main file, I have these vector of ryMediaSource and four rstp urls :


std::vector<rymediasource> mediaSources;
std::vector streams =
{
 {"rtsp://1
 {"rtsp://2
 {"rtsp://3
 {"rtsp://4
};
</rymediasource>

Creating a instance for every vector :


for (const auto& stream : streams)
{
 mediaSources.emplace_back(); // Create a new instance for each stream
}


And opening all the streams (I need to have access to all the streams, all the time).


for (size_t s = 0; s < streams.size(); s++)
{
 mediaSources[s].ryOpenMediaSource(streams[s]);
}


After all the streams are loaded, I start to display the videos all of the streams : av_read_frame(pFormatCtx, pPacket).
But I am having a gap from what is been displayed to what is really capturing from the source (IP Cameras).
From ryOpenMediaSource(streams[0]) is about 11 seconds, ryOpenMediaSource(streams[1]) about 7 seconds, ryOpenMediaSource(streams[2]) is about 4 seconds and ryOpenMediaSource(streams[3]) is real time.
I realized that the issue is on my ryOpenMediaSource code :


bool ryMediaSource::ryOpenMediaSource(const std::string& url)
{
 int rc = -1;

 pFormatCtx = avformat_alloc_context();
 if (!pFormatCtx)
 throw std::runtime_error("Failed to allocate AVFormatContext.");
 rc = avformat_open_input(&pFormatCtx, url.c_str(), NULL, NULL);
 if (rc < 0)
 {
 return false;
 }
}


My question is, why this is happening ? Why can't all streams have the same (time stamp ?) , as the last inserted in my vector of ryMediaSource ?


Should I overwrite some variable of pFormatCtx to "force" the all vector to have the (time stamp ?) as the last one ? If so, can you give me some guidance ?


Tried setting some different values on pFormatCtx after loaded with avformat_open_input(&pFormatCtx, url.c_str(), NULL, &pDicts) ; but no luck at all.


I am expecting that all streams started at the same time, even if pre loading them, for later on, transform these frames into a cv::Mat for rendering.


MRE :


Header :

#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <chrono>
#include <thread>
#include <mutex>


extern "C"
{
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavutil></libavutil>pixdesc.h>
#include <libavutil></libavutil>hwcontext.h>
#include <libavutil></libavutil>opt.h>
#include <libavutil></libavutil>avassert.h>
#include <libavutil></libavutil>imgutils.h>
#include <libswscale></libswscale>swscale.h>
#include <libavdevice></libavdevice>avdevice.h>
#include <libavformat></libavformat>avio.h>
#include <libavutil></libavutil>time.h>
}

class ryMediaSource
{
public:
 ryMediaSource() {}
 ryMediaSource(const ryMediaSource& other);
 ~ryMediaSource();

 struct mediaSourceParams
 {
 int sx;
 int sy;
 int lsize;
 double fps;
 unsigned char* frame;
 };

 bool ryOpenMediaSource(const std::string&);
 mediaSourceParams ryGetMediaSourceFrame();
 void ryCloseMediaSource();

private:
 mediaSource pMediaSource;
 AVFormatContext* pFormatCtx;
 AVCodecContext* pCodecCtx;
 AVFrame* pFrame;
 SwsContext* pSwsCtx;
 AVPacket* pPacket;
 int pVideoStream;
 uint8_t* pBuffer;
 AVFrame* pPict;
 double pFPS;
 mutable std::mutex pMutex;
};

C++ source code :

#include "ryMediaSource.hpp"

ryMediaSource::ryMediaSource(const ryMediaSource& other)
:pFormatCtx(nullptr), 
pCodecCtx(nullptr), 
pFrame(nullptr), 
pSwsCtx(nullptr), 
pPacket(nullptr), 
pBuffer(nullptr), 
pPict(nullptr)
{
 std::lock_guard lock(other.pMutex);
 av_log_set_level(0);
 avformat_network_init();
}

bool ryMediaSource::ryOpenMediaSource(const std::string& url)
{
 int rc = -1;

 try
 {
 AVDictionary* pDicts = nullptr;

 pFormatCtx = avformat_alloc_context();
 if (!pFormatCtx)
 throw std::runtime_error("Failed to allocate AVFormatContext.");
 rc = av_dict_set(&pDicts, "rtsp_transport", "tcp", 0);
 if (rc < 0)
 throw std::runtime_error("av_dict_set failed.");
 rc = avformat_open_input(&pFormatCtx, url.c_str(), NULL, &pDicts);
 if (rc < 0)
 {
 av_dict_free(&pDicts); // Free the dictionary in case of an error
 throw std::runtime_error("Could not open source.");
 }
 }
 catch (const std::exception& e)
 {
 std::cerr << "Exception: " << e.what() << std::endl;
 return false;
 }

 try
 {
 rc = avformat_find_stream_info(pFormatCtx, NULL);
 if (rc < 0)
 {
 throw std::runtime_error("Could not find stream information.");
 }
 pVideoStream = -1;
 for (size_t v = 0; v < pFormatCtx->nb_streams; ++v)
 {
 if (pFormatCtx->streams[v]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
 {
 pVideoStream = static_cast<int>(v);
 AVRational rational = pFormatCtx->streams[pVideoStream]->avg_frame_rate;
 pFPS = 1.0 / ((double)rational.num / (double)(rational.den));
 break;
 }
 }
 if (pVideoStream < 0)
 {
 throw std::runtime_error("Could not find video stream.");
 }

 const AVCodec* pCodec = avcodec_find_decoder(pFormatCtx->streams[pVideoStream]->codecpar->codec_id);
 if (!pCodec)
 {
 throw std::runtime_error("Unsupported codec!");
 }
 pCodecCtx = avcodec_alloc_context3(pCodec);
 if (!pCodecCtx)
 {
 throw std::runtime_error("Failed to allocate AVCodecContext.");
 }
 rc = avcodec_parameters_to_context(pCodecCtx, pFormatCtx->streams[pVideoStream]->codecpar);
 if (rc != 0)
 {
 throw std::runtime_error("Could not copy codec context.");
 }
 rc = avcodec_open2(pCodecCtx, pCodec, NULL);
 if (rc < 0)
 {
 throw std::runtime_error("Could not open codec.");
 }
 pFrame = av_frame_alloc();
 if (!pFrame)
 {
 throw std::runtime_error("Could not allocate frame.");
 }
 pSwsCtx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_BGR24, SWS_BILINEAR, NULL, NULL, NULL);
 if (!pSwsCtx)
 {
 throw std::runtime_error("Failed to allocate SwsContext.");
 }
 pPacket = av_packet_alloc();
 if (!pPacket)
 {
 throw std::runtime_error("Could not allocate AVPacket.");
 }
 pBuffer = (uint8_t*)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height, 1));
 if (!pBuffer)
 {
 throw std::runtime_error("Could not allocate buffer.");
 }
 pPict = av_frame_alloc();
 if (!pPict)
 {
 throw std::runtime_error("Could not allocate frame.");
 }
 av_image_fill_arrays(pPict->data, pPict->linesize, pBuffer, AV_PIX_FMT_BGR24, pCodecCtx->width, pCodecCtx->height, 1);
 }
 catch (const std::exception& e)
 {
 std::cerr << "Exception: " << e.what() << std::endl;
 return false;
 }

 return true;
}

ryMediaSource::mediaSourceParams ryMediaSource::ryGetMediaSourceFrame()
{
 mediaSourceParams msp = { 0, 0, 0, 0.0, nullptr };
 char errbuf[AV_ERROR_MAX_STRING_SIZE];

 std::lock_guard lock(pMutex);
 if (av_read_frame(pFormatCtx, pPacket) >= 0)
 {
 if (pPacket->stream_index == pVideoStream)
 {
 int ret = avcodec_send_packet(pCodecCtx, pPacket);
 if (ret < 0)
 {
 av_strerror(ret, errbuf, sizeof(errbuf));
 std::cerr << "Error sending packet for avcodec_send_packet: " << errbuf << std::endl;

 std::cerr << "avcodec_flush_buffers " << errbuf << std::endl;
 avcodec_flush_buffers(pCodecCtx);
 // Handle specific error cases
 if (ret == AVERROR(EAGAIN))
 {
 std::cerr << "EAGAIN indicates that more input is required" << std::endl;
 }
 else if (ret == AVERROR_EOF)
 {
 std::cerr << "AVERROR_EOF indicates that the encoder has been fully flushed" << std::endl;
 }
 else
 {
 //std::cerr << "avcodec_flush_buffers " << errbuf << std::endl;
 // For other errors, you may choose to flush the codec context and continue decoding.
 //avcodec_flush_buffers(pCodecCtx);
 }
 }
 ret = avcodec_receive_frame(pCodecCtx, pFrame);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 {
 av_strerror(ret, errbuf, sizeof(errbuf));

 std::cerr << "Error receiving packet for avcodec_receive_frame: " << errbuf << std::endl;


 // EAGAIN indicates that more frames are needed or EOF is reached.
 // You may choose to break out of the loop or handle it based on your application's logic.

 return msp;
 }
 else if (ret < 0)
 {
 av_strerror(ret, errbuf, sizeof(errbuf));
 std::cerr << "Error receiving frame for avcodec_receive_frame: " << errbuf << std::endl;
 // Optionally, handle specific error cases
 if (ret == AVERROR(EINVAL))
 {
 std::cerr << "EINVAL indicates that more input is required" << std::endl;

 //break;
 }
 else
 {
 std::cerr << "For other errors" << std::endl;

 //break;
 }
 }
 // Move memory allocation outside the loop if frame size is constant
 size_t bufferSize = static_cast(pPict->linesize[0]) * pCodecCtx->height;
 msp.frame = new unsigned char[bufferSize];
 msp.lsize = pPict->linesize[0];
 msp.sx = pCodecCtx->width;
 msp.sy = pCodecCtx->height;
 msp.fps = pFPS;
 sws_scale(pSwsCtx, (uint8_t const* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pPict->data, pPict->linesize);
 std::memcpy(msp.frame, pBuffer, bufferSize);
 //delete[] msp.frame;
 }

 // Unref packet for non-video streams
 av_packet_unref(pPacket);
 }

 return msp;
}

main.cpp

std::vector streams =
{
 {"rtsp://1},
 {"rtsp://2},
 {"rtsp://3},
 {"rtsp://4},
};

std::vector<rymediasource> mediaSources;

void main()
{
 int key = 0;
 int channel = 0;
 std::vector streamFrame(streams.size());
 ryMediaSource::mediaSourceParams msp = { 0, 0, 0, 0.0, nullptr };

 for (const auto& stream : streams)
 {
 mediaSources.emplace_back(); // Create a new instance for each stream
 }
 for (size_t s = 0; s < streams.size(); s++)
 {
 try
 {
 mediaSources[s].ryOpenMediaSource(streams[s]);
 }
 catch (const std::exception& e)
 {
 std::cerr << "Error initializing stream " << s << ": " << e.what() << std::endl;
 }
 }

 cv::namedWindow("ryInferenceServer", cv::WINDOW_FREERATIO);
 cv::resizeWindow("ryInferenceServer", 640, 480);
 cv::moveWindow("ryInferenceServer", 0, 0);
 for (;;)
 {
 for (size_t st = 0; st < mediaSources.size(); ++st)
 {
 msp = mediaSources[st].ryGetMediaSourceFrame();
 if (msp.frame != nullptr)
 {
 cv::Mat preview;
 cv::Mat frame(msp.sy, msp.sx, CV_8UC3, msp.frame, msp.lsize);
 cv::resize(frame, preview, cv::Size(640, 480));
 if (!frame.empty())
 {
 try
 {
 streamFrame[st] = frame.clone();
 if (channel == st)
 {
 cv::imshow("ryInferenceServer", preview);
 key = cv::waitKeyEx(1);
 if (key == LEFT_KEY)
 {
 channel--;
 if (channel < 0)
 channel = 0;
 }
 if (key == RIGHT_KEY)
 {
 channel++;
 if (channel >= mediaSources.size())
 channel = mediaSources.size() - 1;
 }
 if (key == 27)
 break;
 }
 streamFrame[st].release();
 delete[] msp.frame;
 }
 catch (const std::exception& e)
 {
 std::cerr << "Exception in processing frame for stream " << st << ": " << e.what() << std::endl;
 }
 }
 frame.release();
 }
 }
 }
}
</rymediasource></int></mutex></thread></chrono></vector></string></iostream>

Syndiquer tout le site
