Recherche avancée

Sur d’autres sites (10394)

• Xubuntu ffmpeg screen capturing very slow when no display connected

  8 décembre 2022, par fre_der

  I use ffmpeg on an Intel Nuc with Xubuntu 22.04 (XFCE4, lightdm), with x11grab for screen capturing the desktop, and sending output to a multicast UDP stream (which is shown on different IPTV sets in the network).
The system uses autologin, and autostarts Firefox in kiosk mode, rendering a html5 video.

  


  Everything works fine when a display is attached, but from the moment the hdmi cable is detached, the output video is extremely slow (very shaky, looks like 1 fps, audio is OK although it has occasional hickups).

  


  CPU and memory usage doesn't seem to be affected whether a display is attached or not.

  


  This runs fine on Xubuntu 18.04, although there might be small config changes that I'm not aware of.

  


  To be able to display output when no display is attached, I created a VIRTUAL1 display :

  


  xrandr -d :0 --verbose --newmode "1920x1080_60.00"  173.00  1920 2048 2248 2576  1080 1083 1088 1120 -hsync +vsync
xrandr -d :0 --verbose --addmode VIRTUAL1 "1920x1080_60.00"


  


  my /usr/share/X11/xorg.conf.d/20-intel.conf looks like :

  


  Section "Device"
  Identifier "Intel Graphics"
  Driver "intel"
  Option "VirtualHeads" "1"
  Option "TearFree" "true"
  Option "TripleBuffer" "true"
  Option "DRI" "false"
EndSection


  


  The ffmpeg command :

  


  ffmpeg -r 25 -thread_queue_size 512 -f x11grab -s 1920x1080 -i :0 -thread_queue_size 512 -f alsa -i default -c:a mp2 -f mpegts udp://239.255.255.8:50000?pkt_size=1316


  


  (during trial/error I tested various ffmpeg command line options to no avail)

  


  Output with hdmi cable attached :

  


  ffmpeg version 4.4.2-0ubuntu0.22.04.1 Copyright (c) 2000-2021 the FFmpeg developers
  built with gcc 11 (Ubuntu 11.2.0-19ubuntu1)
  configuration: --prefix=/usr --extra-version=0ubuntu0.22.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --arch=amd64 --enable-gpl --disable-stripping --enable-gnutls --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libcodec2 --enable-libdav1d --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libjack --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librabbitmq --enable-librubberband --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-libzvbi --enable-lv2 --enable-omx --enable-openal --enable-opencl --enable-opengl --enable-sdl2 --enable-pocketsphinx --enable-librsvg --enable-libmfx --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libx264 --enable-shared
  WARNING: library configuration mismatch
  avcodec     configuration: --prefix=/usr --extra-version=0ubuntu0.22.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --arch=amd64 --enable-gpl --disable-stripping --enable-gnutls --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libcodec2 --enable-libdav1d --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libjack --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librabbitmq --enable-librubberband --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-libzvbi --enable-lv2 --enable-omx --enable-openal --enable-opencl --enable-opengl --enable-sdl2 --enable-pocketsphinx --enable-librsvg --enable-libmfx --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libx264 --enable-shared --enable-version3 --disable-doc --disable-programs --enable-libaribb24 --enable-libopencore_amrnb --enable-libopencore_amrwb --enable-libtesseract --enable-libvo_amrwbenc --enable-libsmbclient
  libavutil      56. 70.100 / 56. 70.100
  libavcodec     58.134.100 / 58.134.100
  libavformat    58. 76.100 / 58. 76.100
  libavdevice    58. 13.100 / 58. 13.100
  libavfilter     7.110.100 /  7.110.100
  libswscale      5.  9.100 /  5.  9.100
  libswresample   3.  9.100 /  3.  9.100
  libpostproc    55.  9.100 / 55.  9.100
[x11grab @ 0x55f1fdfa18c0] Stream #0: not enough frames to estimate rate; consider increasing probesize
Input #0, x11grab, from ':0':
  Duration: N/A, start: 1670501458.257764, bitrate: 1658880 kb/s
  Stream #0:0: Video: rawvideo (BGR[0] / 0x524742), bgr0, 1920x1080, 1658880 kb/s, 25 fps, 1000k tbr, 1000k tbn, 1000k tbc
Guessed Channel Layout for Input Stream #1.0 : stereo
Input #1, alsa, from 'default':
  Duration: N/A, start: 1670501459.560180, bitrate: 1536 kb/s
  Stream #1:0: Audio: pcm_s16le, 48000 Hz, stereo, s16, 1536 kb/s
Stream mapping:
  Stream #0:0 -> #0:0 (rawvideo (native) -> mpeg2video (native))
  Stream #1:0 -> #0:1 (pcm_s16le (native) -> mp2 (native))
Press [q] to stop, [?] for help
Output #0, mpegts, to 'udp://239.255.255.8:50000?pkt_size=1316':
  Metadata:
    encoder         : Lavf58.76.100
  Stream #0:0: Video: mpeg2video (Main), yuv420p(tv, progressive), 1920x1080, q=2-31, 200 kb/s, 25 fps, 90k tbn
    Metadata:
      encoder         : Lavc58.134.100 mpeg2video
    Side data:
      cpb: bitrate max/min/avg: 0/0/200000 buffer size: 0 vbv_delay: N/A
  Stream #0:1: Audio: mp2, 48000 Hz, stereo, s16, 384 kb/s
    Metadata:
      encoder         : Lavc58.134.100 mp2
frame= 1041 fps= 25 q=31.0 Lsize=   12451kB time=00:00:41.56 bitrate=2454.3kbits/s speed=1.01x
video:9955kB audio:1920kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 4.847125%
Exiting normally, received signal 2.


  


  Output without hdmi cable attached :

  


  ffmpeg version 4.4.2-0ubuntu0.22.04.1 Copyright (c) 2000-2021 the FFmpeg developers
  built with gcc 11 (Ubuntu 11.2.0-19ubuntu1)
  configuration: --prefix=/usr --extra-version=0ubuntu0.22.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --arch=amd64 --enable-gpl --disable-stripping --enable-gnutls --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libcodec2 --enable-libdav1d --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libjack --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librabbitmq --enable-librubberband --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-libzvbi --enable-lv2 --enable-omx --enable-openal --enable-opencl --enable-opengl --enable-sdl2 --enable-pocketsphinx --enable-librsvg --enable-libmfx --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libx264 --enable-shared
  WARNING: library configuration mismatch
  avcodec     configuration: --prefix=/usr --extra-version=0ubuntu0.22.04.1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --arch=amd64 --enable-gpl --disable-stripping --enable-gnutls --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libcodec2 --enable-libdav1d --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libjack --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librabbitmq --enable-librubberband --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzimg --enable-libzmq --enable-libzvbi --enable-lv2 --enable-omx --enable-openal --enable-opencl --enable-opengl --enable-sdl2 --enable-pocketsphinx --enable-librsvg --enable-libmfx --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-chromaprint --enable-frei0r --enable-libx264 --enable-shared --enable-version3 --disable-doc --disable-programs --enable-libaribb24 --enable-libopencore_amrnb --enable-libopencore_amrwb --enable-libtesseract --enable-libvo_amrwbenc --enable-libsmbclient
  libavutil      56. 70.100 / 56. 70.100
  libavcodec     58.134.100 / 58.134.100
  libavformat    58. 76.100 / 58. 76.100
  libavdevice    58. 13.100 / 58. 13.100
  libavfilter     7.110.100 /  7.110.100
  libswscale      5.  9.100 /  5.  9.100
  libswresample   3.  9.100 /  3.  9.100
  libpostproc    55.  9.100 / 55.  9.100
[x11grab @ 0x56325816a8c0] Stream #0: not enough frames to estimate rate; consider increasing probesize
Input #0, x11grab, from ':0':
  Duration: N/A, start: 1670501334.907900, bitrate: 1658880 kb/s
  Stream #0:0: Video: rawvideo (BGR[0] / 0x524742), bgr0, 1920x1080, 1658880 kb/s, 25 fps, 1000k tbr, 1000k tbn, 1000k tbc
Guessed Channel Layout for Input Stream #1.0 : stereo
Input #1, alsa, from 'default':
  Duration: N/A, start: 1670501336.193971, bitrate: 1536 kb/s
  Stream #1:0: Audio: pcm_s16le, 48000 Hz, stereo, s16, 1536 kb/s
Stream mapping:
  Stream #0:0 -> #0:0 (rawvideo (native) -> mpeg2video (native))
  Stream #1:0 -> #0:1 (pcm_s16le (native) -> mp2 (native))
Press [q] to stop, [?] for help
Output #0, mpegts, to 'udp://239.255.255.8:50000?pkt_size=1316':
  Metadata:
    encoder         : Lavf58.76.100
  Stream #0:0: Video: mpeg2video (Main), yuv420p(tv, progressive), 1920x1080, q=2-31, 200 kb/s, 25 fps, 90k tbn
    Metadata:
      encoder         : Lavc58.134.100 mpeg2video
    Side data:
      cpb: bitrate max/min/avg: 0/0/200000 buffer size: 0 vbv_delay: N/A
  Stream #0:1: Audio: mp2, 48000 Hz, stereo, s16, 384 kb/s
    Metadata:
      encoder         : Lavc58.134.100 mp2
frame= 1020 fps= 26 q=31.0 Lsize=   11802kB time=00:00:40.72 bitrate=2374.3kbits/s speed=1.02x
video:9378kB audio:1873kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: 4.892235%
Exiting normally, received signal 2.


  


  xrandr output with display connected (if no display connected then DP1 just says disconnected as the other outputs)

  


  Screen 0: minimum 8 x 8, current 1920 x 1080, maximum 32767 x 32767
DP1 connected 1920x1080+0+0 (normal left inverted right x axis y axis) 530mm x 300mm
   1920x1080     60.00*+  74.97    50.00    59.94
   1920x1080i    60.00    50.00    59.94
   1680x1050     59.88
   1280x1024     75.02    60.02
   1440x900      59.90
   1280x960      60.00
   1280x720      60.00    50.00    59.94
   1024x768      75.03    70.07    60.00
   832x624       74.55
   800x600       72.19    75.00    60.32    56.25
   720x576       50.00
   720x480       60.00    59.94
   640x480       75.00    72.81    66.67    60.00    59.94
   720x400       70.08
DP2 disconnected (normal left inverted right x axis y axis)
DP3 disconnected (normal left inverted right x axis y axis)
DP4 disconnected (normal left inverted right x axis y axis)
HDMI1 disconnected (normal left inverted right x axis y axis)
VIRTUAL1 connected 1920x1080+0+0 (normal left inverted right x axis y axis) 0mm x 0mm
   1920x1080_60.00  59.96*
VIRTUAL2 disconnected (normal left inverted right x axis y axis)


  


• How to catch stdout stream in ffmpeg then pipe it to v4l2loopback

  29 août 2015, par Tveitan

  I’m trying to pipe my h264 stream to ffmpeg and then to my v4l2loopback device. Problem is that I’m fairly new to linux, so just can’t get it working.
  The stream can be outputted to stdout, but I do not know how to catch it again with ffmpeg and then again pipe it to my v4l2loopback device.

  Does anybody know how this could be done or maybe a pointer on how to solve it ?

  This is the capture program :

  PS ! You can find the options for the capture program almost in the bottom of the code.

  /*
  
   *  V4L2 video capture example, modified by Derek Molloy for the Logitech C920 camera
  
   *  Modifications, added the -F mode for H264 capture and associated help detail
  
   *  www.derekmolloy.ie
  
   *
  
   *  V4L2 video capture example
  
   *
  
   *  This program can be used and distributed without restrictions.
  
   *
  
   *      This program is provided with the V4L2 API
  
   * see http://linuxtv.org/docs.php for more information
  
   */
  
  
  
  #include 
  
  #include 
  
  #include 
  
  #include 
  
  
  
  #include              /* getopt_long() */
  
  
  
  #include               /* low-level i/o */
  
  #include 
  
  #include 
  
  #include <sys></sys>stat.h>
  
  #include <sys></sys>types.h>
  
  #include <sys></sys>time.h>
  
  #include <sys></sys>mman.h>
  
  #include <sys></sys>ioctl.h>
  
  
  
  #include <linux></linux>videodev2.h>
  
  
  
  #define CLEAR(x) memset(&amp;(x), 0, sizeof(x))
  
  
  
  enum io_method {
  
          IO_METHOD_READ,
  
          IO_METHOD_MMAP,
  
          IO_METHOD_USERPTR,
  
  };
  
  
  
  struct buffer {
  
          void   *start;
  
          size_t  length;
  
  };
  
  
  
  static char            *dev_name;
  
  static enum io_method   io = IO_METHOD_MMAP;
  
  static int              fd = -1;
  
  struct buffer          *buffers;
  
  static unsigned int     n_buffers;
  
  static int              out_buf;
  
  static int              force_format = 0;
  
  static int              frame_count = 100;
  
  
  
  static void errno_exit(const char *s)
  
  {
  
          fprintf(stderr, "%s error %d, %s\n", s, errno, strerror(errno));
  
          exit(EXIT_FAILURE);
  
  }
  
  
  
  static int xioctl(int fh, int request, void *arg)
  
  {
  
          int r;
  
  
  
          do {
  
                  r = ioctl(fh, request, arg);
  
          } while (-1 == r &amp;&amp; EINTR == errno);
  
  
  
          return r;
  
  }
  
  
  
  static void process_image(const void *p, int size)
  
  {
  
          if (out_buf)
  
                  fwrite(p, size, 1, stdout);
  
  
  
          fflush(stderr);
  
          fprintf(stderr, ".");
  
          fflush(stdout);
  
  }
  
  
  
  static int read_frame(void)
  
  {
  
          struct v4l2_buffer buf;
  
          unsigned int i;
  
  
  
          switch (io) {
  
          case IO_METHOD_READ:
  
                  if (-1 == read(fd, buffers[0].start, buffers[0].length)) {
  
                          switch (errno) {
  
                          case EAGAIN:
  
                                  return 0;
  
  
  
                          case EIO:
  
                                  /* Could ignore EIO, see spec. */
  
  
  
                                  /* fall through */
  
  
  
                          default:
  
                                  errno_exit("read");
  
                          }
  
                  }
  
  
  
                  process_image(buffers[0].start, buffers[0].length);
  
                  break;
  
  
  
          case IO_METHOD_MMAP:
  
                  CLEAR(buf);
  
  
  
                  buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                  buf.memory = V4L2_MEMORY_MMAP;
  
  
  
                  if (-1 == xioctl(fd, VIDIOC_DQBUF, &amp;buf)) {
  
                          switch (errno) {
  
                          case EAGAIN:
  
                                  return 0;
  
  
  
                          case EIO:
  
                                  /* Could ignore EIO, see spec. */
  
  
  
                                  /* fall through */
  
  
  
                          default:
  
                                  errno_exit("VIDIOC_DQBUF");
  
                          }
  
                  }
  
  
  
                  assert(buf.index &lt; n_buffers);
  
  
  
                  process_image(buffers[buf.index].start, buf.bytesused);
  
  
  
                  if (-1 == xioctl(fd, VIDIOC_QBUF, &amp;buf))
  
                          errno_exit("VIDIOC_QBUF");
  
                  break;
  
  
  
          case IO_METHOD_USERPTR:
  
                  CLEAR(buf);
  
  
  
                  buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                  buf.memory = V4L2_MEMORY_USERPTR;
  
  
  
                  if (-1 == xioctl(fd, VIDIOC_DQBUF, &amp;buf)) {
  
                          switch (errno) {
  
                          case EAGAIN:
  
                                  return 0;
  
  
  
                          case EIO:
  
                                  /* Could ignore EIO, see spec. */
  
  
  
                                  /* fall through */
  
  
  
                          default:
  
                                  errno_exit("VIDIOC_DQBUF");
  
                          }
  
                  }
  
  
  
                  for (i = 0; i &lt; n_buffers; ++i)
  
                          if (buf.m.userptr == (unsigned long)buffers[i].start
  
                              &amp;&amp; buf.length == buffers[i].length)
  
                                  break;
  
  
  
                  assert(i &lt; n_buffers);
  
  
  
                  process_image((void *)buf.m.userptr, buf.bytesused);
  
  
  
                  if (-1 == xioctl(fd, VIDIOC_QBUF, &amp;buf))
  
                          errno_exit("VIDIOC_QBUF");
  
                  break;
  
          }
  
  
  
          return 1;
  
  }
  
  
  
  static void mainloop(void)
  
  {
  
          unsigned int count;
  
      unsigned int loopIsInfinite = 0;
  
  
  
          if (frame_count == 0) loopIsInfinite = 1; //infinite loop
  
      count = frame_count;
  
  
  
          while ((count-- > 0) || loopIsInfinite) {
  
                  for (;;) {
  
                          fd_set fds;
  
                          struct timeval tv;
  
                          int r;
  
  
  
                          FD_ZERO(&amp;fds);
  
                          FD_SET(fd, &amp;fds);
  
  
  
                          /* Timeout. */
  
                          tv.tv_sec = 2;
  
                          tv.tv_usec = 0;
  
  
  
                          r = select(fd + 1, &amp;fds, NULL, NULL, &amp;tv);
  
  
  
                          if (-1 == r) {
  
                                  if (EINTR == errno)
  
                                          continue;
  
                                  errno_exit("select");
  
                          }
  
  
  
                          if (0 == r) {
  
                                  fprintf(stderr, "select timeout\n");
  
                                  exit(EXIT_FAILURE);
  
                          }
  
  
  
                          if (read_frame())
  
                                  break;
  
                          /* EAGAIN - continue select loop. */
  
                  }
  
          }
  
  }
  
  
  
  static void stop_capturing(void)
  
  {
  
          enum v4l2_buf_type type;
  
  
  
          switch (io) {
  
          case IO_METHOD_READ:
  
                  /* Nothing to do. */
  
                  break;
  
  
  
          case IO_METHOD_MMAP:
  
          case IO_METHOD_USERPTR:
  
                  type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                  if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &amp;type))
  
                          errno_exit("VIDIOC_STREAMOFF");
  
                  break;
  
          }
  
  }
  
  
  
  static void start_capturing(void)
  
  {
  
          unsigned int i;
  
          enum v4l2_buf_type type;
  
  
  
          switch (io) {
  
          case IO_METHOD_READ:
  
                  /* Nothing to do. */
  
                  break;
  
  
  
          case IO_METHOD_MMAP:
  
                  for (i = 0; i &lt; n_buffers; ++i) {
  
                          struct v4l2_buffer buf;
  
  
  
                          CLEAR(buf);
  
                          buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                          buf.memory = V4L2_MEMORY_MMAP;
  
                          buf.index = i;
  
  
  
                          if (-1 == xioctl(fd, VIDIOC_QBUF, &amp;buf))
  
                                  errno_exit("VIDIOC_QBUF");
  
                  }
  
                  type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                  if (-1 == xioctl(fd, VIDIOC_STREAMON, &amp;type))
  
                          errno_exit("VIDIOC_STREAMON");
  
                  break;
  
  
  
          case IO_METHOD_USERPTR:
  
                  for (i = 0; i &lt; n_buffers; ++i) {
  
                          struct v4l2_buffer buf;
  
  
  
                          CLEAR(buf);
  
                          buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                          buf.memory = V4L2_MEMORY_USERPTR;
  
                          buf.index = i;
  
                          buf.m.userptr = (unsigned long)buffers[i].start;
  
                          buf.length = buffers[i].length;
  
  
  
                          if (-1 == xioctl(fd, VIDIOC_QBUF, &amp;buf))
  
                                  errno_exit("VIDIOC_QBUF");
  
                  }
  
                  type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                  if (-1 == xioctl(fd, VIDIOC_STREAMON, &amp;type))
  
                          errno_exit("VIDIOC_STREAMON");
  
                  break;
  
          }
  
  }
  
  
  
  static void uninit_device(void)
  
  {
  
          unsigned int i;
  
  
  
          switch (io) {
  
          case IO_METHOD_READ:
  
                  free(buffers[0].start);
  
                  break;
  
  
  
          case IO_METHOD_MMAP:
  
                  for (i = 0; i &lt; n_buffers; ++i)
  
                          if (-1 == munmap(buffers[i].start, buffers[i].length))
  
                                  errno_exit("munmap");
  
                  break;
  
  
  
          case IO_METHOD_USERPTR:
  
                  for (i = 0; i &lt; n_buffers; ++i)
  
                          free(buffers[i].start);
  
                  break;
  
          }
  
  
  
          free(buffers);
  
  }
  
  
  
  static void init_read(unsigned int buffer_size)
  
  {
  
          buffers = calloc(1, sizeof(*buffers));
  
  
  
          if (!buffers) {
  
                  fprintf(stderr, "Out of memory\n");
  
                  exit(EXIT_FAILURE);
  
          }
  
  
  
          buffers[0].length = buffer_size;
  
          buffers[0].start = malloc(buffer_size);
  
  
  
          if (!buffers[0].start) {
  
                  fprintf(stderr, "Out of memory\n");
  
                  exit(EXIT_FAILURE);
  
          }
  
  }
  
  
  
  static void init_mmap(void)
  
  {
  
          struct v4l2_requestbuffers req;
  
  
  
          CLEAR(req);
  
  
  
          req.count = 4;
  
          req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
          req.memory = V4L2_MEMORY_MMAP;
  
  
  
          if (-1 == xioctl(fd, VIDIOC_REQBUFS, &amp;req)) {
  
                  if (EINVAL == errno) {
  
                          fprintf(stderr, "%s does not support "
  
                                   "memory mapping\n", dev_name);
  
                          exit(EXIT_FAILURE);
  
                  } else {
  
                          errno_exit("VIDIOC_REQBUFS");
  
                  }
  
          }
  
  
  
          if (req.count &lt; 2) {
  
                  fprintf(stderr, "Insufficient buffer memory on %s\n",
  
                           dev_name);
  
                  exit(EXIT_FAILURE);
  
          }
  
  
  
          buffers = calloc(req.count, sizeof(*buffers));
  
  
  
          if (!buffers) {
  
                  fprintf(stderr, "Out of memory\n");
  
                  exit(EXIT_FAILURE);
  
          }
  
  
  
          for (n_buffers = 0; n_buffers &lt; req.count; ++n_buffers) {
  
                  struct v4l2_buffer buf;
  
  
  
                  CLEAR(buf);
  
  
  
                  buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                  buf.memory      = V4L2_MEMORY_MMAP;
  
                  buf.index       = n_buffers;
  
  
  
                  if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &amp;buf))
  
                          errno_exit("VIDIOC_QUERYBUF");
  
  
  
                  buffers[n_buffers].length = buf.length;
  
                  buffers[n_buffers].start =
  
                          mmap(NULL /* start anywhere */,
  
                                buf.length,
  
                                PROT_READ | PROT_WRITE /* required */,
  
                                MAP_SHARED /* recommended */,
  
                                fd, buf.m.offset);
  
  
  
                  if (MAP_FAILED == buffers[n_buffers].start)
  
                          errno_exit("mmap");
  
          }
  
  }
  
  
  
  static void init_userp(unsigned int buffer_size)
  
  {
  
          struct v4l2_requestbuffers req;
  
  
  
          CLEAR(req);
  
  
  
          req.count  = 4;
  
          req.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
          req.memory = V4L2_MEMORY_USERPTR;
  
  
  
          if (-1 == xioctl(fd, VIDIOC_REQBUFS, &amp;req)) {
  
                  if (EINVAL == errno) {
  
                          fprintf(stderr, "%s does not support "
  
                                   "user pointer i/o\n", dev_name);
  
                          exit(EXIT_FAILURE);
  
                  } else {
  
                          errno_exit("VIDIOC_REQBUFS");
  
                  }
  
          }
  
  
  
          buffers = calloc(4, sizeof(*buffers));
  
  
  
          if (!buffers) {
  
                  fprintf(stderr, "Out of memory\n");
  
                  exit(EXIT_FAILURE);
  
          }
  
  
  
          for (n_buffers = 0; n_buffers &lt; 4; ++n_buffers) {
  
                  buffers[n_buffers].length = buffer_size;
  
                  buffers[n_buffers].start = malloc(buffer_size);
  
  
  
                  if (!buffers[n_buffers].start) {
  
                          fprintf(stderr, "Out of memory\n");
  
                          exit(EXIT_FAILURE);
  
                  }
  
          }
  
  }
  
  
  
  static void init_device(void)
  
  {
  
          struct v4l2_capability cap;
  
          struct v4l2_cropcap cropcap;
  
          struct v4l2_crop crop;
  
          struct v4l2_format fmt;
  
          unsigned int min;
  
  
  
          if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &amp;cap)) {
  
                  if (EINVAL == errno) {
  
                          fprintf(stderr, "%s is no V4L2 device\n",
  
                                   dev_name);
  
                          exit(EXIT_FAILURE);
  
                  } else {
  
                          errno_exit("VIDIOC_QUERYCAP");
  
                  }
  
          }
  
  
  
          if (!(cap.capabilities &amp; V4L2_CAP_VIDEO_CAPTURE)) {
  
                  fprintf(stderr, "%s is no video capture device\n",
  
                           dev_name);
  
                  exit(EXIT_FAILURE);
  
          }
  
  
  
          switch (io) {
  
          case IO_METHOD_READ:
  
                  if (!(cap.capabilities &amp; V4L2_CAP_READWRITE)) {
  
                          fprintf(stderr, "%s does not support read i/o\n",
  
                                   dev_name);
  
                          exit(EXIT_FAILURE);
  
                  }
  
                  break;
  
  
  
          case IO_METHOD_MMAP:
  
          case IO_METHOD_USERPTR:
  
                  if (!(cap.capabilities &amp; V4L2_CAP_STREAMING)) {
  
                          fprintf(stderr, "%s does not support streaming i/o\n",
  
                                   dev_name);
  
                          exit(EXIT_FAILURE);
  
                  }
  
                  break;
  
          }
  
  
  
  
  
          /* Select video input, video standard and tune here. */
  
  
  
  
  
          CLEAR(cropcap);
  
  
  
          cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
  
  
          if (0 == xioctl(fd, VIDIOC_CROPCAP, &amp;cropcap)) {
  
                  crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
                  crop.c = cropcap.defrect; /* reset to default */
  
  
  
                  if (-1 == xioctl(fd, VIDIOC_S_CROP, &amp;crop)) {
  
                          switch (errno) {
  
                          case EINVAL:
  
                                  /* Cropping not supported. */
  
                                  break;
  
                          default:
  
                                  /* Errors ignored. */
  
                                  break;
  
                          }
  
                  }
  
          } else {
  
                  /* Errors ignored. */
  
          }
  
  
  
  
  
          CLEAR(fmt);
  
  
  
          fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  
      fprintf(stderr, "Force Format %d\n", force_format);
  
          if (force_format) {
  
          if (force_format==2){
  
                      fmt.fmt.pix.width       = 1920;     
  
                  fmt.fmt.pix.height      = 1080;  
  
              fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_H264;
  
                      fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
  
          }
  
          else if(force_format==1){
  
              fmt.fmt.pix.width   = 640;
  
              fmt.fmt.pix.height  = 480;
  
              fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
  
              fmt.fmt.pix.field   = V4L2_FIELD_INTERLACED;
  
          }
  
  
  
                  if (-1 == xioctl(fd, VIDIOC_S_FMT, &amp;fmt))
  
                          errno_exit("VIDIOC_S_FMT");
  
  
  
                  /* Note VIDIOC_S_FMT may change width and height. */
  
          } else {
  
                  /* Preserve original settings as set by v4l2-ctl for example */
  
                  if (-1 == xioctl(fd, VIDIOC_G_FMT, &amp;fmt))
  
                          errno_exit("VIDIOC_G_FMT");
  
          }
  
  
  
          /* Buggy driver paranoia. */
  
          min = fmt.fmt.pix.width * 2;
  
          if (fmt.fmt.pix.bytesperline &lt; min)
  
                  fmt.fmt.pix.bytesperline = min;
  
          min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
  
          if (fmt.fmt.pix.sizeimage &lt; min)
  
                  fmt.fmt.pix.sizeimage = min;
  
  
  
          switch (io) {
  
          case IO_METHOD_READ:
  
                  init_read(fmt.fmt.pix.sizeimage);
  
                  break;
  
  
  
          case IO_METHOD_MMAP:
  
                  init_mmap();
  
                  break;
  
  
  
          case IO_METHOD_USERPTR:
  
                  init_userp(fmt.fmt.pix.sizeimage);
  
                  break;
  
          }
  
  }
  
  
  
  static void close_device(void)
  
  {
  
          if (-1 == close(fd))
  
                  errno_exit("close");
  
  
  
          fd = -1;
  
  }
  
  
  
  static void open_device(void)
  
  {
  
          struct stat st;
  
  
  
          if (-1 == stat(dev_name, &amp;st)) {
  
                  fprintf(stderr, "Cannot identify '%s': %d, %s\n",
  
                           dev_name, errno, strerror(errno));
  
                  exit(EXIT_FAILURE);
  
          }
  
  
  
          if (!S_ISCHR(st.st_mode)) {
  
                  fprintf(stderr, "%s is no device\n", dev_name);
  
                  exit(EXIT_FAILURE);
  
          }
  
  
  
          fd = open(dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
  
  
  
          if (-1 == fd) {
  
                  fprintf(stderr, "Cannot open '%s': %d, %s\n",
  
                           dev_name, errno, strerror(errno));
  
                  exit(EXIT_FAILURE);
  
          }
  
  }
  
  
  
  static void usage(FILE *fp, int argc, char **argv)
  
  {
  
          fprintf(fp,
  
                   "Usage: %s [options]\n\n"
  
                   "Version 1.3\n"
  
                   "Options:\n"
  
                   "-d | --device name   Video device name [%s]\n"
  
                   "-h | --help          Print this message\n"
  
                   "-m | --mmap          Use memory mapped buffers [default]\n"
  
                   "-r | --read          Use read() calls\n"
  
                   "-u | --userp         Use application allocated buffers\n"
  
                   "-o | --output        Outputs stream to stdout\n"
  
                   "-f | --format        Force format to 640x480 YUYV\n"
  
           "-F | --formatH264    Force format to 1920x1080 H264\n"
  
                   "-c | --count         Number of frames to grab [%i] - use 0 for infinite\n"
  
                   "\n"
  
           "Example usage: capture -F -o -c 300 > output.raw\n"
  
           "Captures 300 frames of H264 at 1920x1080 - use raw2mpg4 script to convert to mpg4\n",
  
                   argv[0], dev_name, frame_count);
  
  }
  
  
  
  static const char short_options[] = "d:hmruofFc:";
  
  
  
  static const struct option
  
  long_options[] = {
  
          { "device", required_argument, NULL, 'd' },
  
          { "help",   no_argument,       NULL, 'h' },
  
          { "mmap",   no_argument,       NULL, 'm' },
  
          { "read",   no_argument,       NULL, 'r' },
  
          { "userp",  no_argument,       NULL, 'u' },
  
          { "output", no_argument,       NULL, 'o' },
  
          { "format", no_argument,       NULL, 'f' },
  
      { "formatH264", no_argument,   NULL, 'F' },
  
          { "count",  required_argument, NULL, 'c' },
  
          { 0, 0, 0, 0 }
  
  };
  
  
  
  int main(int argc, char **argv)
  
  {
  
          dev_name = "/dev/video0";
  
  
  
          for (;;) {
  
                  int idx;
  
                  int c;
  
  
  
                  c = getopt_long(argc, argv,
  
                                  short_options, long_options, &amp;idx);
  
  
  
                  if (-1 == c)
  
                          break;
  
  
  
                  switch (c) {
  
                  case 0: /* getopt_long() flag */
  
                          break;
  
  
  
                  case 'd':
  
                          dev_name = optarg;
  
                          break;
  
  
  
                  case 'h':
  
                          usage(stdout, argc, argv);
  
                          exit(EXIT_SUCCESS);
  
  
  
                  case 'm':
  
                          io = IO_METHOD_MMAP;
  
                          break;
  
  
  
                  case 'r':
  
                          io = IO_METHOD_READ;
  
                          break;
  
  
  
                  case 'u':
  
                          io = IO_METHOD_USERPTR;
  
                          break;
  
  
  
                  case 'o':
  
                          out_buf++;
  
                          break;
  
  
  
                  case 'f':
  
                          force_format=1;
  
                          break;
  
  
  
          case 'F':
  
              force_format=2;
  
              break;
  
  
  
                  case 'c':
  
                          errno = 0;
  
                          frame_count = strtol(optarg, NULL, 0);
  
                          if (errno)
  
                                  errno_exit(optarg);
  
                          break;
  
  
  
                  default:
  
                          usage(stderr, argc, argv);
  
                          exit(EXIT_FAILURE);
  
                  }
  
          }
  
  
  
          open_device();
  
          init_device();
  
          start_capturing();
  
          mainloop();
  
          stop_capturing();
  
          uninit_device();
  
          close_device();
  
          fprintf(stderr, "\n");
  
          return 0;
  
  }

  It’s a modified version of a V4L2 video capture example.
  Then I know that if I have outputed the streame to a file I would have to run this command to convert the raw format to mp4 format :

  ffmpeg -f h264 -i output.raw -vcodec copy output.mp4

  And the v4l2loopback program I’m using is foud here :
  https://github.com/umlaeute/v4l2loopback

  ------------------Update------------------

  Okay. So I got the pipe from the capture program to ffmpeg working. It captures, decodes the h264 and I can write it to a mp4 file with this command :

  ./capture -F -d /dev/video0 -o | ffmpeg -f h264 -i - -vcodec copy out.mp4

  Now I am trying to get the last pipe working with this command :

  ./capture -F -d /dev/video0 -o | ffmpeg -f h264 -i - -vcodec copy -f mp4 - | gst-launch-0.10 -v fdsrc ! v4l2sink device=/dev/video3

  I get these errors :

  • muxer does not support non seekable output
  • Could not write header for output file #0 (incorrect codec parameters ?) : Invalid argument

  Any ideas ?

• 5 Top Google Optimize Alternatives to Consider

  17 mars 2023, par Erin — Analytics Tips

  Google Optimize is a popular conversion rate optimization (CRO) tool from Alphabet (parent company of Google). With it, you can run A/B, multivariate, and redirect tests to figure out which web page designs perform best. 

  Google Optimize seamlessly integrates with Google Analytics (GA). It also has a free tier. So many marketers chose it as their default A/B testing tool…until recently. 

  Google will sunset Google Optimize by 30 September 2023. 

  Starting from this date, Google will no longer support Optimize and Optimize 360 (premium edition). All experiments, active after this date, will be paused automatically and you’ll no longer have access to your historical records (unless these are exported in advance).

  The better news is that you still have time to find a Google Optimize alternative — and this post will help you with that. 

  Disclaimer : Please note that the information provided in this blog post is for general informational purposes only and is not intended to provide legal advice. Every situation is unique and requires a specific legal analysis. If you have any questions regarding the legal implications of any matter, please consult with your legal team or seek advice from a qualified legal professional. 

  Best Google Optimize Alternatives 

  Google Optimize was among the first free A/B testing apps. But as with any product, it has some disadvantages. 

  Data updates happen every 24 hours, not in real-time. A free account has caps on the number of experiments. You cannot run more than 5 experiments at a time or implement over 16 combinations for multivariate testing (MVT). A premium version (Optimize 365) has fewer usage constraints, but it costs north of $150K per year. 

  Google Optimize has native integration with GA (of course), so you can review all the CRO data without switching apps. But Optimize doesn’t work well with Google Analytics alternatives, which many choose to use for privacy-friendly user tracking, higher data accuracy and GDPR compliance. 

  At the same time, many other conversion rate optimization (CRO) tools have emerged, often boasting better accuracy and more competitive features than Google Optimize.

  Here are 5 alternative A/B testing apps worth considering.

  Adobe Target 

  

  Adobe Target is an advanced personalization platform for optimising user and marketing experiences on digital properties. It uses machine learning algorithms to deliver dynamic content, personalised promotions and custom browsing experiences to visitors based on their behaviour and demographic data. 

  Adobe Target also provides A/B testing and multivariate testing (MVT) capabilities to help marketers test and refine their digital experiences.

  Key features : 

  • Visual experience builder for A/B tests setup and replication 
  • Full factorial multivariate tests and multi-armed bandit testing
  • Omnichannel personalisation across web properties 
  • Multiple audience segmentation and targeting options 
  • Personalised content, media and product recommendations 
  • Advanced customer intelligence (in conjunction with other Adobe products)

  Pros

  • Convenient A/B test design tool 
  • Acucate MVT and MAB results 
  • Powerful segmentation capabilities 
  • Access to extra behavioural analytics 
  • One-click personalisation activation 
  • Supports rules-based, location-based and contextual personalisation
  • Robust omnichannel analytics in conjunction with other Adobe products 

  Cons 

  • Requires an Adobe Marketing Cloud subscription 
  • No free trial or freemium tier 
  • More complex product setup and configuration 
  • Steep learning curve for new users 

  Price : On-demand. 

  Adobe Target is sold as part of Adobe Marketing Cloud. Licence costs vary, based on selected subscriptions and the number of users, but are typically above $10K.

  Google Optimize vs Adobe Target : The Verdict 

  Google Optimize comes with a free tier, unlike Adobe Target. It provides you with a basic builder for A/B and MVT tests, but none of the personalisation tools Adobe has. Because of ease-of-use and low price, other Google Optimize alternatives are better suited for small to medium-sized businesses, doing baseline CRO for funnel optimisation. 

  Adobe Target pulls you into the vast Adobe marketing ecosystem, offering omnipotent customer behaviour analytics, machine-learning-driven website optimisation, dynamic content recommendations, product personalisation and extensive reporting. The app is better suited for larger enterprises with a significant investment in digital marketing.

  Matomo A/B Testing

  

  Matomo A/B Testing is a CRO tool, integrated into Matomo. All Matomo Cloud users get instant access to it, while On-Premise (free) Matomo users can purchase A/B testing as a plugin. 

  With Matomo A/B Testing, you can create multiple variations of a web or mobile page and test them with different segments of their audience. Matomo also doesn’t have any strict experiment caps, unlike Google Optimize. 

  You can split-test multiple creative variants for on-site assets such as buttons, slogans, titles, call-to-actions, image positions and more. You can even benchmark the performance of two (or more !) completely different homepage designs, for instance. 

  With us, you can compliantly and ethically collect historical user data about any visitor, who’s entered any of the active tests — and monitor their entire customer journey. You can also leverage Matomo A/B Testing data as part of multi-touch attribution modelling to determine which channels bring the best leads and which assets drive them towards conversion. 

   

  Since Matomo A/B Testing is part of our analytics platform, it works well with other features such as goal tracking, heatmaps, user session recordings and more. 

  Key features

  • Run experiments for web, mobile, email and digital campaigns 
  • Convenient A/B test design interface 
  • One-click experiment scheduling 
  • Integration with historic visitor profiles
  • Near real-time conversion tracking 
  • Apply segmentation to Matomo reports 
  • Easy creative variation sharing via a URL 

  Pros

  • High data accuracy with no reporting gaps 
  • Monitor the evolution of your success metrics for each variation
  • Embed experiments across multiple digital channels 
  • Set a custom confidence threshold for winning variations 
  • No compromises on user privacy 
  • Free 21-day trial available (for Matomo Cloud) and free 30-day plugin trial (for Matomo On-Premise)

  Cons

  • No on-site personalisation tools available 
  • Configuration requires some coding experience 

  Price : Matomo A/B Testing is included in the monthly Cloud plan (starting at €19 per month). On-Premise users can buy this functionality as a plugin (starting at €199/year). 

  Google Optimize vs Matomo A/B Testing : The Verdict 

  Matomo offers the same types of A/B testing features as Google Optimize (and some extras !), but without any usage caps. Unlike Matomo, Google Optimize doesn’t support A/B tests for mobile apps. You can access some content testing features for Android Apps via Firebase, but this requires another subscription. 

  Matomo lets you run A/B experiments across the web and mobile properties, plus desktop apps, email campaigns and digital ads. Also, Matomo has higher conversion data accuracy, thanks to our privacy-focused method for collecting website analytics. 

  When using Matomo in most EU markets, you’re legally exempt from showing a cookie consent banner. Meaning you can collect richer insights for each experiment and make data-driven decisions. Nearly 40% of global consumers reject cookie consent banners. With most other tools, you won’t be getting the full picture of your traffic. 

  Optimizely 

  

  Optimizely is a conversion optimization platform that offers several competitive products for a separate subscription. These include a flexible content management system (CMS), a content marketing platform, a web A/B testing app, a mobile featuring testing product and two eCommerce-specific website management products.

  The Web Experimentation app allows you to optimise every customer touchpoint by scheduling unlimited split or multi-variant tests and conversions across all your projects from the same app. Apart from websites, this subscription also supports experiments for single-page applications. But if you want more advanced mobile app testing features, you’ll have to purchase another product — Feature Experimentation. 

  Key features :

  • Intuitive experiment design tool 
  • Cross-browser testing and experiment preview 
  • Multi-page funnel tests design 
  • Behavioural and geo-targeting 
  • Exit/bounce rate tracking
  • Custom audience builder for experiments
  • Comprehensive reporting 

  Pros

  • Unlimited number of concurrent experiments 
  • Upload your audience data for test optimisation 
  • Dynamic content personalisation available on a higher tier 
  • Pre-made integrations with popular heatmap and analytics tools 
  • Supports segmentation by device, campaign type, traffic sources or referrer 

  Cons

  • You need a separate subscription for mobile CRO 
  • Free trial not available, pricing on-demand 
  • Multiple licences and subscriptions may be required 
  • Doesn’t support A/B tests for emails 

  Price : Available on-demand. 

  Web Experimentation tool has three subscription tiers — Grow, Accelerate, and Scale with different features included. 

  Google Optimize vs Optimizely : The Verdict 

  Optimizely is a strong contender for Google Optimize alternative as it offers more advanced audience targeting and segmentation options. You can target users by IP address, cookies, traffic sources, device type, browser, language, location or a custom utm_campaign parameter.

  Similar to Matomo A/B testing, Optimizely doesn’t limit the number of projects or concurrent experiments you can do. But you have to immediately sign an annual contract (no monthly plans are available). Pricing also varies based on the number of processed impressions (more experiments = a higher annual bill). An annual licence can cost $63,700 for 10 million impressions on average, according to an independent estimate. 

  Visual Website Optimizer (VWO) 

  

  VWO is another popular experimentation platform, supporting web, mobile and server-side A/B testing and personalisation campaigns.

  Similar to others, VWO offers a drag-and-drop visual editor for creating campaign variants. You don’t need design or coding knowledge to create tests. Once you’re all set, the app will benchmark your experiment performance against expected conversion rates, report on differences in conversion rate and point towards the best-performing creative. 

  Similar to Optimizely, VWO also offers web/mobile app optimisation as a separate subscription. Apart from testing visual page elements, you can also run in-app experiments throughout the product stack to locate new revenue opportunities. For example, you can test in-app subscription flows, search algorithms or navigation flows to improve product UX. 

  Key features :

  • Multivariate and multi-arm bandit tests 
  • Multi-step (funnel) split tests 
  • Collaborative experiment tracking dashboard 
  • Target users by different attributes (URL, device, geo-data) 
  • Personal library of creative elements 
  • Funnel analytics, session records, and heatmaps available 

  Pros

  • Free starter plan is available (similar to Google Optimize)
  • Simple tracking code installation and easy code editor
  • Offers online reporting dashboards and report downloads 
  • Slice-and-dice reports by different audience dimensions
  • No impact on website/app loading speed and performance 

  Cons

  • Multivariate testing is only available on a higher-tier plan 
  • Annual contract required, despite monthly billing 
  • Mobile app A/B split tests require another licence 
  • Requires ongoing user training 

  Price : Free limited plan available. 

  Then from $356/month, billed annually. 

  Google Optimize vs VWO : The Verdict 

  The free plan on VWO is very similar to Google Optimize. You get access to A/B testing and split URL testing features for websites only. The visual editing tool is relatively simple — and you can use URL or device targeting. 

  Free VWO reports, however, lack the advertised depth in terms of behavioural or funnel-based reporting. In-depth insights are available only to premium users. Extra advertised features like heatmaps, form analytics and session recordings require yet another subscription. With Matomo Cloud, you get all three of these together with A/B testing. 

  ConvertFlow 

  

  ConvertFlow markets itself as a funnel optimisation app for eCommerce and SaaS companies. It meshes lead generation tools with some CRO workflows. 

  With ConvertFlow, you can effortlessly design opt-in forms, pop-ups, quizzes and even entire landing pages using pre-made web elements and a visual builder. Afterwards, you can put all of these assets to a “field test” via the ConvertFlow CRO platform. Select among pre-made templates or create custom variants for split or multivariate testing. You can customise tests based on URLs, cookie data and user geolocation among other factors. 

  Similar to Adobe Target, ConvertFlow also allows you to run tests targeted at specific customer segments in your CRM. The app has native integrations with HubSpot and Salesforce, so this feature is easy to enable. ConvertFlow also offers advanced targeting and segmentation options, based on user on-site behaviour, demographics data or known interests.

  Key features :

  • Create and test landing pages, surveys, quizzes, pop-ups, surveys and other lead-gen assets. 
  • All-in-one funnel builder for creating demand-generation campaigns 
  • Campaign personalisation, based on on-site activity 
  • Re-usable dynamic visitor segments for targeting 
  • Multi-step funnel design and customisation 
  • Embedded forms for split testing CTAs on existing pages 

  Pros

  • Allows controlling the traffic split for each variant to get objective results 
  • Pre-made integration with Google Analytics and Google Tag Manager 
  • Conversion and funnel reports, available for each variant 
  • Access to a library with 300+ conversion campaign templates
  • Apply progressive visitor profiling to dynamically adjust user experiences 

  Cons

  • Each plan covers only $10K views. Each extra 10k costs another $20/mo 
  • Only one website allowed per account (except for Teams plan) 
  • Doesn’t support experiments in mobile app 
  • Not all CRO features are available on a Pro plan. 

  Price : Access to CRO features costs from $300/month on a Pro plan. Subscription costs also increase, based on the total number of monthly views. 

  Google Optimize vs CovertFlow : The Verdict 

  ConvertFlow is equally convenient to use in conjunction with Google Analytics as Google Optimize is. But the similarities end up here since ConvertFlow combines funnel design features with CRO tools. 

  With ConvertFlow, you can run more advanced experiments and apply more targeting criteria than with Google Optimize. You can observe user behaviour and conversion rates across multi-step CTA forms and page funnels, plus benefit from first-touch attribution reporting without switching apps. 

  Though CovertFlow has a free plan, it doesn’t include access to CRO features. Meaning it’s not a free alternative to Google Optimize.

  Comparison of the Top 5 Google Optimize Alternatives

  Feature	Google Optimize	Adobe Target	Matomo A/B test	Optimizely	VWO	ConvertFlow
  Supported channels	Web	Web, mobile, social media, email	Web, mobile, email, digital campaigns	Websites & mobile apps	Websites, web and mobile apps	Websites and mobile apps
  A/B testing
  Easy GA integration
  Integrations with other web analytics apps
  Audience segmentation	Basic	Advanced	Advanced	Advanced	Advanced	Advanced
  Geo-targeting
  Behavioural targeting	Basic	Advanced	Advanced	Advanced	Advanced	Advanced
  Heatmaps			No extra cost with Matomo Cloud	〰️ *via integrations	〰️ *requires another subscription
  Session recordings			No extra cost with Matomo Cloud		〰️ *requires another subscription
  Multivariate testing (MVT)
  Dynamic personalisation					〰️ *only on higher account tiers	〰️ *only on the highest account tiers
  Product recommendations				〰️ *requires another subscription	〰️ *requires another subscription
  Support	Self-help desk on a free tier	Email, live-chat, phone support	Email, self-help guides and user forum	Knowledge base, online tickets, user community	Self-help guides, email, phone	Knowledge base, email, and live chat support
  Price	Freemium	On-demand	From €19 for Cloud subscription From €199/year as plugin for On-Premise	On-demand	Freemium From $365/mo	From $300/month

  Conclusion 

  Google Optimize has served marketers well for over five years. But as the company decided to move on — so should you. 

  Oher A/B testing tools like Matomo, Optimizely or VWO offer better funnel analytics and split testing capabilities without any usage caps. Also, tools like Adobe Target, Optimizely, and VWO offer advanced content personalisation, based on aggregate analytics. However, they also come with much higher subscription costs.

  Matomo is a robust, compliant and cost-effective alternative to Google Optimize. Our tool allows you to schedule campaigns across all digital mediums (and even desktop apps !) without a