Recherche avancée
Autres articles (72)
-
Personnaliser en ajoutant son logo, sa bannière ou son image de fond
5 septembre 2013, parCertains thèmes prennent en compte trois éléments de personnalisation : l’ajout d’un logo ; l’ajout d’une bannière l’ajout d’une image de fond ;
-
MediaSPIP v0.2
21 juin 2013, parMediaSPIP 0.2 est la première version de MediaSPIP stable.
Sa date de sortie officielle est le 21 juin 2013 et est annoncée ici.
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Comme pour la version précédente, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...) -
Ecrire une actualité
21 juin 2013, parPrésentez les changements dans votre MédiaSPIP ou les actualités de vos projets sur votre MédiaSPIP grâce à la rubrique actualités.
Dans le thème par défaut spipeo de MédiaSPIP, les actualités sont affichées en bas de la page principale sous les éditoriaux.
Vous pouvez personnaliser le formulaire de création d’une actualité.
Formulaire de création d’une actualité Dans le cas d’un document de type actualité, les champs proposés par défaut sont : Date de publication ( personnaliser la date de publication ) (...)
Sur d’autres sites (4338)
-
7 Ecommerce Metrics to Track and Improve in 2024
12 avril 2024, par ErinYou can invest hours into market research, create the best ads you’ve ever seen and fine-tune your budgets. But the only way to really know if your digital marketing campaigns move the needle is to track ecommerce metrics.
It’s time to put your hopes and gut feelings aside and focus on the data. Ecommerce metrics are key performance indicators that can tell you a lot about the performance of a single campaign, a traffic source or your entire marketing efforts.
That’s why it’s essential to understand what ecommerce metrics are, key metrics to track and how to improve them.
Ready to do all of the above ? Then, let’s get started.
What are ecommerce metrics ?
An ecommerce metric is any metric that helps you understand the effectiveness of your digital marketing efforts and the extent to which users are taking a desired action. Most ecommerce metrics focus on conversions, which could be anything from making a purchase to subscribing to your email list.
You need to track ecommerce metrics to understand how well your marketing efforts are working. They are essential to helping you run a cost-effective marketing campaign that delivers a return on investment.
For example, tracking ecommerce metrics will help you identify whether your digital marketing campaigns are generating a return on investment or whether they are actually losing money. They also help you identify your most effective campaigns and traffic sources.
Ecommerce metrics also help you spot opportunities for improvement both in terms of your marketing campaigns and your site’s UX.
For instance, you can use ecommerce metrics to track the impact on revenue of A/B tests on your marketing campaigns. Or you can use them to understand how users interact with your website and what, if anything, you can do to make it more engaging.
What’s the difference between conversion rate and conversion value ?
The difference between a conversion rate and a conversion value is that the former is a percentage while the latter is a monetary value.
There can be confusion between the terms conversion rate and conversion value. Since conversions are core metrics in ecommerce, it’s worth taking a minute to clarify.
Conversion rates measure the percentage of people who take a desired action on your website compared to the total number of visitors. If you have 100 visitors and one of them converts, then your conversion rate is 1%.
Here’s the formula for calculating your conversion rate :
Conversion Rate (%) = (Number of conversions / Total number of visitors) × 100
Using the example above :
Conversion Rate = (1 / 100) × 100 = 1%
Conversion value is a monetary amount you assign to each conversion. In some cases, this is the price of the product a user purchases. In other conversion events, such as signing up for a free trial, you may wish to assign a hypothetical conversion value.
To calculate a hypothetical conversion value, let’s consider that you have estimated the average revenue generated from a paying customer is $300. If the conversion rate from free trial to paying customer is 20%, then the hypothetical conversion value for each free trial signup would be $300 multiplied by 20%, which equals $60. This takes into account the number of free trial users who eventually become paying customers.
So the formula for hypothetical conversion value looks like this :
Hypothetical conversion value = (Average revenue per paying customer) × (Conversion rate)
Using the values from our example :
Hypothetical conversion value = $300 × 20% = $60
The most important ecommerce metrics and how to track them
There are dozens of ecommerce metrics you could track, but here are seven of the most important.
Conversion rate
Conversion rate is the percentage of visitors who take a desired action. It is arguably one of the most important ecommerce metrics and a great top-level indicator of the success of your marketing efforts.
You can measure the conversion rate of anything, including newsletter signups, ebook downloads, and product purchases, using the following formula :
Conversion rate = (Number of people who took action / Total number of visitors) × 100
You usually won’t have to manually calculate your conversion rate, though. Almost every web analytics or ad platform will track the conversion rate automatically.
Matomo, for instance, automatically tracks any conversion you set in the Goals report.
As you can see in the screenshot, your site’s conversions are plotted over a period of time and the conversion rate is tracked below the graph. You can change the time period to see how your conversion rate fluctuates.
If you want to go even further, track your new visitor conversion rate to see how engaging your site is to first-time visitors.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Cost per acquisition
Cost per acquisition (CPA) is the average cost of acquiring a new user. You can calculate your overall CPA or you can break CPA down by email campaign, traffic source, or any other criteria.
Calculate CPA by dividing your total marketing cost by the number of new users you acquire.
CPA = Total marketing cost / Number of new users acquired
So if your Google Ads campaign costs €1,000 and you acquire 100 new users, your CPA is €10 (1000/100=10).
It’s important to note that CPA is not the same as customer acquisition cost. Customer acquisition cost considers the number of paying customers. CPA looks at the number of users taking a certain action, like subscribing to a newsletter, making a purchase, or signing up for a free trial.
Cost per acquisition is a direct measure of your marketing efforts’ effectiveness, especially when comparing CPA to average customer spend and return on ad spend.
If your CPA is higher than the average customer spend, your marketing campaign is profitable. If not, then you can look at ways to either increase customer spend or decrease your cost per acquisition.
Customer lifetime value
Customer lifetime value (CLV) is the average amount of money a customer will spend with your ecommerce brand over their lifetime.
Customer value is the total worth of a customer to your brand based on their purchasing behaviour. To calculate it, multiply the average purchase value by the average number of purchases. For instance, if the average purchase value is €50 and customers make 5 purchases on average, the customer value would be €250.
Use this formula to calculate customer value :
Customer value = Average purchase value × Average number of purchases
Then you can calculate customer lifetime value using the following formula :
CLV = Customer value × Average customer lifespan
In another example, let’s say you have a software company and customers pay you €500 per year for an annual subscription. If the average customer lifespan is 5 years, then the Customer Lifetime Value (CLV) would be €2,500.
Customer lifetime value = €500 × 5 = €2,500
Knowing how much potential customers are likely to spend helps you set accurate marketing budgets and optimise the price of your products.
Return on investment
Return on investment (ROI) is the amount of revenue your marketing efforts generate compared to total spend.
It’s usually calculated as a percentage using the following formula :
ROI = (Revenue / Total spend) × 100
If you spend €1,000 on a paid ad campaign and your efforts bring in €5,000, then your ROI is 500% (5,000/1,000 × 100).
With a web analytics tool like Matomo, you can quickly see the revenue generated from each traffic source and you can drill down further to compare different social media channels, search engines, referral websites and campaigns to get more granular view.
In the example above in Matomo’s Marketing Attribution feature, we can see that social networks are generating the highest amount of revenue in the year. To calculate ROI, we would need to compare the amount of investment to each channel.
Let’s say we invested $1,000 per year in search engine optimisation and content marketing, the return on investment (ROI) stands at approximately 2576%, based on a revenue of $26,763.48 per year.
Conversely, for organic social media campaigns, where $5,000 was invested and revenue amounted to $71,180.22 per year, the ROI is approximately 1323%.
Despite differences in revenue generation, both channels exhibit significant returns on investment, with SEO and content marketing demonstrating a much higher ROI compared to organic social media campaigns.
With that in mind, we might want to consider shifting our marketing budget to focus more on search engine optimisation and content marketing as it’s a greater return on investment.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Return on ad spend
Return on ad spend (ROAS) is similar to return on investment, but it measures the profitability of a specific ad or campaign.
Calculate ROAS using the following formula :
ROAS = Revenue / Ad cost
A positive ROAS means you are making money. If you generate €3 for every €1 you spend on advertising, for example, there’s no reason to turn off that campaign. If you only make €1 for every €2 you spend, however, then you need to shut down the campaign or optimise it.
Bounce rate
Bounce rate is the percentage of visitors who leave your site without taking another action. Calculate it using the following formula :
Bounce rate = (Number of visitors who bounce / Total number of visitors) × 100
Some portion of users will always leave your site immediately, but you should aim to make your bounce rate as low as possible. After all, every customer that bounces is a missed opportunity that you may never get again.
You can check the bounce rate for each one of your site’s pages using Matomo’s page analytics report. Web analytics tools like Google Analytics can track bounce rates for online stores also.
Bounce rate is calculated automatically. You can sort the list of pages by bounce rate allowing you to prioritise your optimisation efforts.
Don’t stop there, though. Explore bounce rate further by comparing your mobile bounce rate vs. desktop bounce rate by segmenting your traffic. This will highlight whether your mobile site needs improving.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Click-through rate
Your clickthrough rate (CTR) tells you the number of people who click on your ads as a percentage of total impressions. You can calculate it by dividing the number of clicks your ad gets by the total number of times people see it.
So the formula looks like this :
CTR (%) = (Number of clicks / Total impressions) × 100
If an ad gets 1,000 impressions and 10 people click on it, then the CTR will be 10/1,000 × 100 = 1%
You don’t usually need to calculate your clickthrough rate manually, however. Most ad platforms like Google Ads will automatically calculate CTR.
What is considered a good ecommerce sales conversion rate ?
This question is so broad it’s almost impossible to answer. The thing is, sales conversion rates vary massively depending on the conversion event and the industry. A good conversion rate in one industry might be terrible in another.
That being said, research shows that the average website conversion rate across all industries is 2.35%. Of course, some websites convert much better than this. The same study found that the top 25% of websites across all industries have a conversion rate of 5.31% or higher.
How can you improve your conversion rate ?
Ecommerce metrics don’t just let you track your campaign’s ROI, they help you identify ways to improve your campaign.
Use these five tips to start improving your marketing campaign’s conversion rates today :
Run A/B tests
The most effective way to improve almost all of the ecommerce metrics you track is to test, test, and test again.
A/B testing or multivariate testing compares two different versions of the same content, such as a landing page or blog post. Seeing which version performs better can help you squeeze as many conversions as possible from your website and ad campaigns. But only if you test as many things as possible. This should include :
- Ad placement
- Ad copy
- CTAs
- Headlines
- Straplines
- Colours
- Design
To create and analyse tests and their results effectively, you’ll need either an A/B testing platform or a web analytics solution like Matomo, which offers one out of the box.
Matomo’s A/B Testing feature makes it easy to create and track tests over time, breaking down each test’s variations by the metrics that matter. It automatically calculates statistical significance, too, meaning you can be sure you’re making a change for the better.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
-
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.
-
C - Transcoding to UDP using FFmpeg ?
30 avril 2013, par golmschenkI'm trying to use the FFmpeg libraries to take an existing video file and stream it over a UDP connection. Specifically, I've been looking at the muxing.c and demuxing.c example files in the source code doc/example directory of FFmpeg. The demuxing file presents code which allows an input video to be converted into the video and audio streams. The muxing file presents code which creates fake data and can already be output to a UDP connection as I would like. I've begun work combining the two. Below can be found my code which is basically a copy of the muxing file with some parts replaced/appended with parts of the demuxing file. Unfortunately I'm running into plenty of complications attempting my goal through this approach. Is there an existing source code example which does the transcoding I'm looking for ? Or at least a tutorial on how one might create this ? If not, at least a few pointers might be helpful in directing my work in combing the two files to achieve my goal. Specifically, I'm getting the error :
[NULL @ 0x23b4040] Unable to find a suitable output format for 'udp://localhost:7777'
Could not deduce output format from file extension: using MPEG.
Output #0, mpeg, to 'udp://localhost:7777':Even though the muxing file could accept UDP formats. Any suggestions ? Thank you much !
#include
#include
#include
#include
#include <libavutil></libavutil>mathematics.h>
#include <libavformat></libavformat>avformat.h>
#include <libswscale></libswscale>swscale.h>
/* 5 seconds stream duration */
#define STREAM_DURATION 200.0
#define STREAM_FRAME_RATE 25 /* 25 images/s */
#define STREAM_NB_FRAMES ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
#define STREAM_PIX_FMT AV_PIX_FMT_YUV420P /* default pix_fmt */
//FROM DE
static AVFormatContext *fmt_ctx = NULL;
static AVCodecContext *video_dec_ctx = NULL, *audio_dec_ctx;
static AVStream *video_stream = NULL, *audio_stream = NULL;
static const char *src_filename = NULL;
static const char *video_dst_filename = NULL;
static const char *audio_dst_filename = NULL;
static FILE *video_dst_file = NULL;
static FILE *audio_dst_file = NULL;
static uint8_t *video_dst_data[4] = {NULL};
static int video_dst_linesize[4];
static int video_dst_bufsize;
static uint8_t **audio_dst_data = NULL;
static int audio_dst_linesize;
static int audio_dst_bufsize;
static int video_stream_idx = -1, audio_stream_idx = -1;
static AVFrame *frame = NULL;
static AVPacket pkt;
static int video_frame_count = 0;
static int audio_frame_count = 0;
//END DE
static int sws_flags = SWS_BICUBIC;
/**************************************************************/
/* audio output */
static float t, tincr, tincr2;
static int16_t *samples;
static int audio_input_frame_size;
/* Add an output stream. */
static AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
enum AVCodecID codec_id)
{
AVCodecContext *c;
AVStream *st;
/* find the encoder */
*codec = avcodec_find_encoder(codec_id);
if (!(*codec)) {
fprintf(stderr, "Could not find encoder for '%s'\n",
avcodec_get_name(codec_id));
exit(1);
}
st = avformat_new_stream(oc, *codec);
if (!st) {
fprintf(stderr, "Could not allocate stream\n");
exit(1);
}
st->id = oc->nb_streams-1;
c = st->codec;
switch ((*codec)->type) {
case AVMEDIA_TYPE_AUDIO:
st->id = 1;
c->sample_fmt = AV_SAMPLE_FMT_S16;
c->bit_rate = 64000;
c->sample_rate = 44100;
c->channels = 2;
break;
case AVMEDIA_TYPE_VIDEO:
c->codec_id = codec_id;
c->bit_rate = 400000;
/* Resolution must be a multiple of two. */
c->width = 352;
c->height = 288;
/* timebase: This is the fundamental unit of time (in seconds) in terms
* of which frame timestamps are represented. For fixed-fps content,
* timebase should be 1/framerate and timestamp increments should be
* identical to 1. */
c->time_base.den = STREAM_FRAME_RATE;
c->time_base.num = 1;
c->gop_size = 12; /* emit one intra frame every twelve frames at most */
c->pix_fmt = STREAM_PIX_FMT;
if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
/* just for testing, we also add B frames */
c->max_b_frames = 2;
}
if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
/* Needed to avoid using macroblocks in which some coeffs overflow.
* This does not happen with normal video, it just happens here as
* the motion of the chroma plane does not match the luma plane. */
c->mb_decision = 2;
}
break;
default:
break;
}
/* Some formats want stream headers to be separate. */
if (oc->oformat->flags & AVFMT_GLOBALHEADER)
c->flags |= CODEC_FLAG_GLOBAL_HEADER;
return st;
}
/**************************************************************/
/* audio output */
static float t, tincr, tincr2;
static int16_t *samples;
static int audio_input_frame_size;
static void open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st)
{
AVCodecContext *c;
int ret;
c = st->codec;
/* open it */
ret = avcodec_open2(c, codec, NULL);
if (ret < 0) {
fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
exit(1);
}
/* init signal generator */
t = 0;
tincr = 2 * M_PI * 110.0 / c->sample_rate;
/* increment frequency by 110 Hz per second */
tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
if (c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)
audio_input_frame_size = 10000;
else
audio_input_frame_size = c->frame_size;
samples = av_malloc(audio_input_frame_size *
av_get_bytes_per_sample(c->sample_fmt) *
c->channels);
if (!samples) {
fprintf(stderr, "Could not allocate audio samples buffer\n");
exit(1);
}
}
/* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
* 'nb_channels' channels. */
static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
{
int j, i, v;
int16_t *q;
q = samples;
for (j = 0; j < frame_size; j++) {
v = (int)(sin(t) * 10000);
for (i = 0; i < nb_channels; i++)
*q++ = v;
t += tincr;
tincr += tincr2;
}
}
static void write_audio_frame(AVFormatContext *oc, AVStream *st)
{
AVCodecContext *c;
AVPacket pkt = { 0 }; // data and size must be 0;
AVFrame *frame = avcodec_alloc_frame();
int got_packet, ret;
av_init_packet(&pkt);
c = st->codec;
get_audio_frame(samples, audio_input_frame_size, c->channels);
frame->nb_samples = audio_input_frame_size;
avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
(uint8_t *)samples,
audio_input_frame_size *
av_get_bytes_per_sample(c->sample_fmt) *
c->channels, 1);
ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
if (ret < 0) {
fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
exit(1);
}
if (!got_packet)
return;
pkt.stream_index = st->index;
/* Write the compressed frame to the media file. */
ret = av_interleaved_write_frame(oc, &pkt);
if (ret != 0) {
fprintf(stderr, "Error while writing audio frame: %s\n",
av_err2str(ret));
exit(1);
}
avcodec_free_frame(&frame);
}
static void close_audio(AVFormatContext *oc, AVStream *st)
{
avcodec_close(st->codec);
av_free(samples);
}
/**************************************************************/
/* video output */
static AVFrame *frame;
static AVPicture src_picture, dst_picture;
static int frame_count;
static void open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
{
int ret;
AVCodecContext *c = st->codec;
/* open the codec */
ret = avcodec_open2(c, codec, NULL);
if (ret < 0) {
fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
exit(1);
}
/* allocate and init a re-usable frame */
frame = avcodec_alloc_frame();
if (!frame) {
fprintf(stderr, "Could not allocate video frame\n");
exit(1);
}
/* Allocate the encoded raw picture. */
ret = avpicture_alloc(&dst_picture, c->pix_fmt, c->width, c->height);
if (ret < 0) {
fprintf(stderr, "Could not allocate picture: %s\n", av_err2str(ret));
exit(1);
}
/* If the output format is not YUV420P, then a temporary YUV420P
* picture is needed too. It is then converted to the required
* output format. */
if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
ret = avpicture_alloc(&src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
if (ret < 0) {
fprintf(stderr, "Could not allocate temporary picture: %s\n",
av_err2str(ret));
exit(1);
}
}
/* copy data and linesize picture pointers to frame */
*((AVPicture *)frame) = dst_picture;
}
/* Prepare a dummy image. */
static void fill_yuv_image(AVPicture *pict, int frame_index,
int width, int height)
{
int x, y, i;
i = frame_index;
/* Y */
for (y = 0; y < height; y++)
for (x = 0; x < width; x++)
pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
/* Cb and Cr */
for (y = 0; y < height / 2; y++) {
for (x = 0; x < width / 2; x++) {
pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
}
}
}
static void write_video_frame(AVFormatContext *oc, AVStream *st)
{
int ret;
static struct SwsContext *sws_ctx;
AVCodecContext *c = st->codec;
if (frame_count >= STREAM_NB_FRAMES) {
/* No more frames to compress. The codec has a latency of a few
* frames if using B-frames, so we get the last frames by
* passing the same picture again. */
} else {
if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
/* as we only generate a YUV420P picture, we must convert it
* to the codec pixel format if needed */
if (!sws_ctx) {
sws_ctx = sws_getContext(c->width, c->height, AV_PIX_FMT_YUV420P,
c->width, c->height, c->pix_fmt,
sws_flags, NULL, NULL, NULL);
if (!sws_ctx) {
fprintf(stderr,
"Could not initialize the conversion context\n");
exit(1);
}
}
fill_yuv_image(&src_picture, frame_count, c->width, c->height);
sws_scale(sws_ctx,
(const uint8_t * const *)src_picture.data, src_picture.linesize,
0, c->height, dst_picture.data, dst_picture.linesize);
} else {
fill_yuv_image(&dst_picture, frame_count, c->width, c->height);
}
}
if (oc->oformat->flags & AVFMT_RAWPICTURE) {
/* Raw video case - directly store the picture in the packet */
AVPacket pkt;
av_init_packet(&pkt);
pkt.flags |= AV_PKT_FLAG_KEY;
pkt.stream_index = st->index;
pkt.data = dst_picture.data[0];
pkt.size = sizeof(AVPicture);
ret = av_interleaved_write_frame(oc, &pkt);
} else {
AVPacket pkt = { 0 };
int got_packet;
av_init_packet(&pkt);
/* encode the image */
ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
if (ret < 0) {
fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
exit(1);
}
/* If size is zero, it means the image was buffered. */
if (!ret && got_packet && pkt.size) {
pkt.stream_index = st->index;
/* Write the compressed frame to the media file. */
ret = av_interleaved_write_frame(oc, &pkt);
} else {
ret = 0;
}
}
if (ret != 0) {
fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
exit(1);
}
frame_count++;
}
static void close_video(AVFormatContext *oc, AVStream *st)
{
avcodec_close(st->codec);
av_free(src_picture.data[0]);
av_free(dst_picture.data[0]);
av_free(frame);
}
static int open_codec_context(int *stream_idx,
AVFormatContext *fmt_ctx, enum AVMediaType type)
{
int ret;
AVStream *st;
AVCodecContext *dec_ctx = NULL;
AVCodec *dec = NULL;
ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0);
if (ret < 0) {
fprintf(stderr, "Could not find %s stream in input file '%s'\n",
av_get_media_type_string(type), src_filename);
return ret;
} else {
*stream_idx = ret;
st = fmt_ctx->streams[*stream_idx];
/* find decoder for the stream */
dec_ctx = st->codec;
dec = avcodec_find_decoder(dec_ctx->codec_id);
if (!dec) {
fprintf(stderr, "Failed to find %s codec\n",
av_get_media_type_string(type));
return ret;
}
if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {
fprintf(stderr, "Failed to open %s codec\n",
av_get_media_type_string(type));
return ret;
}
}
return 0;
}
/**************************************************************/
/* media file output */
int main(int argc, char **argv)
{
const char *filename;
AVOutputFormat *fmt;
AVFormatContext *oc;
AVStream *audio_st, *video_st;
AVCodec *audio_codec, *video_codec;
double audio_pts, video_pts;
int ret = 0, got_frame;;
/* Initialize libavcodec, and register all codecs and formats. */
av_register_all();
if (argc != 3) {
printf("usage: %s input_file output_file\n"
"\n", argv[0]);
return 1;
}
src_filename = argv[1];
filename = argv[2];
/* allocate the output media context */
avformat_alloc_output_context2(&oc, NULL, NULL, filename);
if (!oc) {
printf("Could not deduce output format from file extension: using MPEG.\n");
avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
}
if (!oc) {
return 1;
}
fmt = oc->oformat;
/* Add the audio and video streams using the default format codecs
* and initialize the codecs. */
video_stream = NULL;
audio_stream = NULL;
//FROM DE
/* open input file, and allocate format context */
if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) {
fprintf(stderr, "Could not open source file %s\n", src_filename);
exit(1);
}
/* retrieve stream information */
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
fprintf(stderr, "Could not find stream information\n");
exit(1);
}
if (open_codec_context(&video_stream_idx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) {
video_stream = fmt_ctx->streams[video_stream_idx];
video_dec_ctx = video_stream->codec;
/* allocate image where the decoded image will be put */
ret = av_image_alloc(video_dst_data, video_dst_linesize,
video_dec_ctx->width, video_dec_ctx->height,
video_dec_ctx->pix_fmt, 1);
if (ret < 0) {
fprintf(stderr, "Could not allocate raw video buffer\n");
goto end;
}
video_dst_bufsize = ret;
}
if (open_codec_context(&audio_stream_idx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) {
int nb_planes;
audio_stream = fmt_ctx->streams[audio_stream_idx];
audio_dec_ctx = audio_stream->codec;
nb_planes = av_sample_fmt_is_planar(audio_dec_ctx->sample_fmt) ?
audio_dec_ctx->channels : 1;
audio_dst_data = av_mallocz(sizeof(uint8_t *) * nb_planes);
if (!audio_dst_data) {
fprintf(stderr, "Could not allocate audio data buffers\n");
ret = AVERROR(ENOMEM);
goto end;
}
}
//END DE
/* Now that all the parameters are set, we can open the audio and
* video codecs and allocate the necessary encode buffers. */
if (video_stream)
open_video(oc, video_codec, video_stream);
if (audio_stream)
open_audio(oc, audio_codec, audio_stream);
av_dump_format(oc, 0, filename, 1);
/* open the output file, if needed */
if (!(fmt->flags & AVFMT_NOFILE)) {
ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
if (ret < 0) {
fprintf(stderr, "Could not open '%s': %s\n", filename,
av_err2str(ret));
return 1;
}
}
/* Write the stream header, if any. */
ret = avformat_write_header(oc, NULL);
if (ret < 0) {
fprintf(stderr, "Error occurred when opening output file: %s\n",
av_err2str(ret));
return 1;
}
if (frame)
frame->pts = 0;
for (;;) {
/* Compute current audio and video time. */
if (audio_stream)
audio_pts = (double)audio_stream->pts.val * audio_stream->time_base.num / audio_stream->time_base.den;
else
audio_pts = 0.0;
if (video_stream)
video_pts = (double)video_stream->pts.val * video_stream->time_base.num /
video_stream->time_base.den;
else
video_pts = 0.0;
if ((!audio_stream || audio_pts >= STREAM_DURATION) &&
(!video_stream || video_pts >= STREAM_DURATION))
break;
/* write interleaved audio and video frames */
if (!video_stream || (video_stream && audio_st && audio_pts < video_pts)) {
write_audio_frame(oc, audio_stream);
} else {
write_video_frame(oc, video_stream);
frame->pts += av_rescale_q(1, video_stream->codec->time_base, video_stream->time_base);
}
}
/* Write the trailer, if any. The trailer must be written before you
* close the CodecContexts open when you wrote the header; otherwise
* av_write_trailer() may try to use memory that was freed on
* av_codec_close(). */
av_write_trailer(oc);
/* Close each codec. */
if (video_st)
close_video(oc, video_st);
if (audio_st)
close_audio(oc, audio_st);
if (!(fmt->flags & AVFMT_NOFILE))
/* Close the output file. */
avio_close(oc->pb);
/* free the stream */
avformat_free_context(oc);
end:
if (video_dec_ctx)
avcodec_close(video_dec_ctx);
if (audio_dec_ctx)
avcodec_close(audio_dec_ctx);
avformat_close_input(&fmt_ctx);
if (video_dst_file)
fclose(video_dst_file);
if (audio_dst_file)
fclose(audio_dst_file);
av_free(frame);
av_free(video_dst_data[0]);
av_free(audio_dst_data);
return 0;
}
Syndiquer tout le site
