Recherche avancée
Médias (1)
-
Revolution of Open-source and film making towards open film making
6 octobre 2011, par
Mis à jour : Juillet 2013
Langue : English
Type : Texte
Autres articles (62)
-
Websites made with MediaSPIP
2 mai 2011, parThis page lists some websites based on MediaSPIP.
-
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" (...) -
Other interesting software
13 avril 2011, parWe don’t claim to be the only ones doing what we do ... and especially not to assert claims to be the best either ... What we do, we just try to do it well and getting better ...
The following list represents softwares that tend to be more or less as MediaSPIP or that MediaSPIP tries more or less to do the same, whatever ...
We don’t know them, we didn’t try them, but you can take a peek.
Videopress
Website : http://videopress.com/
License : GNU/GPL v2
Source code : (...)
Sur d’autres sites (6849)
-
Incrementality Testing : Quick-Start Guide (With Calculations)
26 mars 2024, par ErinHow do you know when a campaign is successful ? When you earn more revenue than last month ?
Maybe.
But how do you know how much of an impact a certain campaign or channel had on your sales ?
With marketing attribution, you can determine credit for each sale.
But if you want a deeper look, you need to understand the incremental impact of each channel and campaign.
The way you do this ?
Incrementality testing.
In this guide, we break down what incrementality is, why it’s important and how to test it so you can double down on the activities driving the most growth.
What is incrementality ?
So, what exactly is incrementality ?
Let’s say you just ran a marketing campaign for a new product. The launch was a success. Breakthrough numbers in your revenue. You used a variety of channels and activities to bring it all together.
So, you launch a plan for next month’s campaign. But you don’t truly know what moved the needle.
Did you just hit new highs because your audience is bigger ? And your brand is greater ?
Or did the recent moves you made make a direct difference ?
This is incrementality.
Incrementality is growth directly attributed to marketing efforts beyond the overall impact of your brand. By measuring and conducting incrementality testing, you can clearly see how much of a difference each activity or channel truly impacted business growth.
What is incrementality testing ?
Incrementality testing allows marketers to gauge the effectiveness of a marketing tactic or strategy. It tells you if a particular marketing activity had a positive, negative or neutral impact on your business.
It also tells you the overall impact it can have on your key performance indicators (KPIs).
The result ?
You can pinpoint the highest-performing moves and incorporate them into your marketing workflows. You also discard marketing strategies with negligible, neutral or even negative impacts.
For example, let’s say you think a B2B LinkedIn ads campaign will help you reach your product launch goals. An incrementality test can tell you if the introduction of this campaign will help you get to the desired outcome.
How incrementality testing works
Before diving into your testing phase, you must clearly identify your KPIs.
Here are the top KPIs you should be tracking on your website :
- Ad impressions
- Website visits
- Leads
- Sales
The exact KPIs will depend on your marketing goals. You’re ready to move forward once you know your key performance indicators.
Here’s how incrementality testing works step-by-step :
1. Define a test and control group
The first step is to define a test group and control group.
- A test group is a segment of your target audience that’s exposed to the marketing campaign.
- A control group is a segment that isn’t.
Keep in mind that both groups have similar demographics and other relevant characteristics.
2. Execute your campaign
The second step is to run the marketing campaign on the test group. This can be a Facebook ad, LinkedIn ad or email marketing campaign.
It all depends on your goals and your primary channels.
3. Measure outcomes
The third step is to measure the campaign’s impact based on your KPIs.
Let’s say a brand wants to see if a certain marketing move increases its leads. The test can tell them the number of email sign-ups with and without the campaign.
4. Compare results
Next, compare the test group results with the control group. The difference in outcomes tells you the impact of that campaign. You can then use this difference to inform your future marketing strategies.
With Matomo, you can easily track results from campaigns — like conversions.
Our platform lets you quickly see what channels are getting the best results so you can gain insights into incrementality and optimise your strategy.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Why it’s important to conduct incrementality tests
The digital marketing industry is constantly changing. Marketers need to stay on their toes to keep up. Incrementality tests help you stay on track.
For example, let’s say you’re selling laptops. You can increase your warranty period to three years to see the impact on sales. An incrementality test will tell you if this move will boost your sales (and by how much).
Now, let’s dive into the reasons why you need to consistently conduct incrementality tests :
Determine the right tactics for success
Identifying the best action to grow your business is a challenge every marketer faces.
The best way to identify marketing tactics is by conducting incrementality testing. These tactics are bound to work since data back them. As a result, you can optimise your marketing budget and maximise your ROIs.
It lets you run multiple tests to identify the most impactful strategy between :
- An email marketing strategy
- A social media strategy
- A PPC ad
For instance, an incrementality test might suggest email marketing will be more cost-effective than an ad campaign. What you can do is :
- Expose the test group to the email marketing campaign and then compare the results with the control group
- Expose the test group to the ad campaign and then compare its results with the control group
Then, you can calculate the difference in results between the two marketing campaigns. This lets you focus on the strategy with a better ROI or ROAS potential.
Accurate data
Marketing data is powerful. But getting accurate data can be challenging. With incrementality testing, you get to know the true impact of a marketing campaign.
Plus, with this testing strategy, you don’t have to waste your marketing budget.
With Matomo, you get 100% accurate data on all website activities.
Unlike Google Analytics, Matomo doesn’t rely on inaccurate data sampling — limiting the amount of data analysed.
Try Matomo for Free
Get the web insights you need, without compromising data accuracy.
Get the most out of your marketing investment
Every business owner wants to maximise their return on investment. The ROI you get mainly depends on the marketing strategy.
For instance, email marketing offers an ROI of about 40:1 with some sources even reporting as high as 72:1.
Incrementality testing helps you make informed investment decisions. With it, you can pinpoint the tactics that are most likely to bring the highest return. You can then focus your resources on them. It also helps you stay away from low-performing strategies.
Increase revenue
It’s safe to say that the goal behind every marketing effort is a revenue boost. The higher your revenue, the more profits you generate. However, for many marketers, it’s an uphill battle.
With incrementality testing, you can boost your revenue by focusing your efforts in the right direction.
Get more traffic
Incrementality testing tells you if a particular strategy can help you drive more traffic. You can use it to get more high-quality leads to your website or landing pages and double down on high-traffic strategies to increase those leads.
How to test incrementality
Developing an implementation plan is crucial to generate accurate insights from an incrementality test. Incrementality testing is like running a science experience. You need to go through several stages. Each stage is important for generating accurate results.
Here’s how you test incrementality :
Define your goals
Get clarity on what you want to achieve with this campaign. Which KPIs do you want to test ? Is it the return on your overall investment (ROI), return on ad spend (ROAS) or something else ?
Segment your audience
Selecting the right audience segment is crucial to getting accurate insights with an incrementality test. Decide the demographics and psychographics of the audience you want to target. Then, divide this audience segment into two sub-parts :
- Test group (people you’ll expose to the marketing campaign)
- Control group (people who won’t be exposed to the campaign)
These groups are a part of the larger segment. This means people in both groups will have similar attributes.
Launch the test at the right time
Before the launch, decide on the length of the test. Ideally, it should be at least one week. Don’t run any other campaigns in this window, as it can interfere with the results.
Analyse the data and take action
Once the campaign is over, measure the results from both groups. Compare the data to identify incremental lift in your selected KPIs.
Let’s say you want to see if this campaign can boost your sales. Check to see if the test group responded differently than the control group. If the sales equal your desired outcome, you have a winning strategy.
Not all incrementality tests result in a positive incremental lift ; Some can be neutral, indicating that the campaign didn’t have any effect. Some can even indicate a negative lift, which means your core group performed better than the test group.
Lastly, take action based on the test findings.
Incrementality test examples
You can use incrementality testing to identify gaps and growth opportunities in your strategy.
Here’s an example :
Let’s say a company runs an incrementality test on a YouTube marketing strategy for sales. The results indicate that the ROI was only $0.10, as the company makes $1.10 for every $1.00 spent. This alarms the marketing department and helps them optimise the campaign for a higher ROI.
Here’s another practical example :
Let’s say a retail business wanted to test the effectiveness of its ad campaign. So, the retailer optimises its ad campaign after conducting an incrementality test on a test and control group. As a result, they experienced a 34% incremental increase in sales.
How to calculate incrementality in marketing
Once you’ve aggregated the data, it’s time to calculate. There are two ways to calculate incrementality :
Incremental profit
The first one is incremental profit. It tells you how much profit you can generate with a strategy (If any). With it, you get the actual value of a marketing campaign.
It’s calculated with the following formula :
Test group profit – control group profit = incremental profit
For example, let’s say you’re exposing a test group to a paid ads campaign. And it generates a profit of $3,000. On the other hand, the control group generated a $2,000 profit.
In this case, your incremental profit will be $1,000 ($3,000 – $2,000).
However, if the paid ads campaign generates a $2,000 profit, the incremental profit would be zero. Essentially, you’re generating the same profit as before, which means the campaign doesn’t work. Similarly, a marketing strategy is no good if it generates lower profits than the control group.
Incremental lift
Incremental lift measures the difference in the conversions you generate with each group.
Here’s the formula :
(Test – Control)/Control x 100 = Lift
So, let’s say the test group and control group generated 2,000 and 1,000 conversions, respectively.
The incremental lift you’ll get from this incrementality test would be :
(2,000 – 1,000)/1,000 x 100 = 100
This turns out to be a 100% incremental lift.
How to track incrementality with Matomo
Incrementality testing lets you use a practical approach to identify the best marketing path for your business.
It helps you develop a hyper-focused approach that gives you access to accurate and practical data.
With these insights, you can confidently move forward to maximise your ROI since it helps you focus on high-performing tactics.
The result is more revenue and profit for your business.
Plus, all you need to do is identify your target audience, divide them into two groups and run your test. Then, the results will be compared to determine if the marketing strategy offers any value.
Conducting incrementality tests may take time and expertise.
But, thanks to Matomo, you can leverage accurate insights for your incrementality tests to ensure you make the right decisions to grow your business.
See for yourself why over 1 million websites choose Matomo. Try it free for 21-days now. No credit card required.
Try Matomo for Free
21 day free trial. No credit card required.
-
FFMPEG audio transcoding using libav* libraries
10 février 2014, par vinvinodI am writing an audio transcoding application using ffmpeg libraries.
Here is my code/*
* File: main.cpp
* Author: vinod
* Compile with "g++ -std=c++11 -o audiotranscode main.cpp -lavformat -lavcodec -lavutil -lavfilter"
*
*/
#if !defined PRId64 || PRI_MACROS_BROKEN
#undef PRId64
#define PRId64 "lld"
#endif
#define __STDC_FORMAT_MACROS
#ifdef __cplusplus
extern "C" {
#endif
#include
#include
#include <sys></sys>types.h>
#include
#include <libavutil></libavutil>imgutils.h>
#include <libavutil></libavutil>samplefmt.h>
#include <libavutil></libavutil>frame.h>
#include <libavutil></libavutil>timestamp.h>
#include <libavformat></libavformat>avformat.h>
#include <libavfilter></libavfilter>avfilter.h>
#include <libavfilter></libavfilter>buffersrc.h>
#include <libavfilter></libavfilter>buffersink.h>
#include <libswscale></libswscale>swscale.h>
#include <libavutil></libavutil>opt.h>
#ifdef __cplusplus
}
#endif
#include <iostream>
using namespace std;
int select_stream, got_frame, got_packet;
AVFormatContext *in_fmt_ctx = NULL, *out_fmt_ctx = NULL;
AVCodec *dec_codec = NULL, * enc_codec = NULL;
AVStream *audio_st = NULL;
AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL;
AVFrame *pFrame = NULL, * pFrameFiltered = NULL;
AVFilterGraph *filter_graph = NULL;
AVFilterContext *buffersrc_ctx = NULL;
AVFilterContext *buffersink_ctx = NULL;
AVPacket packet;
string inFileName = "/home/vinod/vinod/Media/univac.webm";
string outFileName = "audio_extracted.m4a";
int target_bit_rate = 128000,
sample_rate = 22050,
channels = 1;
AVSampleFormat sample_fmt = AV_SAMPLE_FMT_S16;
string filter_description = "aresample=22050,aformat=sample_fmts=s16:channel_layouts=mono";
int log_averror(int errcode)
{
char *errbuf = (char *) calloc(AV_ERROR_MAX_STRING_SIZE, sizeof(char));
av_strerror(errcode, errbuf, AV_ERROR_MAX_STRING_SIZE);
std::cout << "Error - " << errbuf << std::endl;
delete [] errbuf;
return -1;
}
/**
* Initialize conversion filter */
int initialize_audio_filter()
{
char args[512];
int ret;
AVFilter *buffersrc = avfilter_get_by_name("abuffer");
AVFilter *buffersink = avfilter_get_by_name("abuffersink");
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
filter_graph = avfilter_graph_alloc();
const enum AVSampleFormat out_sample_fmts[] = {sample_fmt, AV_SAMPLE_FMT_NONE};
const int64_t out_channel_layouts[] = {av_get_default_channel_layout(out_fmt_ctx -> streams[0] -> codec -> channels), -1};
const int out_sample_rates[] = {out_fmt_ctx -> streams[0] -> codec -> sample_rate, -1};
if (!dec_ctx->channel_layout)
dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);
snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%" PRIx64,
in_fmt_ctx -> streams[select_stream] -> time_base.num, in_fmt_ctx -> streams[select_stream] -> time_base.den,
dec_ctx->sample_rate,
av_get_sample_fmt_name(dec_ctx->sample_fmt),
dec_ctx->channel_layout);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
return -1;
}
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
return ret;
}
ret = av_opt_set_int_list(buffersink_ctx, "sample_fmts", out_sample_fmts, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
return ret;
}
ret = av_opt_set_int_list(buffersink_ctx, "channel_layouts", out_channel_layouts, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
return ret;
}
ret = av_opt_set_int_list(buffersink_ctx, "sample_rates", out_sample_rates, -1,
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
return ret;
}
/* Endpoints for the filter graph. */
outputs -> name = av_strdup("in");
outputs -> filter_ctx = buffersrc_ctx;
outputs -> pad_idx = 0;
outputs -> next = NULL;
/* Endpoints for the filter graph. */
inputs -> name = av_strdup("out");
inputs -> filter_ctx = buffersink_ctx;
inputs -> pad_idx = 0;
inputs -> next = NULL;
string filter_desc = filter_description;
if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_desc.c_str(), &inputs, &outputs, NULL)) < 0) {
log_averror(ret);
exit(1);
}
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0) {
log_averror(ret);
exit(1);
}
/* Print summary of the sink buffer
* Note: args buffer is reused to store channel layout string */
AVFilterLink *outlink = buffersink_ctx->inputs[0];
av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout);
av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n",
(int) outlink->sample_rate,
(char *) av_x_if_null(av_get_sample_fmt_name((AVSampleFormat) outlink->format), "?"),
args);
return 0;
}
/*
*
*/
int main(int argc, char **argv)
{
int ret;
cout << "Hello World" << endl;
printf("abcd");
avcodec_register_all();
av_register_all();
avfilter_register_all();
/* open input file, and allocate format context */
if (avformat_open_input(&in_fmt_ctx, inFileName.c_str(), NULL, NULL) < 0) {
std::cout << "error opening input file - " << inFileName << std::endl;
return -1;
}
/* retrieve stream information */
if (avformat_find_stream_info(in_fmt_ctx, NULL) < 0) {
std::cerr << "Could not find stream information in the input file " << inFileName << std::endl;
}
/* Dump format details */
printf("\n ---------------------------------------------------------------------- \n");
av_dump_format(in_fmt_ctx, 0, inFileName.c_str(), 0);
printf("\n ---------------------------------------------------------------------- \n");
/* Choose a audio stream */
select_stream = av_find_best_stream(in_fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, &dec_codec, 0);
if (select_stream == AVERROR_STREAM_NOT_FOUND) {
std::cerr << "No audio stream found" << std::endl;
return -1;
}
if (select_stream == AVERROR_DECODER_NOT_FOUND) {
std::cerr << "No suitable decoder found" << std::endl;
return -1;
}
dec_ctx = in_fmt_ctx -> streams[ select_stream] -> codec;
av_opt_set_int(dec_ctx, "refcounted_frames", 1, 0);
/* init the audio decoder */
if ((ret = avcodec_open2(dec_ctx, dec_codec, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open audio decoder\n");
return ret;
}
/* allocate output context */
ret = avformat_alloc_output_context2(&out_fmt_ctx, NULL, NULL,
outFileName.c_str());
if (ret < 0) {
std::cerr << "Could not create output context for the file " << outFileName << std::endl;
return -1;
}
/* find the encoder */
enum AVCodecID codec_id = out_fmt_ctx -> oformat -> audio_codec;
enc_codec = avcodec_find_encoder(codec_id);
if (!(enc_codec)) {
std::cerr << "Could not find encoder for - " << avcodec_get_name(codec_id) << std::endl;
return -1;
}
/* add a new stream */
audio_st = avformat_new_stream(out_fmt_ctx, enc_codec);
if (!audio_st) {
std::cerr << "Could not add audio stream - " << std::endl;
}
/* Initialise audio codec */
audio_st -> id = out_fmt_ctx -> nb_streams - 1;
enc_ctx = audio_st -> codec;
enc_ctx -> codec_id = codec_id;
enc_ctx -> codec_type = AVMEDIA_TYPE_AUDIO;
enc_ctx -> bit_rate = target_bit_rate;
enc_ctx -> sample_rate = sample_rate;
enc_ctx -> sample_fmt = sample_fmt;
enc_ctx -> channels = channels;
enc_ctx -> channel_layout = av_get_default_channel_layout(enc_ctx -> channels);
/* Some formats want stream headers to be separate. */
if (out_fmt_ctx -> oformat -> flags & AVFMT_GLOBALHEADER) {
enc_ctx -> flags |= CODEC_FLAG_GLOBAL_HEADER;
}
ret = avcodec_open2(out_fmt_ctx -> streams[0] -> codec, enc_codec, NULL);
if (ret < 0) {
std::cerr << "Could not create codec context for the file " << outFileName << std::endl;
return -1;
}
/* Initialize filter */
initialize_audio_filter();
if (!(out_fmt_ctx -> oformat -> flags & AVFMT_NOFILE)) {
int ret = avio_open(& out_fmt_ctx -> pb, outFileName.c_str(),
AVIO_FLAG_WRITE);
if (ret < 0) {
log_averror(ret);
return -1;
}
}
/* Write header */
if (avformat_write_header(out_fmt_ctx, NULL) < 0) {
if (ret < 0) {
log_averror(ret);
return -1;
}
}
/* Allocate frame */
pFrame = av_frame_alloc();
if (!pFrame) {
std::cerr << "Could not allocate frame\n";
return -1;
}
pFrameFiltered = av_frame_alloc();
if (!pFrameFiltered) {
std::cerr << "Could not allocate frame\n";
return -1;
}
av_init_packet(&packet);
packet.data = NULL;
packet.size = 0;
/* Read packet from the stream */
while (av_read_frame(in_fmt_ctx, &packet) >= 0) {
if (packet.stream_index == select_stream) {
avcodec_get_frame_defaults(pFrame);
ret = avcodec_decode_audio4(dec_ctx, pFrame, &got_frame, &packet);
if (ret < 0) {
log_averror(ret);
return ret;
}
printf("Decoded packet pts : %ld ", packet.pts);
printf("Frame Best Effor pts : %ld \n", pFrame->best_effort_timestamp);
/* Set frame pts */
pFrame -> pts = av_frame_get_best_effort_timestamp(pFrame);
if (got_frame) {
/* push the decoded frame into the filtergraph */
ret = av_buffersrc_add_frame_flags(buffersrc_ctx, pFrame, AV_BUFFERSRC_FLAG_KEEP_REF);
if (ret < 0) {
log_averror(ret);
return ret;
}
/* pull filtered frames from the filtergraph */
while (1) {
ret = av_buffersink_get_frame(buffersink_ctx, pFrameFiltered);
if ((ret == AVERROR(EAGAIN)) || (ret == AVERROR_EOF)) {
break;
}
if (ret < 0) {
printf("Error while getting filtered frames from filtergraph\n");
log_averror(ret);
return -1;
}
/* Initialize the packets */
AVPacket encodedPacket = {0};
av_init_packet(&encodedPacket);
ret = avcodec_encode_audio2(out_fmt_ctx -> streams[0] -> codec, &encodedPacket, pFrameFiltered, &got_packet);
if (!ret && got_packet && encodedPacket.size) {
/* Set correct pts and dts */
if (encodedPacket.pts != AV_NOPTS_VALUE) {
encodedPacket.pts = av_rescale_q(encodedPacket.pts, buffersink_ctx -> inputs[0] -> time_base,
out_fmt_ctx -> streams[0] -> time_base);
}
if (encodedPacket.dts != AV_NOPTS_VALUE) {
encodedPacket.dts = av_rescale_q(encodedPacket.dts, buffersink_ctx -> inputs[0] -> time_base,
out_fmt_ctx -> streams[0] -> time_base);
}
printf("Encoded packet pts %ld\n", encodedPacket.pts);
/* Write the compressed frame to the media file. */
ret = av_interleaved_write_frame(out_fmt_ctx, &encodedPacket);
if (ret < 0) {
log_averror(ret);
return -1;
}
} else if (ret < 0) {
log_averror(ret);
return -1;
}
av_frame_unref(pFrameFiltered);
}
av_frame_unref(pFrame);
}
}
}
/* Flush delayed frames from encoder*/
got_packet=1;
while (got_packet) {
AVPacket encodedPacket = {0};
av_init_packet(&encodedPacket);
ret = avcodec_encode_audio2(out_fmt_ctx -> streams[0] -> codec, &encodedPacket, NULL, &got_packet);
if (!ret && got_packet && encodedPacket.size) {
/* Set correct pts and dts */
if (encodedPacket.pts != AV_NOPTS_VALUE) {
encodedPacket.pts = av_rescale_q(encodedPacket.pts, buffersink_ctx -> inputs[0] -> time_base,
out_fmt_ctx -> streams[0] -> time_base);
}
if (encodedPacket.dts != AV_NOPTS_VALUE) {
encodedPacket.dts = av_rescale_q(encodedPacket.dts, buffersink_ctx -> inputs[0] -> time_base,
out_fmt_ctx -> streams[0] -> time_base);
}
printf("Encoded packet pts %ld\n", encodedPacket.pts);
/* Write the compressed frame to the media file. */
ret = av_interleaved_write_frame(out_fmt_ctx, &encodedPacket);
if (ret < 0) {
log_averror(ret);
return -1;
}
} else if (ret < 0) {
log_averror(ret);
return -1;
}
}
/* Write Trailer */
av_write_trailer(out_fmt_ctx);
avfilter_graph_free(&filter_graph);
if (dec_ctx)
avcodec_close(dec_ctx);
avformat_close_input(&in_fmt_ctx);
av_frame_free(&pFrame);
av_frame_free(&pFrameFiltered);
if (!(out_fmt_ctx -> oformat -> flags & AVFMT_NOFILE))
avio_close(out_fmt_ctx -> pb);
avcodec_close(out_fmt_ctx->streams[0]->codec);
avformat_free_context(out_fmt_ctx);
return 0;
}
</iostream>The audio file after transcoding is same duration as the input. But its completely noisy. Can somebody tell me what I am doing wrong here !
-
FFMPEG audio transcoding using libav* libraries
25 mai 2022, par vinvinodI am writing an audio transcoding application using ffmpeg libraries. 
Here is my code



/*
 * File: main.cpp
 * Author: vinod
 * Compile with "g++ -std=c++11 -o audiotranscode main.cpp -lavformat -lavcodec -lavutil -lavfilter"
 * 
 */


 #if !defined PRId64 || PRI_MACROS_BROKEN
 #undef PRId64
 #define PRId64 "lld"
 #endif

 #define __STDC_FORMAT_MACROS

 #ifdef __cplusplus
 extern "C" {
 #endif

 #include 
 #include 
 #include <sys></sys>types.h>
 #include 
 #include <libavutil></libavutil>imgutils.h>
 #include <libavutil></libavutil>samplefmt.h>
 #include <libavutil></libavutil>frame.h>
 #include <libavutil></libavutil>timestamp.h>
 #include <libavformat></libavformat>avformat.h>
 #include <libavfilter></libavfilter>avfilter.h>
 #include <libavfilter></libavfilter>buffersrc.h>
 #include <libavfilter></libavfilter>buffersink.h>
 #include <libswscale></libswscale>swscale.h>
 #include <libavutil></libavutil>opt.h>

 #ifdef __cplusplus
 }
 #endif

 #include <iostream>
 using namespace std;

 int select_stream, got_frame, got_packet;

 AVFormatContext *in_fmt_ctx = NULL, *out_fmt_ctx = NULL;
 AVCodec *dec_codec = NULL, * enc_codec = NULL;
 AVStream *audio_st = NULL;
 AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL;

 AVFrame *pFrame = NULL, * pFrameFiltered = NULL;

 AVFilterGraph *filter_graph = NULL;
 AVFilterContext *buffersrc_ctx = NULL;
 AVFilterContext *buffersink_ctx = NULL;

 AVPacket packet;

 string inFileName = "/home/vinod/vinod/Media/univac.webm";
 string outFileName = "audio_extracted.m4a";

 int target_bit_rate = 128000,
 sample_rate = 22050,
 channels = 1;
 AVSampleFormat sample_fmt = AV_SAMPLE_FMT_S16;
 string filter_description = "aresample=22050,aformat=sample_fmts=s16:channel_layouts=mono";

 int log_averror(int errcode)
 {
 char *errbuf = (char *) calloc(AV_ERROR_MAX_STRING_SIZE, sizeof(char));
 av_strerror(errcode, errbuf, AV_ERROR_MAX_STRING_SIZE);
 std::cout << "Error - " << errbuf << std::endl;
 delete [] errbuf;
 return -1;
 }

 /**
 * Initialize conversion filter */
 int initialize_audio_filter()
 {
 char args[512];
 int ret;
 AVFilter *buffersrc = avfilter_get_by_name("abuffer");
 AVFilter *buffersink = avfilter_get_by_name("abuffersink");
 AVFilterInOut *outputs = avfilter_inout_alloc();
 AVFilterInOut *inputs = avfilter_inout_alloc();
 filter_graph = avfilter_graph_alloc();
 const enum AVSampleFormat out_sample_fmts[] = {sample_fmt, AV_SAMPLE_FMT_NONE};
 const int64_t out_channel_layouts[] = {av_get_default_channel_layout(out_fmt_ctx -> streams[0] -> codec -> channels), -1};
 const int out_sample_rates[] = {out_fmt_ctx -> streams[0] -> codec -> sample_rate, -1};

 if (!dec_ctx->channel_layout)
 dec_ctx->channel_layout = av_get_default_channel_layout(dec_ctx->channels);

 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%" PRIx64,
 in_fmt_ctx -> streams[select_stream] -> time_base.num, in_fmt_ctx -> streams[select_stream] -> time_base.den,
 dec_ctx->sample_rate,
 av_get_sample_fmt_name(dec_ctx->sample_fmt),
 dec_ctx->channel_layout);
 ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph);

 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
 return -1;
 }

 ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, NULL, filter_graph);

 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
 return ret;
 }

 ret = av_opt_set_int_list(buffersink_ctx, "sample_fmts", out_sample_fmts, -1,
 AV_OPT_SEARCH_CHILDREN);

 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
 return ret;
 }

 ret = av_opt_set_int_list(buffersink_ctx, "channel_layouts", out_channel_layouts, -1,
 AV_OPT_SEARCH_CHILDREN);

 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
 return ret;
 }

 ret = av_opt_set_int_list(buffersink_ctx, "sample_rates", out_sample_rates, -1,
 AV_OPT_SEARCH_CHILDREN);

 if (ret < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
 return ret;
 }

 /* Endpoints for the filter graph. */
 outputs -> name = av_strdup("in");
 outputs -> filter_ctx = buffersrc_ctx;
 outputs -> pad_idx = 0;
 outputs -> next = NULL;
 /* Endpoints for the filter graph. */
 inputs -> name = av_strdup("out");
 inputs -> filter_ctx = buffersink_ctx;
 inputs -> pad_idx = 0;
 inputs -> next = NULL;
 string filter_desc = filter_description;

 if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_desc.c_str(), &inputs, &outputs, NULL)) < 0) {
 log_averror(ret);
 exit(1);
 }

 if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0) {
 log_averror(ret);
 exit(1);
 }

 /* Print summary of the sink buffer
 * Note: args buffer is reused to store channel layout string */
 AVFilterLink *outlink = buffersink_ctx->inputs[0];
 av_get_channel_layout_string(args, sizeof(args), -1, outlink->channel_layout);
 av_log(NULL, AV_LOG_INFO, "Output: srate:%dHz fmt:%s chlayout:%s\n",
 (int) outlink->sample_rate,
 (char *) av_x_if_null(av_get_sample_fmt_name((AVSampleFormat) outlink->format), "?"),
 args);
 return 0;
 }

 /*
 *
 */
 int main(int argc, char **argv)
 {
 int ret;
 cout << "Hello World" << endl;
 printf("abcd");
 avcodec_register_all();
 av_register_all();
 avfilter_register_all();

 /* open input file, and allocate format context */
 if (avformat_open_input(&in_fmt_ctx, inFileName.c_str(), NULL, NULL) < 0) {
 std::cout << "error opening input file - " << inFileName << std::endl;
 return -1;
 }

 /* retrieve stream information */
 if (avformat_find_stream_info(in_fmt_ctx, NULL) < 0) {
 std::cerr << "Could not find stream information in the input file " << inFileName << std::endl;
 }

 /* Dump format details */
 printf("\n ---------------------------------------------------------------------- \n");
 av_dump_format(in_fmt_ctx, 0, inFileName.c_str(), 0);
 printf("\n ---------------------------------------------------------------------- \n");
 /* Choose a audio stream */
 select_stream = av_find_best_stream(in_fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, &dec_codec, 0);

 if (select_stream == AVERROR_STREAM_NOT_FOUND) {
 std::cerr << "No audio stream found" << std::endl;
 return -1;
 }

 if (select_stream == AVERROR_DECODER_NOT_FOUND) {
 std::cerr << "No suitable decoder found" << std::endl;
 return -1;
 }

 dec_ctx = in_fmt_ctx -> streams[ select_stream] -> codec;
 av_opt_set_int(dec_ctx, "refcounted_frames", 1, 0);

 /* init the audio decoder */
 if ((ret = avcodec_open2(dec_ctx, dec_codec, NULL)) < 0) {
 av_log(NULL, AV_LOG_ERROR, "Cannot open audio decoder\n");
 return ret;
 }

 /* allocate output context */
 ret = avformat_alloc_output_context2(&out_fmt_ctx, NULL, NULL,
 outFileName.c_str());

 if (ret < 0) {
 std::cerr << "Could not create output context for the file " << outFileName << std::endl;
 return -1;
 }

 /* find the encoder */
 enum AVCodecID codec_id = out_fmt_ctx -> oformat -> audio_codec;
 enc_codec = avcodec_find_encoder(codec_id);

 if (!(enc_codec)) {
 std::cerr << "Could not find encoder for - " << avcodec_get_name(codec_id) << std::endl;
 return -1;
 }

 /* add a new stream */
 audio_st = avformat_new_stream(out_fmt_ctx, enc_codec);

 if (!audio_st) {
 std::cerr << "Could not add audio stream - " << std::endl;
 }

 /* Initialise audio codec */
 audio_st -> id = out_fmt_ctx -> nb_streams - 1;
 enc_ctx = audio_st -> codec;
 enc_ctx -> codec_id = codec_id;
 enc_ctx -> codec_type = AVMEDIA_TYPE_AUDIO;
 enc_ctx -> bit_rate = target_bit_rate;
 enc_ctx -> sample_rate = sample_rate;
 enc_ctx -> sample_fmt = sample_fmt;
 enc_ctx -> channels = channels;
 enc_ctx -> channel_layout = av_get_default_channel_layout(enc_ctx -> channels);

 /* Some formats want stream headers to be separate. */
 if (out_fmt_ctx -> oformat -> flags & AVFMT_GLOBALHEADER) {
 enc_ctx -> flags |= CODEC_FLAG_GLOBAL_HEADER;
 }

 ret = avcodec_open2(out_fmt_ctx -> streams[0] -> codec, enc_codec, NULL);

 if (ret < 0) {
 std::cerr << "Could not create codec context for the file " << outFileName << std::endl;
 return -1;
 }

 /* Initialize filter */
 initialize_audio_filter();

 if (!(out_fmt_ctx -> oformat -> flags & AVFMT_NOFILE)) {
 int ret = avio_open(& out_fmt_ctx -> pb, outFileName.c_str(),
 AVIO_FLAG_WRITE);

 if (ret < 0) {
 log_averror(ret);
 return -1;
 }
 }

 /* Write header */
 if (avformat_write_header(out_fmt_ctx, NULL) < 0) {
 if (ret < 0) {
 log_averror(ret);
 return -1;
 }
 }

 /* Allocate frame */
 pFrame = av_frame_alloc();

 if (!pFrame) {
 std::cerr << "Could not allocate frame\n";
 return -1;
 }

 pFrameFiltered = av_frame_alloc();

 if (!pFrameFiltered) {
 std::cerr << "Could not allocate frame\n";
 return -1;
 }

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

 /* Read packet from the stream */
 while (av_read_frame(in_fmt_ctx, &packet) >= 0) {
 if (packet.stream_index == select_stream) {
 avcodec_get_frame_defaults(pFrame);
 ret = avcodec_decode_audio4(dec_ctx, pFrame, &got_frame, &packet);

 if (ret < 0) {
 log_averror(ret);
 return ret;
 }

 printf("Decoded packet pts : %ld ", packet.pts);
 printf("Frame Best Effor pts : %ld \n", pFrame->best_effort_timestamp);
 /* Set frame pts */
 pFrame -> pts = av_frame_get_best_effort_timestamp(pFrame);

 if (got_frame) {
 /* push the decoded frame into the filtergraph */
 ret = av_buffersrc_add_frame_flags(buffersrc_ctx, pFrame, AV_BUFFERSRC_FLAG_KEEP_REF);

 if (ret < 0) {
 log_averror(ret);
 return ret;
 }

 /* pull filtered frames from the filtergraph */
 while (1) {
 ret = av_buffersink_get_frame(buffersink_ctx, pFrameFiltered);

 if ((ret == AVERROR(EAGAIN)) || (ret == AVERROR_EOF)) {
 break;
 }

 if (ret < 0) {
 printf("Error while getting filtered frames from filtergraph\n");
 log_averror(ret);
 return -1;
 }

 /* Initialize the packets */
 AVPacket encodedPacket = {0};
 av_init_packet(&encodedPacket);
 ret = avcodec_encode_audio2(out_fmt_ctx -> streams[0] -> codec, &encodedPacket, pFrameFiltered, &got_packet);

 if (!ret && got_packet && encodedPacket.size) {
 /* Set correct pts and dts */
 if (encodedPacket.pts != AV_NOPTS_VALUE) {
 encodedPacket.pts = av_rescale_q(encodedPacket.pts, buffersink_ctx -> inputs[0] -> time_base,
 out_fmt_ctx -> streams[0] -> time_base);
 }

 if (encodedPacket.dts != AV_NOPTS_VALUE) {
 encodedPacket.dts = av_rescale_q(encodedPacket.dts, buffersink_ctx -> inputs[0] -> time_base,
 out_fmt_ctx -> streams[0] -> time_base);
 }

 printf("Encoded packet pts %ld\n", encodedPacket.pts);
 /* Write the compressed frame to the media file. */
 ret = av_interleaved_write_frame(out_fmt_ctx, &encodedPacket);

 if (ret < 0) {
 log_averror(ret);
 return -1;
 }
 } else if (ret < 0) {
 log_averror(ret);
 return -1;
 }

 av_frame_unref(pFrameFiltered);
 }

 av_frame_unref(pFrame);
 }
 }
 }

 /* Flush delayed frames from encoder*/
 got_packet=1;
 while (got_packet) {
 AVPacket encodedPacket = {0};
 av_init_packet(&encodedPacket);
 ret = avcodec_encode_audio2(out_fmt_ctx -> streams[0] -> codec, &encodedPacket, NULL, &got_packet);

 if (!ret && got_packet && encodedPacket.size) {
 /* Set correct pts and dts */
 if (encodedPacket.pts != AV_NOPTS_VALUE) {
 encodedPacket.pts = av_rescale_q(encodedPacket.pts, buffersink_ctx -> inputs[0] -> time_base,
 out_fmt_ctx -> streams[0] -> time_base);
 }

 if (encodedPacket.dts != AV_NOPTS_VALUE) {
 encodedPacket.dts = av_rescale_q(encodedPacket.dts, buffersink_ctx -> inputs[0] -> time_base,
 out_fmt_ctx -> streams[0] -> time_base);
 }

 printf("Encoded packet pts %ld\n", encodedPacket.pts);
 /* Write the compressed frame to the media file. */
 ret = av_interleaved_write_frame(out_fmt_ctx, &encodedPacket);

 if (ret < 0) {
 log_averror(ret);
 return -1;
 }
 } else if (ret < 0) {
 log_averror(ret);
 return -1;
 }
 }

 /* Write Trailer */
 av_write_trailer(out_fmt_ctx);
 avfilter_graph_free(&filter_graph);

 if (dec_ctx)
 avcodec_close(dec_ctx);

 avformat_close_input(&in_fmt_ctx);
 av_frame_free(&pFrame);
 av_frame_free(&pFrameFiltered);

 if (!(out_fmt_ctx -> oformat -> flags & AVFMT_NOFILE))
 avio_close(out_fmt_ctx -> pb);
 avcodec_close(out_fmt_ctx->streams[0]->codec);
 avformat_free_context(out_fmt_ctx);
 return 0;
 }
</iostream>


The audio file after transcoding is same duration as the input. But its completely noisy. Can somebody tell me what I am doing wrong here !


Syndiquer tout le site
