Sur d’autres sites (3511)

• Transcode of H.264 to VP8 using libav* has incorrect frame rate

  17 avril 2014, par Kevin Watson

  I’ve so far failed to get the correct output frame rate when transcoding H.264 to VP8 with the libav* libraries. I created a functioning encode of Sintel.2010.720p.mkv as WebM (VP8/Vorbis) using a modification of the transcoding.c example in the FFmpeg source. Unfortunately the resulting file is 48 fps unlike the 24 fps of the original and the output of the ffmpeg command I’m trying to mimic.

  I noticed ffprobe produces a tbc of double the fps for this and other H.264 videos, while the tbc of the resulting VP8 stream produced by the ffmpeg command is the default 1000. The stock transcoding.c example copies the time base of the decoder to the encoder AVCodecContext, which is 1/48. Running the ffmpeg command through gdb it looks like the time base of the AVCodecContext is set to 1/24, but making that change alone only causes the resulting video to be slowed to twice the duration at 24 fps.

  I can create a usable video, but the frame rate doubles. When the output frame rate is the correct 24 fps, the video is smooth but slowed to half speed.

  Here is my modification of the example.

   /*
  
    * Copyright (c) 2010 Nicolas George
  
    * Copyright (c) 2011 Stefano Sabatini
  
    * Copyright (c) 2014 Andrey Utkin
  
    *
  
    * Permission is hereby granted, free of charge, to any person obtaining a copy
  
    * of this software and associated documentation files (the "Software"), to deal
  
    * in the Software without restriction, including without limitation the rights
  
    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  
    * copies of the Software, and to permit persons to whom the Software is
  
    * furnished to do so, subject to the following conditions:
  
    *
  
    * The above copyright notice and this permission notice shall be included in
  
    * all copies or substantial portions of the Software.
  
    *
  
    * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  
    * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  
    * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  
    * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  
    * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  
    * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  
    * THE SOFTWARE.
  
    */
  
  
  
   /**
  
    * @file
  
    * API example for demuxing, decoding, filtering, encoding and muxing
  
    * @example doc/examples/transcoding.c
  
    */
  
  
  
   #include <libavcodec></libavcodec>avcodec.h>
  
   #include <libavformat></libavformat>avformat.h>
  
   #include <libavfilter></libavfilter>avfiltergraph.h>
  
   #include <libavfilter></libavfilter>avcodec.h>
  
   #include <libavfilter></libavfilter>buffersink.h>
  
   #include <libavfilter></libavfilter>buffersrc.h>
  
   #include <libavutil></libavutil>opt.h>
  
   #include <libavutil></libavutil>pixdesc.h>
  
  
  
   #define STATS_LOG "stats.log"
  
  
  
   static AVFormatContext *ifmt_ctx;
  
   static AVFormatContext *ofmt_ctx;
  
   typedef struct FilteringContext {
  
     AVFilterContext *buffersink_ctx;
  
     AVFilterContext *buffersrc_ctx;
  
     AVFilterGraph *filter_graph;
  
   } FilteringContext;
  
   static FilteringContext *filter_ctx;
  
  
  
   static int open_input_file(const char *filename) {
  
     int ret;
  
     unsigned int i;
  
  
  
     ifmt_ctx = NULL;
  
     if ((ret = avformat_open_input(&amp;ifmt_ctx, filename, NULL, NULL)) &lt; 0) {
  
   av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
  
   return ret;
  
     }
  
  
  
     if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) &lt; 0) {
  
   av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
  
   return ret;
  
     }
  
  
  
     for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
   AVStream *stream;
  
   AVCodecContext *codec_ctx;
  
   stream = ifmt_ctx->streams[i];
  
   codec_ctx = stream->codec;
  
   /* Reencode video &amp; audio and remux subtitles etc. */
  
   if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
  
       || codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
  
     /* Open decoder */
  
     ret = avcodec_open2(codec_ctx,
  
                 avcodec_find_decoder(codec_ctx->codec_id), NULL);
  
     if (ret &lt; 0) {
  
       av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
  
       return ret;
  
     }
  
   }
  
     }
  
  
  
     av_dump_format(ifmt_ctx, 0, filename, 0);
  
     return 0;
  
   }
  
  
  
   static int init_output_context(char* filename) {
  
     int ret;
  
     ofmt_ctx = NULL;
  
  
  
     avformat_alloc_output_context2(&amp;ofmt_ctx, NULL, NULL, filename);
  
     if (!ofmt_ctx) {
  
   av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
  
   return AVERROR_UNKNOWN;
  
     }
  
  
  
     return 0;
  
   }
  
  
  
   static int init_webm_encoders(int audioBitRate, int crf, int videoMaxBitRate, int threads,
  
                 char* quality, int speed, int pass, char* stats) {
  
     AVStream *out_stream;
  
     AVStream *in_stream;
  
     AVCodecContext *dec_ctx, *enc_ctx;
  
     AVCodec *encoder;
  
     int ret;
  
     unsigned int i;
  
  
  
     for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
   in_stream = ifmt_ctx->streams[i];
  
   dec_ctx = in_stream->codec;
  
   if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO || dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
  
  
  
     AVDictionary *opts = NULL;
  
     if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
  
       encoder = avcodec_find_encoder(AV_CODEC_ID_VP8);
  
       out_stream = avformat_new_stream(ofmt_ctx, encoder);
  
       if (!out_stream) {
  
         av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
  
         return AVERROR_UNKNOWN;
  
       }
  
  
  
       enc_ctx = out_stream->codec;
  
       enc_ctx->height = dec_ctx->height;
  
       enc_ctx->width = dec_ctx->width;
  
       enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
  
       /* take first format from list of supported formats */
  
       enc_ctx->pix_fmt = encoder->pix_fmts[0];
  
       /* video time_base can be set to whatever is handy and supported by encoder */
  
       enc_ctx->time_base = dec_ctx->time_base;
  
       /* enc_ctx->time_base.num = 1; */
  
       /* enc_ctx->time_base.den = 24; */
  
  
  
       enc_ctx->bit_rate = videoMaxBitRate;
  
       enc_ctx->thread_count = threads;
  
       switch (pass) {
  
       case 1:
  
         enc_ctx->flags |= CODEC_FLAG_PASS1;
  
         break;
  
       case 2:
  
         enc_ctx->flags |= CODEC_FLAG_PASS2;
  
         if (stats) {
  
       enc_ctx->stats_in = stats;
  
         }
  
         break;
  
       }
  
  
  
       char crfString[3];
  
       snprintf(crfString, 3, "%d", crf);
  
       av_dict_set(&amp;opts, "crf", crfString, 0);
  
       av_dict_set(&amp;opts, "quality", quality, 0);
  
       char speedString[3];
  
       snprintf(speedString, 3, "%d", speed);
  
       av_dict_set(&amp;opts, "speed", speedString, 0);
  
     } else {
  
       encoder = avcodec_find_encoder(AV_CODEC_ID_VORBIS);
  
       out_stream = avformat_new_stream(ofmt_ctx, encoder);
  
       if (!out_stream) {
  
         av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
  
         return AVERROR_UNKNOWN;
  
       }
  
  
  
       /* in_stream = ifmt_ctx->streams[i]; */
  
       /* dec_ctx = in_stream->codec; */
  
       enc_ctx = out_stream->codec;
  
       /* encoder = out_stream->codec->codec; */
  
  
  
       enc_ctx->sample_rate = dec_ctx->sample_rate;
  
       enc_ctx->channel_layout = dec_ctx->channel_layout;
  
       enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
  
       /* take first format from list of supported formats */
  
       enc_ctx->sample_fmt = encoder->sample_fmts[0];
  
       enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate};
  
       enc_ctx->bit_rate = audioBitRate;
  
     }
  
  
  
     /* Open codec with the set options */
  
     ret = avcodec_open2(enc_ctx, encoder, &amp;opts);
  
     if (ret &lt; 0) {
  
       av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
  
       return ret;
  
     }
  
     int unused = av_dict_count(opts);
  
     if (unused > 0) {
  
       av_log(NULL, AV_LOG_WARNING, "%d unused options\n", unused);
  
     }
  
     /* } else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) { */
  
   } else {
  
     av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
  
     return AVERROR_INVALIDDATA;
  
   } /* else { */
  
     /*   /\* if this stream must be remuxed *\/ */
  
     /*   ret = avcodec_copy_context(ofmt_ctx->streams[i]->codec, */
  
     /*                ifmt_ctx->streams[i]->codec); */
  
     /*   if (ret &lt; 0) { */
  
     /*   av_log(NULL, AV_LOG_ERROR, "Copying stream context failed\n"); */
  
     /*   return ret; */
  
     /*   } */
  
     /* } */
  
  
  
   if (ofmt_ctx->oformat->flags &amp; AVFMT_GLOBALHEADER)
  
     enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
     }
  
  
  
     return 0;
  
   }
  
  
  
   static int open_output_file(const char *filename) {
  
     int ret;
  
  
  
     av_dump_format(ofmt_ctx, 0, filename, 1);
  
  
  
     if (!(ofmt_ctx->oformat->flags &amp; AVFMT_NOFILE)) {
  
   ret = avio_open(&amp;ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Could not open output file &#39;%s&#39;", filename);
  
     return ret;
  
   }
  
     }
  
  
  
     /* init muxer, write output file header */
  
     ret = avformat_write_header(ofmt_ctx, NULL);
  
     if (ret &lt; 0) {
  
   av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
  
   return ret;
  
     }
  
  
  
     return 0;
  
   }
  
  
  
   static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
  
              AVCodecContext *enc_ctx, const char *filter_spec) {
  
     char args[512];
  
     int ret = 0;
  
     AVFilter *buffersrc = NULL;
  
     AVFilter *buffersink = NULL;
  
     AVFilterContext *buffersrc_ctx = NULL;
  
     AVFilterContext *buffersink_ctx = NULL;
  
     AVFilterInOut *outputs = avfilter_inout_alloc();
  
     AVFilterInOut *inputs  = avfilter_inout_alloc();
  
     AVFilterGraph *filter_graph = avfilter_graph_alloc();
  
  
  
     if (!outputs || !inputs || !filter_graph) {
  
   ret = AVERROR(ENOMEM);
  
   goto end;
  
     }
  
  
  
     if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
  
   buffersrc = avfilter_get_by_name("buffer");
  
   buffersink = avfilter_get_by_name("buffersink");
  
   if (!buffersrc || !buffersink) {
  
     av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
  
     ret = AVERROR_UNKNOWN;
  
     goto end;
  
   }
  
  
  
   snprintf(args, sizeof(args),
  
        "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
  
        dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
  
        dec_ctx->time_base.num, dec_ctx->time_base.den,
  
        dec_ctx->sample_aspect_ratio.num,
  
        dec_ctx->sample_aspect_ratio.den);
  
  
  
   ret = avfilter_graph_create_filter(&amp;buffersrc_ctx, buffersrc, "in",
  
                      args, NULL, filter_graph);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
  
     goto end;
  
   }
  
  
  
   ret = avfilter_graph_create_filter(&amp;buffersink_ctx, buffersink, "out",
  
                      NULL, NULL, filter_graph);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
  
     goto end;
  
   }
  
  
  
   ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
  
                (uint8_t*)&amp;enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),
  
                AV_OPT_SEARCH_CHILDREN);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
  
     goto end;
  
   }
  
     } else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
  
   buffersrc = avfilter_get_by_name("abuffer");
  
   buffersink = avfilter_get_by_name("abuffersink");
  
   if (!buffersrc || !buffersink) {
  
     av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
  
     ret = AVERROR_UNKNOWN;
  
     goto end;
  
   }
  
  
  
   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,
  
        dec_ctx->time_base.num, dec_ctx->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(&amp;buffersrc_ctx, buffersrc, "in",
  
                      args, NULL, filter_graph);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
  
     goto end;
  
   }
  
  
  
   ret = avfilter_graph_create_filter(&amp;buffersink_ctx, buffersink, "out",
  
                      NULL, NULL, filter_graph);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
  
     goto end;
  
   }
  
  
  
   ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",
  
                (uint8_t*)&amp;enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),
  
                AV_OPT_SEARCH_CHILDREN);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
  
     goto end;
  
   }
  
  
  
   ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",
  
                (uint8_t*)&amp;enc_ctx->channel_layout,
  
                sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
  
     goto end;
  
   }
  
  
  
   ret = av_opt_set_bin(buffersink_ctx, "sample_rates",
  
                (uint8_t*)&amp;enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),
  
                AV_OPT_SEARCH_CHILDREN);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
  
     goto end;
  
   }
  
     } else {
  
   ret = AVERROR_UNKNOWN;
  
   goto end;
  
     }
  
  
  
     /* Endpoints for the filter graph. */
  
     outputs->name       = av_strdup("in");
  
     outputs->filter_ctx = buffersrc_ctx;
  
     outputs->pad_idx    = 0;
  
     outputs->next       = NULL;
  
  
  
     inputs->name       = av_strdup("out");
  
     inputs->filter_ctx = buffersink_ctx;
  
     inputs->pad_idx    = 0;
  
     inputs->next       = NULL;
  
  
  
     if (!outputs->name || !inputs->name) {
  
   ret = AVERROR(ENOMEM);
  
   goto end;
  
     }
  
  
  
     if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
  
                     &amp;inputs, &amp;outputs, NULL)) &lt; 0)
  
   goto end;
  
  
  
     if ((ret = avfilter_graph_config(filter_graph, NULL)) &lt; 0)
  
   goto end;
  
  
  
     /* Fill FilteringContext */
  
     fctx->buffersrc_ctx = buffersrc_ctx;
  
     fctx->buffersink_ctx = buffersink_ctx;
  
     fctx->filter_graph = filter_graph;
  
  
  
    end:
  
     avfilter_inout_free(&amp;inputs);
  
     avfilter_inout_free(&amp;outputs);
  
  
  
     return ret;
  
   }
  
  
  
   static int init_filters(enum AVCodecID audioCodec) {
  
     const char *filter_spec;
  
     unsigned int i;
  
     int ret;
  
     filter_ctx = av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));
  
     if (!filter_ctx)
  
   return AVERROR(ENOMEM);
  
  
  
     for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
   filter_ctx[i].buffersrc_ctx  = NULL;
  
   filter_ctx[i].buffersink_ctx = NULL;
  
   filter_ctx[i].filter_graph   = NULL;
  
   /* Skip streams that are neither audio nor video */
  
   if (!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO
  
         || ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
  
     continue;
  
  
  
  
  
   if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
  
     filter_spec = "null"; /* passthrough (dummy) filter for video */
  
   else
  
     /* TODO: make this more general */
  
     if (audioCodec == AV_CODEC_ID_VORBIS) {
  
       filter_spec = "asetnsamples=n=64";
  
     } else {
  
       /* filter_spec = "null"; /\* passthrough (dummy) filter for audio *\/ */
  
       filter_spec = "fps=24";
  
       /* filter_spec = "settb=expr=1/24"; */
  
     }
  
   ret = init_filter(&amp;filter_ctx[i], ifmt_ctx->streams[i]->codec,
  
             ofmt_ctx->streams[i]->codec, filter_spec);
  
   if (ret)
  
     return ret;
  
     }
  
     return 0;
  
   }
  
  
  
   static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {
  
     int ret;
  
     int got_frame_local;
  
     AVPacket enc_pkt;
  
     int (*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =
  
   (ifmt_ctx->streams[stream_index]->codec->codec_type ==
  
    AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;
  
  
  
     if (!got_frame)
  
   got_frame = &amp;got_frame_local;
  
  
  
     /* av_log(NULL, AV_LOG_INFO, "Encoding frame\n"); */
  
     /* encode filtered frame */
  
     enc_pkt.data = NULL;
  
     enc_pkt.size = 0;
  
     av_init_packet(&amp;enc_pkt);
  
     ret = enc_func(ofmt_ctx->streams[stream_index]->codec, &amp;enc_pkt,
  
            filt_frame, got_frame);
  
     av_frame_free(&amp;filt_frame);
  
     if (ret &lt; 0)
  
   return ret;
  
     if (!(*got_frame))
  
   return 0;
  
  
  
     /* prepare packet for muxing */
  
     enc_pkt.stream_index = stream_index;
  
     enc_pkt.dts = av_rescale_q_rnd(enc_pkt.dts,
  
                    ofmt_ctx->streams[stream_index]->codec->time_base,
  
                    ofmt_ctx->streams[stream_index]->time_base,
  
                    AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
     enc_pkt.pts = av_rescale_q_rnd(enc_pkt.pts,
  
                    ofmt_ctx->streams[stream_index]->codec->time_base,
  
                    ofmt_ctx->streams[stream_index]->time_base,
  
                    AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
     enc_pkt.duration = av_rescale_q(enc_pkt.duration,
  
                     ofmt_ctx->streams[stream_index]->codec->time_base,
  
                     ofmt_ctx->streams[stream_index]->time_base);
  
  
  
     /* av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n"); */
  
     /* mux encoded frame */
  
     ret = av_interleaved_write_frame(ofmt_ctx, &amp;enc_pkt);
  
     return ret;
  
   }
  
  
  
   static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index) {
  
     int ret;
  
     AVFrame *filt_frame;
  
  
  
     /* av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n"); */
  
     /* push the decoded frame into the filtergraph */
  
     ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,
  
                    frame, 0);
  
     if (ret &lt; 0) {
  
   av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
  
   return ret;
  
     }
  
  
  
     /* pull filtered frames from the filtergraph */
  
     while (1) {
  
   filt_frame = av_frame_alloc();
  
   if (!filt_frame) {
  
     ret = AVERROR(ENOMEM);
  
     break;
  
   }
  
   /* av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n"); */
  
   ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,
  
                     filt_frame);
  
   if (ret &lt; 0) {
  
     /* if no more frames for output - returns AVERROR(EAGAIN)
  
      * if flushed and no more frames for output - returns AVERROR_EOF
  
      * rewrite retcode to 0 to show it as normal procedure completion
  
      */
  
     if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  
       ret = 0;
  
     av_frame_free(&amp;filt_frame);
  
     break;
  
   }
  
  
  
   filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
  
   ret = encode_write_frame(filt_frame, stream_index, NULL);
  
   if (ret &lt; 0)
  
     break;
  
     }
  
  
  
     return ret;
  
   }
  
  
  
   static int flush_encoder(unsigned int stream_index) {
  
     int ret;
  
     int got_frame;
  
  
  
     if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities &amp;
  
       CODEC_CAP_DELAY))
  
   return 0;
  
  
  
     while (1) {
  
   av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);
  
   ret = encode_write_frame(NULL, stream_index, &amp;got_frame);
  
   if (ret &lt; 0)
  
     break;
  
   if (!got_frame)
  
     return 0;
  
     }
  
     return ret;
  
   }
  
  
  
   static int transcode() {
  
     int ret;
  
     AVPacket packet = { .data = NULL, .size = 0 };
  
     AVFrame *frame = NULL;
  
     enum AVMediaType type;
  
     unsigned int stream_index;
  
     unsigned int i;
  
     int got_frame;
  
     int (*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
  
  
  
     /* read all packets */
  
     while (1) {
  
   if ((ret = av_read_frame(ifmt_ctx, &amp;packet)) &lt; 0)
  
     break;
  
   stream_index = packet.stream_index;
  
   type = ifmt_ctx->streams[packet.stream_index]->codec->codec_type;
  
   av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
  
      stream_index);
  
  
  
   if (filter_ctx[stream_index].filter_graph) {
  
     av_log(NULL, AV_LOG_DEBUG, "Going to reencode&amp;filter the frame\n");
  
     frame = av_frame_alloc();
  
     if (!frame) {
  
       ret = AVERROR(ENOMEM);
  
       break;
  
     }
  
     packet.dts = av_rescale_q_rnd(packet.dts,
  
                   ifmt_ctx->streams[stream_index]->time_base,
  
                   ifmt_ctx->streams[stream_index]->codec->time_base,
  
                   AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
     packet.pts = av_rescale_q_rnd(packet.pts,
  
                   ifmt_ctx->streams[stream_index]->time_base,
  
                   ifmt_ctx->streams[stream_index]->codec->time_base,
  
                   AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
     dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :
  
       avcodec_decode_audio4;
  
     ret = dec_func(ifmt_ctx->streams[stream_index]->codec, frame,
  
            &amp;got_frame, &amp;packet);
  
     if (ret &lt; 0) {
  
       av_frame_free(&amp;frame);
  
       av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
  
       break;
  
     }
  
  
  
     if (got_frame) {
  
       frame->pts = av_frame_get_best_effort_timestamp(frame);
  
       ret = filter_encode_write_frame(frame, stream_index);
  
       av_frame_free(&amp;frame);
  
       if (ret &lt; 0)
  
         goto end;
  
     } else {
  
       av_frame_free(&amp;frame);
  
     }
  
   } else {
  
     /* remux this frame without reencoding */
  
     packet.dts = av_rescale_q_rnd(packet.dts,
  
                   ifmt_ctx->streams[stream_index]->time_base,
  
                   ofmt_ctx->streams[stream_index]->time_base,
  
                   AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
     packet.pts = av_rescale_q_rnd(packet.pts,
  
                   ifmt_ctx->streams[stream_index]->time_base,
  
                   ofmt_ctx->streams[stream_index]->time_base,
  
                   AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
  
  
     ret = av_interleaved_write_frame(ofmt_ctx, &amp;packet);
  
     if (ret &lt; 0)
  
       goto end;
  
   }
  
   av_free_packet(&amp;packet);
  
     }
  
  
  
     /* flush filters and encoders */
  
     for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
   /* flush filter */
  
   if (!filter_ctx[i].filter_graph)
  
     continue;
  
   ret = filter_encode_write_frame(NULL, i);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");
  
     goto end;
  
   }
  
  
  
   /* flush encoder */
  
   ret = flush_encoder(i);
  
   if (ret &lt; 0) {
  
     av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");
  
     goto end;
  
   }
  
     }
  
  
  
     av_write_trailer(ofmt_ctx);
  
  
  
     // Retrieve and store the first instance of codec statistics
  
     // TODO: less naive, deal with multiple instances of statistics
  
     for (i = 0; i &lt; ofmt_ctx->nb_streams; i++) {
  
   AVCodecContext* codec = ofmt_ctx->streams[i]->codec;
  
   if ((codec->flags &amp; CODEC_FLAG_PASS1) &amp;&amp; (codec->stats_out)){
  
     FILE* logfile = fopen(STATS_LOG, "wb");
  
     fprintf(logfile, "%s", codec->stats_out);
  
     if (fclose(logfile) &lt; 0) {
  
       av_log(NULL, AV_LOG_ERROR, "Error closing log file.\n");
  
     }
  
     break;
  
   }
  
     }
  
  
  
     av_log(NULL, AV_LOG_INFO, "output duration = %" PRId64 "\n", ofmt_ctx->duration);
  
  
  
    end:
  
     av_free_packet(&amp;packet);
  
     av_frame_free(&amp;frame);
  
     for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
   avcodec_close(ifmt_ctx->streams[i]->codec);
  
   if (ofmt_ctx &amp;&amp; ofmt_ctx->nb_streams > i &amp;&amp; ofmt_ctx->streams[i] &amp;&amp; ofmt_ctx->streams[i]->codec)
  
     avcodec_close(ofmt_ctx->streams[i]->codec);
  
   if (filter_ctx &amp;&amp; filter_ctx[i].filter_graph)
  
     avfilter_graph_free(&amp;filter_ctx[i].filter_graph);
  
     }
  
     av_free(filter_ctx);
  
     avformat_close_input(&amp;ifmt_ctx);
  
     if (ofmt_ctx &amp;&amp; !(ofmt_ctx->oformat->flags &amp; AVFMT_NOFILE))
  
   avio_close(ofmt_ctx->pb);
  
     avformat_free_context(ofmt_ctx);
  
  
  
     if (ret &lt; 0)
  
   av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));
  
  
  
     return ret ? 1 : 0;
  
   }
  
  
  
   int TranscodeToWebM(char* inputPath, char* outputPath, int audioBitRate, int crf, int videoMaxBitRate, int threads,
  
           char* quality, int speed) {
  
     int ret;
  
     unsigned int pass;
  
     char* stats = NULL;
  
  
  
     av_register_all();
  
     avfilter_register_all();
  
  
  
     for (pass = 1; pass &lt;= 2; pass++) {
  
   if ((ret = open_input_file(inputPath)) &lt; 0)
  
     goto end;
  
  
  
   if ((ret = init_output_context(outputPath)) &lt; 0)
  
     goto end;
  
  
  
   if (pass == 2) {
  
     size_t stats_length;
  
     if (cmdutils_read_file(STATS_LOG, &amp;stats, &amp;stats_length) &lt; 0) {
  
       av_log(NULL, AV_LOG_ERROR, "Error reading stats file.\n");
  
       break;
  
     }
  
   }
  
  
  
   if ((ret = init_webm_encoders(audioBitRate, crf, videoMaxBitRate, threads, quality, speed, pass, stats)) &lt; 0)
  
     goto end;
  
  
  
   if ((ret = open_output_file(outputPath)) &lt; 0)
  
     goto end;
  
  
  
   if ((ret = init_filters(AV_CODEC_ID_VORBIS)) &lt; 0)
  
     goto end;
  
  
  
   if ((ret = transcode()) &lt; 0)
  
     goto end;
  
     }
  
  
  
     if (remove(STATS_LOG) != 0) {
  
   av_log(NULL, AV_LOG_ERROR, "Failed to remove %s\n", STATS_LOG);
  
     }
  
  
  
    end:
  
     if (ret &lt; 0) {
  
   av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));
  
   return ret;
  
     }
  
  
  
     return 0;
  
   }

  Here is the output from the ffmpeg command I am trying to mimic.

  ffmpeg version N-62301-g59a5384 Copyright (c) 2000-2014 the FFmpeg developers
  
    built on Apr  9 2014 09:58:44 with gcc 4.8.2 (GCC) 20140206 (prerelease)
  
    configuration: --prefix=/opt/ffmpeg --extra-cflags=-I/opt/x264/include --extra-ldflags=-L/opt/x264/lib --extra-libs=-ldl --enable-gpl --enable-nonfree --enable-libfdk-aac --enable-libopus --enable-libvorbis --enable-libvpx --enable-libx264
  
    libavutil      52. 75.100 / 52. 75.100
  
    libavcodec     55. 58.103 / 55. 58.103
  
    libavformat    55. 36.102 / 55. 36.102
  
    libavdevice    55. 11.100 / 55. 11.100
  
    libavfilter     4.  3.100 /  4.  3.100
  
    libswscale      2.  6.100 /  2.  6.100
  
    libswresample   0. 18.100 /  0. 18.100
  
    libpostproc    52.  3.100 / 52.  3.100
  
  Input #0, matroska,webm, from '/mnt/scratch/test_source/Sintel.2010.720p.mkv':
  
    Metadata:
  
  encoder         : libebml v1.0.0 + libmatroska v1.0.0
  
  creation_time   : 2011-04-24 17:20:33
  
    Duration: 00:14:48.03, start: 0.000000, bitrate: 6071 kb/s
  
  Chapter #0.0: start 0.000000, end 103.125000
  
  Metadata:
  
    title           : Chapter 01
  
  Chapter #0.1: start 103.125000, end 148.667000
  
  Metadata:
  
    title           : Chapter 02
  
  Chapter #0.2: start 148.667000, end 349.792000
  
  Metadata:
  
    title           : Chapter 03
  
  Chapter #0.3: start 349.792000, end 437.208000
  
  Metadata:
  
    title           : Chapter 04
  
  Chapter #0.4: start 437.208000, end 472.075000
  
  Metadata:
  
    title           : Chapter 05
  
  Chapter #0.5: start 472.075000, end 678.833000
  
  Metadata:
  
    title           : Chapter 06
  
  Chapter #0.6: start 678.833000, end 744.083000
  
  Metadata:
  
    title           : Chapter 07
  
  Chapter #0.7: start 744.083000, end 888.032000
  
  Metadata:
  
    title           : Chapter 08
  
  Stream #0:0(eng): Video: h264 (High), yuv420p(tv, bt709), 1280x544, SAR 1:1 DAR 40:17, 24 fps, 24 tbr, 1k tbn, 48 tbc
  
  Stream #0:1(eng): Audio: ac3, 48000 Hz, 5.1(side), fltp, 640 kb/s
  
  Metadata:
  
    title           : AC3 5.1 @ 640 Kbps
  
  Stream #0:2(ger): Subtitle: subrip
  
  Stream #0:3(eng): Subtitle: subrip
  
  Stream #0:4(spa): Subtitle: subrip
  
  Stream #0:5(fre): Subtitle: subrip
  
  Stream #0:6(ita): Subtitle: subrip
  
  Stream #0:7(dut): Subtitle: subrip
  
  Stream #0:8(pol): Subtitle: subrip
  
  Stream #0:9(por): Subtitle: subrip
  
  Stream #0:10(rus): Subtitle: subrip
  
  Stream #0:11(vie): Subtitle: subrip
  
  [libvpx @ 0x24b74c0] v1.3.0
  
  Output #0, webm, to '/mnt/scratch/test_out/Sintel.2010.720p.script.webm':
  
    Metadata:
  
  encoder         : Lavf55.36.102
  
  Chapter #0.0: start 0.000000, end 103.125000
  
  Metadata:
  
    title           : Chapter 01
  
  Chapter #0.1: start 103.125000, end 148.667000
  
  Metadata:
  
    title           : Chapter 02
  
  Chapter #0.2: start 148.667000, end 349.792000
  
  Metadata:
  
    title           : Chapter 03
  
  Chapter #0.3: start 349.792000, end 437.208000
  
  Metadata:
  
    title           : Chapter 04
  
  Chapter #0.4: start 437.208000, end 472.075000
  
  Metadata:
  
    title           : Chapter 05
  
  Chapter #0.5: start 472.075000, end 678.833000
  
  Metadata:
  
    title           : Chapter 06
  
  Chapter #0.6: start 678.833000, end 744.083000
  
  Metadata:
  
    title           : Chapter 07
  
  Chapter #0.7: start 744.083000, end 888.032000
  
  Metadata:
  
    title           : Chapter 08
  
  Stream #0:0(eng): Video: vp8 (libvpx), yuv420p, 1280x544 [SAR 1:1 DAR 40:17], q=-1--1, pass 2, 60000 kb/s, 1k tbn, 24 tbc
  
  Stream #0:1(eng): Audio: vorbis (libvorbis), 48000 Hz, 5.1(side), fltp, 384 kb/s
  
  Metadata:
  
    title           : AC3 5.1 @ 640 Kbps
  
  Stream mapping:
  
    Stream #0:0 -> #0:0 (h264 -> libvpx)
  
    Stream #0:1 -> #0:1 (ac3 -> libvorbis)
  
  Press [q] to stop, [?] for help
  
  frame=21312 fps= 11 q=0.0 Lsize=  567191kB time=00:14:48.01 bitrate=5232.4kbits/s    
  
  video:537377kB audio:29266kB subtitle:0kB other streams:0kB global headers:7kB muxing overhead: 0.096885%

• Nexus One

  19 mars 2010, par Mans — Uncategorized

  I have had a Nexus One for about a week (thanks Google), and naturally I have an opinion or two about it.
  

  Hardware

  With the front side dominated by a touch-screen and a lone, round button, the Nexus One appearance is similar to that of most contemporary smartphones. The reverse sports a 5 megapixel camera with LED flash, a Google logo, and a smaller HTC logo. Power button, volume control, and headphone and micro-USB sockets are found along the edges. It is with appreciation I note the lack of a front-facing camera ; the silly idea of video calls is finally put to rest.

  Powering up the phone (I’m beginning to question the applicability of that word), I am immediately enamoured with the display. At 800×480 pixels, the AMOLED display is crystal-clear and easily viewable even in bright light. In a darker environment, the display automatically dims. The display does have one quirk in that the subpixel pattern doesn’t actually have a full RGB triplet for each pixel. The close-up photo below shows the pattern seen when displaying a solid white colour.

  

  The result of this is that fine vertical lines, particularly red or blue ones, look a bit jagged. Most of the time this is not much of a problem, and I find it an acceptable compromise for the higher effective resolution it provides.

  Basic interaction

  The Android system is by now familiar, and the Nexus offers no surprises in basic usage. All the usual applications come pre-installed : browser, email, calendar, contacts, maps, and even voice calls. Many of the applications integrate with a Google account, which is nice. Calendar entries, map placemarks, etc. are automatically shared between desktop and mobile. Gone is the need for the bug-ridden custom synchronisation software with which mobile phones of the past were plagued.

  Launching applications is mostly speedy, and recently used apps are kept loaded as long as memory needs allow. Although this garbage-collection-style of application management, where you are never quite sure whether an app is still running, takes a few moments of acclimatisation, it works reasonably well in day to day use. Most of the applications are well-behaved and save their data before terminating.

  Email

  Two email applications are included out of the box : one generic and one Gmail-only. As I do not use Gmail, I cannot comment on this application. The generic email client supports IMAP, but is rather limited in functionality. Fortunately, a much-enhanced version, K-9, is available for download. The main feature I find lacking here is threaded message view.

  The features, or lack thereof, in the email applications is not, however, of huge importance, as composing email, or any longer piece of text, is something one rather avoids on a system like this. The on-screen keyboard, while falling among the better of its kind, is still slow to use. Lack of tactile feedback means accidentally tapping the wrong key is easily done, and entering numbers or punctuation is an outright chore.

  Browser

  Whatever the Nexus lacks in email abilities, it makes up for with the browser. Surfing the web on a phone has never been this pleasant. Page rendering is quick, and zooming is fast and simple. Even pages not designed for mobile viewing are easy to read with smart reformatting almost entirely eliminating the sideways scrolling which hampered many a mobile browser of old.

  Calls and messaging

  Being a phone, the Nexus One is obviously able to make and receive calls, and it does so with ease. Entering a number or locating a stored contact are both straight-forward operations. During a call, audio is clear and of adequate loudness, although I have yet to use the phone in really noisy surroundings.

  The other traditional task of a mobile phone, messaging, is also well-supported. There isn’t really much to say about this.

  Multimedia

  Having a bit of an interest in most things multimedia, I obviously tested the capabilities of the Nexus by throwing some assorted samples at it, revealing ample space for improvement. With video limited to H.264 and MPEG4, and the only supported audio codecs being AAC, MP3, Vorbis, and AMR, there are many files which will not play.

  To make matters worse, only selected combinations of audio and video will play together. Several video files I tested played without sound, yet when presented with the very same audio data alone, it was correctly decoded. As for container formats, it appears restricted to MP4/MOV, and Ogg (for Vorbis). AVI files are recognised as media files, but I was unable to find an AVI file which would play.

  With a device clearly capable of so much more, the poor multimedia support is nothing short of embarrassing.

  The Market

  Much of the hype surrounding Android revolves around the Market, Google’s virtual marketplace for app authors to sell or give away their creations. The thousands of available applications are broadly categorised, and a search function is available.

  The categorised lists are divided into free and paid sections, while search results, disappointingly, are not. To aid the decision, ratings and comments are displayed alongside the summary and screenshots of each application. Overall, the process of finding and installing an application is mostly painless. While it could certainly be improved, it could also have been much worse.

  The applications themselves are, as hinted above, beyond numerous. Sadly, quality does not quite match up to quantity. The vast majority of the apps are pointless, though occasionally mildly amusing, gimmicks of no practical value. The really good ones, and they do exist, are very hard to find unless one knows precisely what to look for.

  Battery

  Packing great performance into a pocket-size device comes with a price in battery life. The battery in the Nexus lasts considerably shorter time than that in my older, less feature-packed Nokia phone. To some extent this is probably a result of me actually using it a lot more, yet the end result is the same : more frequent recharging. I should probably get used to the idea of recharging the phone every other night.

  Verdict

  The Nexus One is a capable hardware platform running an OS with plenty of potential. The applications are still somewhat lacking (or very hard to find), although the basic features work reasonably well. Hopefully future Android updates will see more and better core applications integrated, and I imagine that over time, I will find third-party apps to solve my problems in a way I like. I am not putting this phone on the shelf just yet.

• 7 Best Marketing Attribution Software in 2024

  22 février 2024, par Erin

  It can be hard to accurately track the impact of your marketing efforts across marketing channels and campaigns. That’s where marketing attribution software comes in. 

  It goes beyond basic web analytics solutions that just look at the final click. Instead, it shows how different channels, content, and ads are performing at every step of the buyer’s journey, which gives a more accurate picture than just focusing on the last click.

  In this guide, we’ll cover the basics of marketing attribution, list the top marketing attribution software and explain how the issue of privacy is transforming the web analytics industry.

  What is marketing attribution ?

  Marketing attribution is the process of assigning credit to each touchpoint in a buyer’s journey that leads to a desired action (such as a conversion or sale) in order to understand the effectiveness of various marketing channels and campaigns in influencing the customer’s decision-making process.

  Marketers use software tools like website analytics to to track and analyse customer interactions across different touchpoints, allowing them to attribute conversions or sales to specific marketing efforts and optimise their strategies and budgets accordingly.

  Why is marketing attribution so important ?

  If you don’t track your campaigns correctly, it’s easy to spend thousands (or even millions) in an ineffective way. A 2022 survey by Australian marketing agency Next&Co revealed their clients wasted AU$5.46 billion in ineffective ad spend.

  

  That’s 41% of all the ad spend tracked by Next&Co in 2022. A wasted marketing spend percentage this high isn’t exactly a recipe for a high marketing return on investment (ROI). And yet, it’s the average.

  Why is that ? 

  Most companies don’t actively track the results of their marketing campaigns actively enough.

  By improving your marketing attribution, you can determine which channels, ads, and campaigns work and which don’t. Then, you can move the budget from ineffective channels to effective ones.

  Even if you can only identify half of your wastage, this could be 20% or more of your total spend. Just imagine what your bottom line would look like if your marketing budget were 20% more effective.

  That’s the power that marketing attribution, when done right, brings to the table. It’s the road to a higher marketing ROI.

  Common marketing attribution models and how they’re different 

  The default model for attributing completed goals in most analytics tools is either the last interaction or the last non-direct interaction.

  However, some multi-touch models can help you get a more holistic view of the impact of your marketing efforts.

  

  • Last interaction model : attributes the conversion to the final interaction or referring source (campaign or ad).
  • Last non-direct interaction model : attributes the conversion to the final touchpoint that was not a direct visit to your website. (For example, if a search ad took them to a product page, the user bookmarked it and returned directly the next day to finish the purchase. The credit would go to the search ad as it’s the last non-direct touchpoint.)
  • First interaction model : attributes the conversion to the first referring event alone.
  • Linear model : gives equal value to every touchpoint throughout the customer journey. 
  • Time decay model : gives more value to touchpoints the closer they were to the actual sale.
  • Position-based model : gives more value to the first and last touchpoints — often 40% each, while splitting 20% among the rest.

  You can read our guide dedicated to marketing attribution models for more details on these models.

  Types of marketing attribution software and the impact of privacy regulations

  Until recently, digital advertising was the “scientific” advertisers’ utopia. Everything could be measured, with cookies from giants like Google and Facebook stalking every user across the web.

  But with the advent of regulations like GDPR and the CCPA, you can no longer blindly trust Google Analytics or the Meta Pixel without consequences.

  Multi-channel attribution tools with third-party cookies and GDPR

  Google, Meta, and other companies used to track and combine user data from their own platforms and websites across the web that installed their tags. These third-party cookies have long been under fire and have caused several GDPR fines.

  

  The alternative : analytics platforms with first-party cookies

  In a post-GDPR digital marketing landscape, a compliant-by-default web analytics platform like Matomo is a more reliable and accurate alternative.

  Plus, with a platform like Matomo, you don’t need to rely on data from digital advertising platforms like Facebook Ads and Google Ads. You can accurately track referral sources using our campaign tracking parameters.

  7 best marketing attribution software in 2024

  Below is the list of our favourite marketing attribution tools in 2024. If you find and use one that suits your needs correctly, you can quickly boost your marketing performance.

  1. Matomo — Accurate and easiest to set up for marketing attribution

  Matomo is a privacy-friendly web analytics suite that empowers you to accurately attribute marketing efforts and gain valuable insights while prioritising user privacy and compliance.

  Matomo integrates with e-commerce platforms like WooCommerce and Magenta. That makes it easy for B2C marketing teams to track the revenue impact of their campaigns.

  

  You can also compare a variety of attribution models against each other. B2B teams can use our API to integrate Matomo with their CRM.

  Pros :

  • Relies on first-party cookies for tracking, ensuring accurate data collection and attribution of user actions
  • Includes additional features like Heatmaps, Session Recordings, Form Analytics, A/B Testing, and more
  • Easy to set up and use
  • Features most common multi-touch attribution models

  Cons :

  • Limited to owned channels (website and e-commerce store) due to first-party cookies and data (but you can integrate other data sources through a CRM)

  Pricing

  The self-hosted version is free. The cloud hosted version starts at $19 per month and includes a 21-day free trial. No credit card requierd. 

  Try Matomo for Free

  Get the web insights you need, without compromising data accuracy.

  Start for free

  No credit card required

  2. WhatConverts — Great option for leads-based businesses with high ad spend

  WhatConverts is a marketing attribution tool with a focus on lead tracking. With most web analytics setups, it adds call and text tracking to the typical form-only tracking.

  

  Pros :

  • Reliable call and text tracking
  • Revenue attribution to specific leads (and, by extension, campaigns and ads)

  Cons :

  • Focused exclusively on leads — little utility for e-commerce companies 

  Pricing

  The cheapest plan starts at $30/month but does not include analytics integrations or form tracking. To access this and advanced flow tracking and attribution features, you need the Elite plan, which starts at $160/month.

  3. HubSpot Marketing Hub — Ideal CRM for larger B2B companies

  HubSpot is a marketing CRM with attribution features for tracking and analysis.

  

  The platform is very broad — encompassing CRM, email automation and other tools — which makes it challenging to use effectively. The price tag is also quite steep for smaller companies and marketing teams.

  Pros :

  • Concretely tracks revenue to multiple different touchpoints and marketing channels
  • Includes several different multi-touch attribution models
  • Allows offline conversion tracking

  Cons :

  • The price point is too high for smaller teams
  • Cam be difficult to set up effectively

  Pricing

  Since marketing attribution is only included in HubSpot Marketing Hub’s Professional and Enterprise plans, pricing starts at $800/month (paid annually). If you commit for a year but pay monthly, the price is $890/month for the professional plan. This goes up with additional add-ons and as your contacts increase as well. 

  4. ActiveCampaign — Good CRM option for small B2B companies

  ActiveCampaign is a CRM and marketing automation platform that can help you trace leads and revenue back to their source.

  

  Although it has a similar scope of features to HubSpot, it is more affordable and slightly easier to use for beginners.

  Pros :

  • Tracks sales revenue back to specific marketing touchpoints
  • Powerful marketing automation features

  Cons :

  • B2B companies may need to purchase two plans, one ActiveCampaign marketing and one CRM.

  Pricing

  Unlike HubSpot, ActiveCampaign offers a much more affordable plan, starting at $29/month billed annually (for up to 1,000 contacts). The marketing and sales CRM bundle starts at $93/month with up to five users.

  5. Salesforce Data Cloud for Marketing — Ideal CRM for enterprises

  Salesforce is a robust and feature-rich CRM that many enterprises rely on for their sales teams.

  

  That makes Salesforce’s marketing attribution platform a logical choice for existing Salesforce users.

  Pros :

  • Uses prospect and sales data from CRM to attribute revenue
  • Revenue prediction analytics
  • Lead scoring to help your sales team focus on high-value leads

  Cons :

  • Difficult to set up and use
  • Clunky and aged user interface
  • Relatively high price point

  Pricing

  The limited Marketing Cloud Account Engagement Growth plan starts at $1,250/month, billed annually. To access advanced cross-channel journeys, you need the Pro plan, which starts at $2,750 monthly.

  6. Terminus — Great for account-based marketing

  If your marketing team uses an account-based marketing (ABM) approach, Terminus might be the right option for you.

  

  It offers ABM tools like target account event tracking and revenue attribution tools for your marketing campaigns.

  Pros :

  • Advanced multi-channel revenue attribution tools with a wide range of reports
  • Track intent touchpoints back to target accounts
  • Reliable revenue predictions help you focus your marketing activities

  Cons :

  • Complex and difficult to set up, understand and use effectively
  • Lacks native integrations with many common advertising platforms and analytics tools

  Pricing

  Terminus offers no standard pricing plans. You must contact their sales team for a custom quote based on your needs.

  7. Adobe Analytics — An analytics for enterprises

  Adobe Analytics is part of the Adobe Experience Cloud, with plenty of big data analysis tools for enterprises. Although the platform is quite powerful, it is equally complex and difficult to use. The price point is also prohibitive for many smaller companies.

  

  Pros :

  • Very extensive reporting tools
  • Predictive analytics give you solid leading indicator for future campaign performance
  • Track multiple digital touchpoints across the entire customer journey

  Cons :

  • Like Google Analytics, Adobe Analytics aggregates your visitor data by default, making compliant “consent-free tracking” — tracking user actions without asking for consent — impossible according to GDPR. (See more differences in Matomo’s comparison against Adobe Analytics and Google Analytics.)
  • Prohibitively expensive for most smaller companies
  • Very steep learning curve for setting up and using it correctly

  Pricing

  Adobe Analytics uses usage-based pricing — which means they adjust the pricing based on the traffic volume to your website. Still, their lower price points aren’t exactly SMB-friendly — multiple sources put Adobe’s lowest starting price point at $2,000–2,500 per month.

  Get accurate marketing attribution with Matomo (without privacy concerns)

  Matomo allows you to do marketing attribution effectively and accurately without compromising your users’ privacy. By default, we only use first-party cookies and offer consent-free tracking – meaning no more annoying cookie consent banners (excluding in Germany and the UK).

  If you want to boost your marketing performance without disregarding your users’ privacy, get started with our 21-day free trial. No credit card required. It’s time to make more informed decisions about your marketing campaigns.

  Try Matomo for Free

  21 day free trial. No credit card required.

  
  

  Your email address
  

  Your website address
  

  Your Analytics subdomain will be .matomo.cloud (change)

  Choose your analytics subdomain
  

  .matomo.cloud

  I accept the terms and conditions and data processing agreement (DPA)

  
  Your information will be used to create an account on our cloud service. For more information please consult our privacy policy.
  
  
  

  Start improving your websites now