Recherche avancée
Autres articles (29)
-
Publier sur MédiaSpip
13 juin 2013Puis-je poster des contenus à partir d’une tablette Ipad ?
Oui, si votre Médiaspip installé est à la version 0.2 ou supérieure. Contacter au besoin l’administrateur de votre MédiaSpip pour le savoir -
La sauvegarde automatique de canaux SPIP
1er avril 2010, parDans le cadre de la mise en place d’une plateforme ouverte, il est important pour les hébergeurs de pouvoir disposer de sauvegardes assez régulières pour parer à tout problème éventuel.
Pour réaliser cette tâche on se base sur deux plugins SPIP : Saveauto qui permet une sauvegarde régulière de la base de donnée sous la forme d’un dump mysql (utilisable dans phpmyadmin) mes_fichiers_2 qui permet de réaliser une archive au format zip des données importantes du site (les documents, les éléments (...) -
Encoding and processing into web-friendly formats
13 avril 2011, parMediaSPIP automatically converts uploaded files to internet-compatible formats.
Video files are encoded in MP4, Ogv and WebM (supported by HTML5) and MP4 (supported by Flash).
Audio files are encoded in MP3 and Ogg (supported by HTML5) and MP3 (supported by Flash).
Where possible, text is analyzed in order to retrieve the data needed for search engine detection, and then exported as a series of image files.
All uploaded files are stored online in their original format, so you can (...)
Sur d’autres sites (6600)
-
Top 4 CRO Tools to Boost Your Conversion Rates in 2024
31 octobre 2023, par ErinAre you tired of watching potential customers leave your website without converting ? You’ve spent countless hours creating an engaging website, but those high bounce rates keep haunting you.
The good news ? The solution lies in the transformative power of Conversion Rate Optimisation (CRO) tools. In this guide, we’ll dive deep into the world of CRO tools. We will equip you with strategies to turn those bounces into conversions.
Why are conversion rate optimisation tools so crucial ?
CRO tools can be assets in digital marketing, playing a pivotal role in enhancing online businesses’ performance. CRO tools empower businesses to improve website conversion rates by analysing user behaviour. You can then leverage this user data to optimise web elements.
Improving website conversion rates is paramount because it increases revenue and customer satisfaction. A study by VentureBeat revealed an average return on investment (ROI) of 223% thanks to CRO tools.
173 marketers out of the surveyed group reported returns exceeding 1,000%. Both of these data points highlight the impact CRO tools can have.
Coupled with CRO tools, certain testing tools and web analytics tools play a crucial role. They offer insight into user behaviour patterns, enabling businesses to choose effective strategies. By understanding what resonates with users, these tools help inform data-driven decisions. This allows businesses to refine online strategies and enhance the customer experience.
CRO tools enhance user experiences and ensure business sustainability. Integrating these tools is crucial for staying ahead. CRO and web analytics work together to optimise digital presence.
Real-world examples of CRO tools in action
In this section, we’ll explore real case studies showcasing CRO tools in action. See how businesses enhance conversion rates, user experiences, and online performance. These studies reveal the practical impact of data-driven decisions and user-focused strategies.
Case study : How Matomo’s Form Analytics helped Concrete CMS 3x leads
Concrete CMS, is a content management system provider that helps users build and manage websites. They used Matomo’s Form Analytics to uncover that users were getting stuck at the address input stage of the onboarding process. Using these insights to make adjustments to their onboarding form, Concrete CMS was able to achieve 3 times the amount of leads in just a few days.
Read the full Concrete CMS case study.
Best analytics tools for enhancing conversion rate optimisation in 2023
Jump to the comparison table to see an overview of each tool.
1. Matomo
Matomo stands out as an all-encompassing tool that seamlessly combines traditional web analytics features (like pageviews and bounce rates) with advanced behavioural analytics capabilities, providing a full spectrum of insights for effective CRO.
Key features
- Heatmaps and Session Recordings :
These features empower businesses to see their websites through the eyes of their visitors. By visually mapping user engagement and observing individual sessions, businesses can make informed decisions, enhance user experience and ultimately increase conversions. These tools are invaluable assets for businesses aiming to create user-friendly websites.
- Form Analytics :
Matomo’s Form Analytics offers comprehensive tracking of user interactions within forms. This includes covering input fields, dropdowns, buttons and submissions. Businesses can create custom conversion funnels and pinpoint form abandonment reasons.
- Users Flow :
Matomo’s Users Flow feature tracks visitor paths, drop-offs and successful routes, helping businesses optimise their websites. This insight informs decisions, enhances user experience, and boosts conversion rates.
- Surveys plugin :
The Matomo Surveys plugin allows businesses to gather direct feedback from users. This feature enhances understanding by capturing user opinions, adding another layer to the analytical depth Matomo offers.
- A/B testing :
The platform allows you to conduct A/B tests to compare different versions of web pages. This helps determine which performs better in conversions. By conducting experiments and analysing the results within Matomo, businesses can iteratively refine their content and design elements.
- Funnels :
Matomo’s Funnels feature empower businesses to visualise, analyse and optimise their conversion paths. By identifying drop-off points, tailoring user experiences and conducting A/B tests within the funnel, businesses can make data-driven decisions that significantly boost conversions and enhance the overall user journey on their websites.
Pros
- Starting at $19 per month, Matomo is an affordable CRO solution.
- Matomo guarantees accurate data, eliminating the need to fill gaps with artificial intelligence (AI) or machine learning.
- Matomo’s open-source framework ensures enhanced security, privacy, customisation, community support and long-term reliability.
Cons
- The On-Premise (self-hosted) version is free, with additional charges for advanced features.
- Managing Matomo On-Premise requires servers and technical know-how.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
2. Google Analytics
Google Analytics provides businesses and website owners valuable insights into their online audience. It tracks website traffic, user interactions and analyses conversion data to enhance the user experience.
While Google Analytics may not provide the extensive CRO-specific features found in other tools on this list, it can still serve as a valuable resource for basic analysis and optimisation of conversion rates.
Key features
- Comprehensive Data Tracking :
Google Analytics meticulously tracks website traffic, user behaviour and conversion rates. These insights form the foundation for CRO efforts. Businesses can identify patterns, user bottlenecks and high-performing areas.
- Real-Time Reporting :
Access to real-time data is invaluable for CRO efforts. Monitor current website activity, user interactions, and campaign performance as they unfold. This immediate feedback empowers businesses to make instant adjustments, optimising web elements and content for maximum conversions.
- User flow analysis
Visualise and understand how visitors navigate through your website. It provides insights into the paths users take as they move from one page to another, helping you identify the most common routes and potential drop-off points in the user journey.
- Event-based tracking :
GA4’s event-based reporting offers greater flexibility and accuracy in data collection. By tracking various interactions, including video views and checkout processes, businesses can gather more precise insights into user behaviour.
- Funnels :
GA4 offers multistep funnels, path analysis, custom metrics that integrate with audience segments. These user behaviour insights help businesses to tailor their websites, marketing campaigns and user experiences.
Pros
- Flexible audience management across products, regions or brands allow businesses to analyse data from multiple source properties.
- Google Analytics integrates with other Google services and third-party platforms. This enables a comprehensive view of online activities.
- Free to use, although enterprises may need to switch to the paid version to accommodate higher data volumes.
Cons
- Google Analytics raises privacy concerns, primarily due to its tracking capabilities and the extensive data it collects.
- Limitations imposed by thresholding can significantly hinder efforts to enhance user experience and boost conversions effectively.
- Property and sampling limits exist. This creates problems when you’re dealing with extensive datasets or high-traffic websites.
- The interface is difficult to navigate and configure, resulting in a steep learning curve.
3. Contentsquare
Contentsquare is a web analytics and CRO platform. It stands out for its in-depth behavioural analytics. Contentsquare offers detailed data on how users interact with websites and mobile applications.
Key features
- Heatmaps and Session Replays :
Users can visualise website interactions through heatmaps, highlighting popular areas and drop-offs. Session replay features enable the playback of user sessions. These provide in-depth insights into individual user experiences.
- Conversion Funnel Analysis :
Contentsquare tracks users through conversion funnels, identifying where users drop off during conversion. This helps in optimising the user journey and increasing conversion rates.
- Segmentation and Personalisation :
Businesses can segment their audience based on various criteria. Segments help create personalised experiences, tailoring content and offers to specific user groups.
- Integration Capabilities :
Contentsquare integrates with various third-party tools and platforms, enhancing its functionality and allowing businesses to leverage their existing tech stack.
Pros
- Comprehensive support and resources.
- User-friendly interface.
- Personalisation capabilities.
Cons
- High price point.
- Steep learning curve.
4. Hotjar
Hotjar is a robust tool designed to unravel user behaviour intricacies. With its array of features including visual heatmaps, session recordings and surveys, it goes beyond just identifying popular areas and drop-offs.
Hotjar provides direct feedback and offers an intuitive interface, enabling seamless experience optimisation.
Key features
- Heatmaps :
Hotjar provides visual heatmaps that display user interactions on your website. Heatmaps show where users click, scroll, and how far they read. This feature helps identify popular areas and points of abandonment.
- Session Recordings :
Hotjar allows you to record user sessions and watch real interactions on your site. This insight is invaluable for understanding user behaviour and identifying usability issues.
- Surveys and Feedback :
Hotjar offers on-site surveys and feedback forms that can get triggered based on user behaviour. These tools help collect qualitative data from real users, providing valuable insights.
- Recruitment Tool :
Hotjar’s recruitment tool lets you recruit participants from your website for user testing. This feature streamlines the process of finding participants for usability studies.
- Funnel and Form Analysis :
Hotjar enables the tracking of user journeys through funnels. It provides insights into where users drop off during the conversion process. It also offers form analysis to optimise form completion rates.
- User Polls :
You can create customisable polls to engage with visitors. Gather specific feedback on your website, products, or services.
Pros
- Starting at $32 per month, Hotjar is a cost-effective solution for most businesses.
- Hotjar provides a user-friendly interface that is easy for the majority of users to pick up quickly.
Cons
- Does not provide traditional web analytics and requires combining with another tool, potentially creating a less streamlined and cohesive user experience, which can complicate conversion rate optimization efforts.
- Hotjar’s limited integrations can hinder its ability to seamlessly work with other essential tools and platforms, potentially further complicating CRO.
Comparison Table
Please note : We aim to keep this table accurate and up to date. However, if you see any inaccuracies or outdated information, please email us at marketing@matomo.org
To make comparing these tools even easier, we’ve put together a table for you to compare features and price points :
Conclusion
CRO tools and web analytics are essential for online success. Businesses thrive by investing wisely, understanding user behaviour and using targeted strategies. The key : generate traffic and convert it into leads and customers. The right tools and strategies lead to remarkable conversions and online success. Each click, each interaction, becomes an opportunity to create an engaging user journey. This careful orchestration of data and insight separates thriving businesses from the rest.
Are you ready to embark on a journey toward improved conversions and enhanced user experiences ? Matomo offers analytics solutions meticulously designed to complement your CRO strategy. Take the next step in your CRO journey. Start your 21-day free trial today—no credit card required.
Try Matomo for Free
21 day free trial. No credit card required.
- Heatmaps and Session Recordings :
-
5-Step Conversion Rate Optimisation Checklist
27 octobre 2023, par ErinDid you know the average conversion rate across e-commerce businesses in August 2023 was 2.03% ? In the past year, conversion rates have increased by 0.39%.
Make no mistake. Just because conversion rates are higher this year doesn’t make it any easier to convert visitors.
Cracking the secrets to improving conversion rates is crucial to running a successful website or business.
Your site is the digital headquarters all of your marketing efforts funnel toward. With every visitor comes an opportunity to convert them into a lead (or sale).
Keep reading if you want to improve your lead generation or convert more visitors into customers. In this article, we’ll break down a simple five-step conversion rate optimisation checklist you need to follow to maximise your conversions.
What is conversion rate optimisation ?
Before we dive into the steps you need to follow to optimise your conversions, let’s back up and talk conversion rate optimisation.
Conversion rate optimisation, or CRO for short, is the process of increasing the number of website visitors who take a specific action.
In most cases, this means :
- Turning more visitors into leads by getting them to join an email list
- Convincing a visitor to fill out a contact form for a consultation
- Converting a visitor into a paying customer by purchasing a product
However, conversion rate optimisation can be used for any action you want someone to take on your site. That could be downloading a free guide, clicking on a specific link, commenting on a blog post or sharing your website with a friend.
Why following a CRO checklist is important
Conversion rate optimisation is both a valuable practice and an absolute necessity for any business or marketer. While it can be a bit complex, especially when you start diving into A/B testing, there are a variety of advantages :
Get the most out of your efforts
When all is said and done, if you can’t convert the traffic already coming to your site, dumping a ton of time and resources into traffic generation (whether paid or organic) won’t solve your problem.
Instead, you need to look at the root of the problem : your conversion rate.
By doubling down on conversions and following a conversion rate optimisation checklist, you’ll get the greatest result for the effort you’re already putting into your site.
Increase audience size
To increase your audience size, you need to increase your traffic, right ? Not exactly.
While your audience may be considered people who have seen your content or follow you on social media, a high-value audience is one you can market to directly on an ongoing basis.
Your website gives you the playground to convert visitors into high-value audience members. This is done by creating conversion-focused email signup forms and optimising your website for sale conversions.
Generate more sales
Boosting sales through CRO is the core objective. By optimising product pages, simplifying the checkout process, and employing persuasive strategies, you can systematically increase your sales and maximise the value of your existing traffic.
Reduce customer acquisition costs (CAC)
With conversion optimisation, you can convert a higher percentage of your website visitors into paid customers. Even if you don’t spend more on acquiring new customers, you’ll be able to generate more sales overall.
The result is that your customer acquisition costs will drop, allowing you to increase your total acquisitions to your customer base.
Improve profitability
While reduced customer acquisition costs mean you can pour more money into customer acquisition at a cheaper rate, you could simply maintain your costs while driving sales, resulting in increased profitability.
If you can spend the same amount on acquisition but bring in 20% more customers (due to using a CRO checklist), your profit margins will automatically increase.
5-step CRO checklist
To double down on conversion rate optimisation, you need to follow a checklist to ensure you don’t miss any major optimisation opportunities.
The checklist below is designed to help you systematically optimise your website, ensuring you make the most of your traffic by continuously refining its performance.
1. Forms
Analysing and optimising your website’s forms is crucial for enhancing conversion rates. Understanding how visitors interact with your forms can uncover pain points and help you streamline the conversion process.
Ever wonder where your visitors drop off on your forms ? It could be due to lengthy, time-consuming fields or overly complex forms, leading to a frustrating user experience and lower conversion rate. Whatever the reason, you need the right tools to uncover the root of the issue.
By leveraging Form Analytics, you gain powerful insights into user behaviour and can identify areas where people may encounter difficulties.
Form Analytics provides the insights to discover :
- Average time spent on each field : This metric helps you understand where users may be struggling or spending too much time. By optimising these fields, you can streamline the form, reduce user frustration and increase conversions.
- Identifying drop-off points : Understanding where users drop off provides insights into which form fields may need improvement. Addressing these drop-off points can increase the conversion rate.
- Unneeded fields with a high blank submission rate : Discovering fields left blank upon submission can highlight areas for simplification. By eliminating unnecessary fields, you can create more concise and user-friendly forms that may entice more visitors to engage with the form.
Hear first-hand how Concrete CMS achieve 3x more leads with insights from Form Analytics.
These data-driven insights empower you to optimise your forms, remove guesswork and settle debates about form design. By fine-tuning and streamlining your forms, you can ensure a smoother path to conversion and maximise your success in converting more visitors.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
2. Copywriting
Another crucial element you need to test is your copywriting. Your copywriting is the foundation of your entire website. It helps communicate to your audience what you have to offer and why they need to take action.
You need to ensure you have a good offer. This isn’t just the product or service you’re putting out there. It’s the complete package. It includes the product, rewards, a unique guarantee, customer service, packaging and promotions.
Start testing your copy with your headlines. Look at the headers and test different phrases to convert more potential customers into paying customers.
Here are a few tips to optimise your copy for more conversions :
- Ensure copy is relevant to your headline and vice versa.
- Write short words, short sentences and short paragraphs.
- Use bullets and subheaders to make the copy easy to skim.
- Don’t focus too heavily on optimising for search engines (SEO). Instead, write for humans.
- Focus on writing about benefits, not features.
- Write about how your offer solves the pain points of your audience.
You can test your copy in several areas once you’ve begun testing your headers – your subheaders, body copy, signup forms and product pages (if you’re e-commerce).
3. Media : videos and audio
Next, testing out different media types is crucial. This means incorporating videos and audio into your content.
Don’t just take a random guess by throwing stuff against the wall, hoping it sticks. Instead, you should use data to develop impactful content.
Look at your Media Analytics reports in your website analytics solution and see what media people spend the most time on. See what kind of video or audio content already impacts conversions.
Humans are highly visual. You should craft your content so it’s easy to digest. Instead of covering your website in huge chunks of text, split up your copy with engaging content like videos.
High-quality videos and audio recordings allow your readers to consume more of your content easily, and help persuade them to take action on your site.
4. Calls to action (CTA)
This brings us to our next point : your call to action (CTA).
Are you trying to convert more prospects into leads ? Want to turn more leads into customers ? Trying to get more email subscribers ? Or do you want to generate more sales every month ?
You could write the most compelling offer flooded with beautiful images, videos and CRO tactics. But your efforts will go to waste if you don’t include a compelling CTA.
Here are a few tips to optimise your CTAs :
- Keep them congruent on a single web page (e.g., don’t sell a hat and a sweater on the same page, as it can be confusing).
- Place at least one CTA above the fold on your web pages.
- Include benefits in your CTA. Rather than “Buy Now,” try “Buy Now to Get 30% Off.”
- It’s better to be clear and concise than too fancy and unique.
Optimising your call to action isn’t just about your copywriting. It’s also about design. Test different fonts, sizes, and visual elements like borders, icons and background colours.
5. Web design
Your site design will impact how well your visitors convert. You could have incredible copywriting, but if your site is laid out poorly, it will drive people away.
You must ensure your copy and visual content fit your website design well.
The first place you need to start with your site is your homepage design.
Your site design consists of the theme or template, colour scheme and other visual elements that can be optimised to improve conversions.
Here are a few tips to keep in mind when optimising your website design :
- Use a colour scheme that’s pleasant rather than too distracting or extreme.
- Ensure your design doesn’t remove the text’s clarity but makes it easier to read.
- When in doubt, start with black text on a white background (the opposite rarely works).
- Keep plenty of whitespace in between design elements.
- When in doubt about font size, start by testing a larger size.
- Design mobile-first rather than desktop-first.
Finally, it’s critical to ensure your website is easy to navigate. Good design is all about the user experience. Is it easy to find what they’re looking for ? Simplify steps to reduce the need to click, and your conversions will increase.
Start optimising your website for conversions
If you’re looking to get the most out of the traffic on your site by converting more visitors into leads or customers, following this 5-step CRO checklist will help you take steps in the right direction.
Just remember conversion rate optimisation is an ongoing process. It’s not a one-time deal. To succeed, you need to test quickly, analyse the impact and do more of what’s working and less of what’s not.
To optimise your website for better conversion rates, you need the right tools that provide accurate data and insights to effectively increase conversions. With Matomo, you gain access to web analytics and CRO features like Form Analytics and Media Analytics, designed to enhance your conversion rate optimisation efforts.
Try Matomo free for 21 days and take your conversion rate to the next level. No credit card required.
Try Matomo for Free
21 day free trial. No credit card required.
-
Read existing MP4 File and write into a new MP4 file using libavcodec
4 octobre 2023, par TahfimulI am new to the libavcodec space.


I am trying to read video and audio streams from an existing mp4 file and take the data from the two streams and then mux the two streams and write the muxed data into a new mp4 file using libavcodec in C++. Essentially, I am aiming to split the original (existing) mp4 file into small chunks of 1 second clips that then can be played back using a video player. I would like to preserve the original mp4 video's video stream (i.e. preserve its color, resolution and etc.) and preserve the mp4 video's audio stream (i.e. preserve its bit rate and etc.). I am trying to achieve this using libavcodec in C++. But there does not seem to be any tutorial or documentation online that points me to that direction.


So far, I have looked at and tried to implement a solution using this tutorial (tutorial#1) : https://github.com/leandromoreira/ffmpeg-libav-tutorial/blob/master/0_hello_world.c


However, tutorial#1 aimed to save each video frame from the existing (original) mp4 video stream into individual .pgm files, which meant that the .pgm files would store a grayscale image of each video frame.


Since, I want to preserve the colors of the original (existing) mp4 file, I looked at this tutorial (tutorial#2) that aimed to convert the grayscale video frame into color using the swscale library : https://www.youtube.com/watch?v=Y7SUm7Xf1sc&ab_channel=Bartholomew
However, in tutorial#2, they exported the output from swscale library to a GUI library to be viewed in a GUI application and did not show hwo to write the output data into a new mp4 file that can be played back by a video player.


So then, I looked at this tutorial(tutorial#3) which showed how to create an MP4 file using libavcodec : C++ FFmpeg create mp4 file
However, the problem with that solution is that I was not able to take a video frame from the original mp4 video and store it into another mp4 file. I kept getting errors when attempting to do so and I did not succeed in taking the data from the original(existing) mp4 file and storing it into a new mp4 file.


Here is the code that I have written so far :


#include<fstream>
#include 
#include 
#include 
extern "C"
{
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavutil></libavutil>mathematics.h>
#include <libswscale></libswscale>swscale.h>
#include <libavfilter></libavfilter>buffersrc.h>
#include <libavfilter></libavfilter>buffersink.h>
#include <libavutil></libavutil>time.h>
#include <libavutil></libavutil>opt.h>
}
#pragma comment(lib, "avfilter.lib")
#ifdef av_err2str
#undef av_err2str
#include <string>
av_always_inline std::string av_err2string(int errnum) {
 char str[AV_ERROR_MAX_STRING_SIZE];
 return av_make_error_string(str, AV_ERROR_MAX_STRING_SIZE, errnum);
}
#define av_err2str(err) av_err2string(err).c_str()
#endif // av_err2str

#include <chrono>
#include <thread>


// decode packets into frames
static int decode_packet(AVPacket *pPacket, AVCodecContext *pCodecContext, AVFrame *pFrame);

static void pushFrame(AVFrame* frame, AVCodecContext* outputCodecContext, AVPacket * outputPacket, AVFormatContext* outputFormatContext, AVCodec *outputCodec) {
 
 std::cout<<"outputCodecContext: "<format = AV_PIX_FMT_YUV420P;
 frame->width = 800;
 frame->height = 800;
 if ((err = av_frame_get_buffer(frame, 32)) < 0) {
 std::cout << "Failed to allocate picture" << err << std::endl;
 return;
 }
 }
 SwsContext* swsCtx = nullptr;
 if (!swsCtx) {
 swsCtx = sws_getContext(800, 800, AV_PIX_FMT_RGB24, 800, 
 800, AV_PIX_FMT_YUV420P, SWS_BICUBIC, 0, 0, 0);
 }
 int inLinesize[1] = { 3 * 800 };
 // From RGB to YUV
 // sws_scale(swsCtx, (const uint8_t* const*)&data, inLinesize, 0, 800, 
 // frame->data, frame->linesize);
 std::cout<<"frame "<pts = (1.0 / 30.0) * 90000 * (1);
 // std::cout << videoFrame->pts << " " << cctx->time_base.num << " " << 
 // cctx->time_base.den << " " << 1 << std::endl;
 if ((err = avcodec_send_frame(outputCodecContext, frame)) < 0) {
 std::cout << "Failed to send frame" << err << std::endl;
 return;
 }
 AV_TIME_BASE;
 AVPacket pkt;
 av_init_packet(&pkt);
 pkt.data = NULL;
 pkt.size = 0;
 pkt.flags |= AV_PKT_FLAG_KEY;
 std::cout<<"here\n";
 if (avcodec_receive_packet(outputCodecContext, outputPacket) == 0) {
 static int counter = 0;
 if (counter == 0) {
 FILE* fp = fopen("dump_first_frame1.dat", "wb");
 fwrite(outputPacket->data, outputPacket->size, 1, fp);
 fclose(fp);
 }
 // std::cout << "pkt key: " << (pkt.flags & AV_PKT_FLAG_KEY) << " " << 
 // pkt.size << " " << (counter++) << std::endl;
 // uint8_t* size = ((uint8_t*)pkt.data);
 // std::cout << "first: " << (int)size[0] << " " << (int)size[1] << 
 // " " << (int)size[2] << " " << (int)size[3] << " " << (int)size[4] << 
 // " " << (int)size[5] << " " << (int)size[6] << " " << (int)size[7] << 
 // std::endl;
 av_interleaved_write_frame(outputFormatContext, outputPacket);
 av_packet_unref(outputPacket);
 }
}

int main()
{

 char* filename = "c++.mp4";

 AVFormatContext *pFormatContext = avformat_alloc_context();

 AVOutputFormat* outputFormat = NULL;

 AVFormatContext* outputFormatContext = nullptr;

 AVCodecContext* outputCodecContext = nullptr;

 if (!pFormatContext) {
 std::cerr<<"ERROR could not allocate memory for Format Context\n";
 return -1;
 }

 if (avformat_open_input(&pFormatContext, filename , NULL, NULL) != 0) {
 std::cerr<<"ERROR could not open the file\n";
 return -1;
 }

 std::cout<<"format: "<iformat->name<<" , duration:"<<(double)(pFormatContext->duration/AV_TIME_BASE)<<"seconds, bit_rate:"<bit_rate<video_codec);

 
 if (!outputCodec)
 {
 std::cout << "can't create output codec" << std::endl;
 return -1;
 } 
 

 AVStream* outputStream = avformat_new_stream(outputFormatContext, outputCodec);

 if (!outputStream)
 {
 std::cout << "can't find output format" << std::endl;
 return -1;
 }

 outputCodecContext = avcodec_alloc_context3(outputCodec);

 if (!outputCodecContext)
 {
 std::cout << "can't create output codec context" << std::endl;
 return -1;
 }

 AVCodec *pCodec = NULL;

 AVCodecParameters *pCodecParameters = NULL;

 int video_stream_index = -1;

 AVStream* stream = NULL;
 
 // loop though all the streams and print its main information
 for (int i = 0; i < pFormatContext->nb_streams; i++)
 {
 
 AVCodecParameters *pLocalCodecParameters = NULL;
 pLocalCodecParameters = pFormatContext->streams[i]->codecpar;

 AVCodec *pLocalCodec = NULL;
 pLocalCodec = avcodec_find_decoder(pLocalCodecParameters->codec_id);
 if (pLocalCodec==NULL) {
 std::cerr<<"ERROR unsupported codec!\n";
 // In this example if the codec is not found we just skip it
 continue;
 }


 if (pLocalCodecParameters->codec_type == AVMEDIA_TYPE_VIDEO) {
 if (video_stream_index == -1) {
 video_stream_index = i;
 pCodec = pLocalCodec;
 pCodecParameters = pLocalCodecParameters;
 stream = pFormatContext->streams[i];
 std::cout<<"codec id: "<codecpar->codec_id<codecpar->codec_type<codecpar->width<codecpar->height<codecpar->format<codecpar->bit_rate<codecpar->codec_id = outputFormat->video_codec;
 // outputStream->codecpar->codec_id = stream->codecpar->codec_id;
 outputStream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 outputStream->codecpar->width = stream->codecpar->width;
 outputStream->codecpar->height = stream->codecpar->height;
 outputStream->codecpar->format = AV_PIX_FMT_YUV420P;
 outputStream->codecpar->bit_rate = stream->codecpar->bit_rate;
 
 avcodec_parameters_to_context(outputCodecContext, outputStream->codecpar);
 } 

 std::cout<<"Video Codec: resolution " << pLocalCodecParameters->width << " x "<height<codec_type == AVMEDIA_TYPE_AUDIO) {
 std::cout<<"Audio Codec: "<channels<<" channels, sample rate "<sample_rate<name << " ID: " <id<< " bit_rate: "<bit_rate</ outputStream->codecpar->codec_id = outputFormat->video_codec;
 // outputStream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 // outputStream->codecpar->width = 300;
 // outputStream->codecpar->height = 300;
 // outputStream->codecpar->format = AV_PIX_FMT_YUV420P;
 // outputStream->codecpar->bit_rate = 200 * 1000;
 outputCodecContext->time_base = (AVRational){ 1, 1 };
 outputCodecContext->max_b_frames = 2;
 outputCodecContext->gop_size = 12;
 outputCodecContext->framerate = (AVRational){ 30, 1 };

 if (avcodec_parameters_to_context(pCodecContext, pCodecParameters) < 0)
 {
 std::cerr<<"failed to copy codec params to codec context\n";
 return -1;
 }

 // std::cout<<"pCodecContext->time_base: "<time_base)</ outputCodecContext->time_base = pCodecContext->time_base;
 // outputCodecContext->max_b_frames = pCodecContext->max_b_frames;
 // outputCodecContext->gop_size = pCodecContext->gop_size;
 // outputCodecContext->framerate = pCodecContext->framerate;

 if (outputStream->codecpar->codec_id == AV_CODEC_ID_H264) {
 // av_opt_set(pCodecContext, "preset", "ultrafast", 0);
 av_opt_set(outputCodecContext, "preset", "ultrafast", 0);
 }
 else if (outputStream->codecpar->codec_id == AV_CODEC_ID_H265)
 {
 // av_opt_set(pCodecContext, "preset", "ultrafast", 0);
 av_opt_set(outputCodecContext, "preset", "ultrafast", 0);
 }

 // avcodec_parameters_from_context(stream->codecpar, pCodecContext);
 avcodec_parameters_from_context(outputStream->codecpar, outputCodecContext);

 if (avcodec_open2(pCodecContext, pCodec, NULL) < 0)
 {
 std::cerr<<"failed to open codec through avcodec_open2\n";
 return -1;
 }

 if (avcodec_open2(outputCodecContext, outputCodec, NULL) < 0)
 {
 std::cerr<<"failed to open output codec through avcodec_open2\n";
 return -1;
 }


 if (!(outputFormat->flags & AVFMT_NOFILE)) {
 if (avio_open(&outputFormatContext->pb, "test.mp4", AVIO_FLAG_WRITE) < 0) {
 std::cout << "Failed to open file" << std::endl;
 return -1;
 }
 }

 if (avformat_write_header(outputFormatContext, NULL) < 0) {
 std::cout << "Failed to write header" << std::endl;
 return -1;
 }

 av_dump_format(outputFormatContext, 0, "test.mp4", 1);


 AVFrame *pFrame = av_frame_alloc();
 if (!pFrame)
 {
 std::cerr<<"failed to allocate memory for AVFrame\n";
 return -1;
 }
 
 // https://ffmpeg.org/doxygen/trunk/structAVPacket.html
 AVPacket *pPacket = av_packet_alloc();
 if (!pPacket)
 {
 std::cerr<<"failed to allocate memory for AVPacket\n";
 return -1;
 }

 int response = 0;
 int how_many_packets_to_process = 300;

 // fill the Packet with data from the Stream
 // https://ffmpeg.org/doxygen/trunk/group__lavf__decoding.html#ga4fdb3084415a82e3810de6ee60e46a61
 while (av_read_frame(pFormatContext, pPacket) >= 0)
 {
 // if it's the video stream
 if (pPacket->stream_index == video_stream_index) {
 std::cout<<"AVPacket->pts "<pts;
 // if(av_write_frame(outputFormatContext, pPacket)<0)
 // std::cout<<"error writing output frame\n";
 // pushFrame(pFrame, outputCodecContext, pPacket, outputFormatContext, outputCodec);
 response = decode_packet(pPacket, pCodecContext, pFrame);
 if (response < 0)
 break;
 // stop it, otherwise we'll be saving hundreds of frames
 if (--how_many_packets_to_process <= 0) break;
 }
 // https://ffmpeg.org/doxygen/trunk/group__lavc__packet.html#ga63d5a489b419bd5d45cfd09091cbcbc2
 av_packet_unref(pPacket);
 } 

 if(av_write_trailer(outputFormatContext)<0)
 std::cout <<"Error writing output trailer\n";


 return 0;
}

int save_frame_as_mpeg(AVCodecContext* pCodecCtx, AVFrame* pFrame, int FrameNo) {
 int ret = 0;

 const AVCodec* mpegCodec = avcodec_find_encoder(pCodecCtx->codec_id);
 if (!mpegCodec) {
 std::cout<<"failed to open mpegCodec\n";
 return -1;
 }
 AVCodecContext* mpegContext = avcodec_alloc_context3(mpegCodec);
 if (!mpegContext) {
 std::cout<<"failed to open mpegContext\n";
 return -1;
 }

 mpegContext->pix_fmt = pCodecCtx->pix_fmt;
 mpegContext->height = pFrame->height;
 mpegContext->width = pFrame->width;
 mpegContext->time_base = AVRational{ 1,10 };

 ret = avcodec_open2(mpegContext, mpegCodec, NULL);
 if (ret < 0) {
 return ret;
 }
 FILE* MPEGFile;
 char MPEGFName[256];

 AVPacket packet;
 packet.data = NULL;
 packet.size = 0;
 av_init_packet(&packet);

 int gotFrame;

 ret = avcodec_send_frame(mpegContext, pFrame);
 if (ret < 0) {
 std::cout<<"failed to send frame for mpegContext\n";
 return ret;
 }

 ret = avcodec_receive_packet(mpegContext, &packet);
 if (ret < 0) {
 std::cout<<"failed to receive packet for mpegContext\terrocode: "<pix_fmt = pCodecCtx->pix_fmt;
 jpegContext->height = pFrame->height;
 jpegContext->width = pFrame->width;
 jpegContext->time_base = AVRational{ 1,10 };

 ret = avcodec_open2(jpegContext, jpegCodec, NULL);
 if (ret < 0) {
 return ret;
 }
 FILE* JPEGFile;
 char JPEGFName[256];

 AVPacket packet;
 packet.data = NULL;
 packet.size = 0;
 av_init_packet(&packet);

 int gotFrame;

 ret = avcodec_send_frame(jpegContext, pFrame);
 if (ret < 0) {
 return ret;
 }

 ret = avcodec_receive_packet(jpegContext, &packet);
 if (ret < 0) {
 return ret;
 }

 sprintf(JPEGFName, "c:\\folder\\dvr-%06d.jpg", FrameNo);
 JPEGFile = fopen(JPEGFName, "wb");
 fwrite(packet.data, 1, packet.size, JPEGFile);
 fclose(JPEGFile);

 av_packet_unref(&packet);
 avcodec_close(jpegContext);
 return 0;
}

static int decode_packet(AVPacket *pPacket, AVCodecContext *pCodecContext, AVFrame *pFrame)
{
 // Supply raw packet data as input to a decoder
 // https://ffmpeg.org/doxygen/trunk/group__lavc__decoding.html#ga58bc4bf1e0ac59e27362597e467efff3
 int response = avcodec_send_packet(pCodecContext, pPacket);
 if (response < 0) {
 std::cerr<<"Error while sending a packet to the decoder: "<= 0)
 {
 // Return decoded output data (into a frame) from a decoder
 // https://ffmpeg.org/doxygen/trunk/group__lavc__decoding.html#ga11e6542c4e66d3028668788a1a74217c
 response = avcodec_receive_frame(pCodecContext, pFrame);
 if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
 break;
 } else if (response < 0) {
 std::cerr<<"Error while receiving a frame from the decoder: "<= 0) {

 response = save_frame_as_jpeg(pCodecContext, pFrame, pCodecContext->frame_number);

 if(response<0)
 {
 std::cerr<<"Failed to save frame as jpeg\n";
 return -1;
 }

 response = save_frame_as_mpeg(pCodecContext, pFrame, pCodecContext->frame_number);

 if(response<0)
 {
 std::cerr<<"Failed to save frame as mpeg\n";
 return -1;
 }


 std::cout<<
 "Frame "<frame_number<< "type= "<pict_type)<<" size= "<pkt_size<<" bytes, format= "<format<<" "<pts<<"pts key_frame "<key_frame<< " [DTS"<coded_picture_number<<" ]\n";
 
 char frame_filename[1024];
 snprintf(frame_filename, sizeof(frame_filename), "%s-%d.pgm", "frame", pCodecContext->frame_number);
 // Check if the frame is a planar YUV 4:2:0, 12bpp
 // That is the format of the provided .mp4 file
 // RGB formats will definitely not give a gray image
 // Other YUV image may do so, but untested, so give a warning
 if (pFrame->format != AV_PIX_FMT_YUV420P)
 {
 std::cout<<"Warning: the generated file may not be a grayscale image, but could e.g. be just the R component if the video format is RGB\n";
 }
 
 }
 }
 return 0;
}
</thread></chrono></string></fstream>

The question that I am seeking an answer to is How can I use libavcodec to split an mp4 file into 1 second chunk clips (those clips will be in mp4 format) ?


Syndiquer tout le site
