Recherche avancée

Sur d’autres sites (3361)

• GA360 Sunset : Is Now the Time to Switch ?

  20 mai 2024, par Erin

  Google pushed the sunset date of Universal Analytics 360 to July 2024, giving enterprise users more time to transition to Google Analytics 4. This extension is also seen by some as time to find a suitable alternative. 

  While Google positions GA4 as an upgrade to Universal Analytics, the new platform has faced its fair share of backlash. 

  So before you rush to meet the new sunset deadline, ask yourself this question : Is now the time to switch to a Google Analytics alternative ?

  In this article, we’ll explain what the new GA360 sunset date means and show you what you could gain by choosing a privacy-friendly alternative. 

  What’s happening with the final GA360 sunset ?

  Google has given Universal Analytics 360 properties with a current 360 licence a one-time extension, which will end on 1 July 2024.

  Why did Google extend the sunset ?

  In a blog post on Google, Russell Ketchum, Director of Product Management at Google Analytics, provided more details about the final GA360 sunset. 

  In short, the tech giant realised it would take large enterprise accounts (which typically have complex analytics setups) much longer to transition smoothly. The extension gives them time to migrate to GA4 and check everything is tracking correctly. 

  What’s more, Google is also focused on improving the GA4 experience before more GA360 users migrate :

  “We’re focusing our efforts and investments on Google Analytics 4 to deliver a solution built to adapt to a changing ecosystem. Because of this, throughout 2023 we’ll be shifting support away from Universal Analytics 360 and will move our full focus to Google Analytics 4 in 2024. As a result, performance will likely degrade in Universal Analytics 360 until the new sunset date.”

  Despite the extension, the July sunset is definitive. 

  Starting the week of 1 July 2024, you won’t be able to access any Universal Analytics properties or the API (not even with read-only access), and all data will be deleted.

  In other words, it’s not just data collection that will cease at the start of July. You won’t be able to access the platform, and all your data will be deleted. 

  What GA360 features is Google deprecating, and when ?

  If you’re wondering which GA360 features are being deprecated and when, here is the timeline for Google’s final GA360 sunset :

  • 1 January 2024 : From the beginning of the year, Google doesn’t guarantee all features and functionalities in UA 360 will continue to work as expected. 
  • 29 January 2024 : Google began deprecating a string of advertising and measurement features as it shifts resources to focus on GA4. These features include :
    • Realtime reports
    • Lifetime Value report
    • Model Explorer
    • Cohort Analysis
    • Conversion Probability report
    • GDN Impression Beta
  • Early March 2024 : Google began deprecating more advertising and measurement features. Deprecated advertising features include Demographic and Interest reports, Publisher reporting, Phone Analytics, Event and Salesforce Data Import, and Realtime BigQuery Export. Deprecated measurement features include Universal Analytics property creation, App Views, Unsampled reports, Custom Tables and annotations.
  • Late March 2024 : This is the last recommended date for migration to GA4 to give users three months to validate data and settings. By this date, Google recommends that you migrate your UA’s Google Ads links to GA4, create new Google Ad conversions based on GA4 events, and add GA4 audiences to campaigns and ad groups for retargeting. 
  • 1 July 2024 : From 1 July 2024, you won’t be able to access any UA properties, and all data will be deleted.

  What’s different about GA4 360 ? 

  GA4 comes with a new set of metrics, setups and reports that change how you analyse your data. We highlight the key differences between Universal Analytics and GA4 below. 

  

  New dashboard

  The layout of GA4 is completely different from Universal Analytics, so much so that the UX can be very complex for first-time and experienced GA users alike. Reports or metrics that used to be available in a couple of clicks in UA now take five or more to find. While you can do more in theory with GA4, it takes much more work. 

  New measurements

  The biggest difference between GA4 and UA is how Google measures data. GA4 tracks events — and everything counts as an event. That includes pageviews, scrolls, clicks, file downloads and contact form submissions. 

  The idea is to anonymise data while letting you track complex buyer journeys across multiple devices. However, it can be very confusing, even for experienced marketers and analysts. 

  New metrics

  You won’t be able to track the same metrics in GA4 as in Universal Analytics. Rather than bounce rate, for example, you are forced to track engagement rate, which is the percentage of engaged sessions. These sessions last at least ten seconds, at least two pageviews or at least one conversion event. 

  Confused ? You’re not alone. 

  New reports

  Most reports you’ll be familiar with in Universal Analytics have been replaced in GA4. The new platform also has a completely different reporting interface, with every report grouped under the following five headings : realtime, audience, acquisition, behaviour and conversions. It can be hard for experienced marketers, let alone beginners, to find their way around these new reports. 

  AI insights

  GA4 has machine learning (ML) capabilities that allow you to generate AI insights from your data. Specifically, GA4 has predictive analytics features that let you track three trends : 

  • Purchase probability : the likelihood that a consumer will make a purchase in a given timeframe.
  • Churn probability : the likelihood a customer will churn in a given period.
  • Predictive revenue : the amount of revenue a user is likely to generate over a given period. 

  Google generates these insights using historical data and machine learning algorithms. 

  Cross-platform capabilities

  GA4 also offers cross-platform capabilities, meaning it can track user interactions across websites and mobile apps, giving businesses a holistic view of customer behaviour. This allows for better decision-making throughout the customer journey.

  Does GA4 360 come with other risks ?

  Aside from the poor usability, complexity and steep learning curve, upgrading your GA360 property to GA4 comes with several other risks.

  GA4 has a rocky relationship with privacy regulations, and while you can use it in a GDPR-compliant way at the moment, there’s no guarantee you’ll be able to do so in the future. 

  This presents the prospect of fines for non-compliance. A worse risk, however, is regulators forcing you to change web analytics platforms in the future—something that’s already happened in the EU. Migrating to a new application can be incredibly painful and time-consuming, especially when you can choose a privacy-friendly alternative that avoids the possibility of this scenario. 

  If all this wasn’t bad enough, switching to GA4 risks your historical Universal Analytics data. That’s because you can’t import Universal Analytics data into GA4, even if you migrate ahead of the sunset deadline.

  Why you should consider a GA4 360 alternative instead

  With the GA360 sunset on the horizon, what are your options if you don’t want to deal with GA4’s problems ? 

  The easiest solution is to migrate to a GA4 360 alternative instead. And there are plenty of reasons to migrate from Google Analytics to a privacy-friendly alternative like Matomo. 

  Keep historical data

  As we’ve explained, Google isn’t letting users import their Universal Analytics data from GA360 to GA4. The easiest way to keep it is by switching to a Google Analytics alternative like Matomo that lets you import your historical data. 

  Any business using Google Analytics, whether a GA360 user or otherwise, can import data into Matomo using our Google Analytics Importer plugin. It’s the best way to avoid disruption or losing data when moving on from Universal Analytics.

  Collect 100% accurate data

  Google Analytics implements data sampling and machine learning to fill gaps in your data and generate the kind of predictive insights we mentioned earlier. For standard GA4 users, data sampling starts at 10 million events. For GA4 360 users, data sampling starts at one billion events. Nevertheless, Google Analytics data may not accurately reflect your web traffic. 

  You can fix this using a Google Analytics alternative like Matomo that doesn’t use data sampling. That way, you can be confident that your data-driven decisions are being made with 100% accurate user data. 

  Try Matomo for Free

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

  Start for free

  No credit card required

  Guarantee user privacy first

  Google has a stormy relationship with the EU-US Data Privacy Framework—being banned and added back to the framework in recent years.

  Currently, organisations governed by GDPR can use Google Analytics to collect data about EU residents, but there’s no guarantee of their ability to do so in the future. Nor does the Framework prevent Google from using EU customer data for ulterior purposes such as marketing and training large language models. 

  By switching to a privacy-focused alternative like Matomo, you don’t have to worry about your user’s data ending up in the wrong hands.

  Upgrade to an all-in-one analytics tool

  Switching from Google Analytics can actually give organisations access to more features. That’s because some GA4 alternatives, like Matomo, offer advanced conversion optimisation features like heatmaps, session recordings, A/B testing, form analytics and more right out of the box. 

  

  This makes Matomo a great choice for marketing teams that want to minimise their tech stack and use one tool for both web and behavioural analytics. 

  Get real-time reports

  GA4 isn’t the best tool for analysing website visitors in real time. That’s because it can take up to 4 hours to process new reports in GA360.

  However, Google Analytics alternatives like Matomo have a range of real-time reports you can leverage.

  

  In Matomo, the Real Time Visitor World Map and other reports are processed every 15 minutes. There is also a Visits in Real-time report, which refreshes every five seconds and shows a wealth of data for each visitor. 

  Matomo makes migration easy

  Whether it’s the poor usability, steep learning curve, inaccurate data or privacy issues, there’s every reason to think twice about migrating your UA360 account to GA4. 

  So why not migrate to a Google Analytics alternative like Matomo instead ? One that doesn’t sample data, guarantees your customers’ privacy, offers all the features GA4 doesn’t and is already used by over 1 million sites worldwide.

  Making the switch is easy. Matomo is one of the few web analytics tools that lets you import historical Google Analytics data. In doing so, you can continue to access your historical data and develop more meaningful insights by not having to start from scratch.

  If you’re ready to start a Google Analytics migration, you can try Matomo free for 21 days — no credit card required. 

  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

  

• The issue of inccorrect duration time of MP4 file generated with FFMPEG SDK

  28 avril 2016, par LavenderSs

  The purpose of following code is to merge some pictures into a MP4 file with FFMPEG SDK and X265 encoder. The Mp4 file could be generated and played normally, but the duration time is longer than it should be. Eg. I have 8 pictures, and If the fps of MP4 is 2, the duration time shall be 4 seconds. But the actual duration time is 11 secodes. When I played this MP4 file, it will be over after playing 4s.

  I am just fresh guy in the field of ffmpeg. I think the root cause of issue may be the incorrect bitrate, but I’ve tried updated the parameter of encoders, doesn’t work. Could any people who is familiar with ffmpeg programming help check this issue ? Really appreciate !!

  #define IMAGE_FILE_NUMBER    8
  
  
  
  #define MP4_FILE     "test_sample_1.mp4"
  
  
  
  char* image_file[IMAGE_FILE_NUMBER] = 
  
  {
  
      "test_sample_1_1.bmp",
  
      "test_sample_1_2.bmp",
  
      "test_sample_1_3.bmp",
  
      "test_sample_1_4.bmp",
  
      "test_sample_1_5.bmp",
  
      "test_sample_1_6.bmp",
  
      "test_sample_1_7.bmp",
  
      "test_sample_1_8.bmp"
  
  };
  
  
  
  void test_image2mp4(const char* output_filename)
  
  {
  
      printf(" Enter %s!!!\n", __FUNCTION__);
  
  
  
      FILE *file[IMAGE_FILE_NUMBER];    /*image file handler*/  
  
      char *szTxt[IMAGE_FILE_NUMBER];  /*image data*/  
  
      int nDataLen[IMAGE_FILE_NUMBER]={0};   /*image data length (exclude header)*/
  
  
  
      int nWidth = 0;    
  
      int nHeight= 0;    
  
      int nLen;  
  
      int nHeadLen;
  
  
  
      int file_index;
  
      int ret;
  
  
  
      BITMAPFILEHEADER bmpFHeader = {0};    
  
      BITMAPINFOHEADER bmpIHeader = {0};
  
  
  
      //Abstract image data from bmp files
  
      for (file_index = 0; file_index < IMAGE_FILE_NUMBER; file_index ++)    
  
      {
  
          file[file_index] = fopen(image_file[file_index], "rb");  
  
  
  
          av_assert0(file[file_index] != NULL);
  
  
  
          /*Read image file*/
  
          fseek(file[file_index],0,SEEK_END);  
  
          nLen = ftell(file[file_index]);  
  
          szTxt[file_index] = (char *)malloc(nLen); 
  
  
  
          fseek(file[file_index],0,SEEK_SET);
  
          nLen = fread(szTxt[file_index],1,nLen,file[file_index]);  
  
          fclose(file[file_index]);    
  
  
  
          memcpy(&bmpFHeader, szTxt[file_index], sizeof(BITMAPFILEHEADER));  
  
  
  
          nHeadLen = bmpFHeader.bfOffBits - sizeof(BITMAPFILEHEADER);  
  
  
  
          memcpy(&bmpIHeader,szTxt[file_index]+sizeof(BITMAPFILEHEADER),nHeadLen);  
  
  
  
          nWidth = bmpIHeader.biWidth;  
  
          nHeight = bmpIHeader.biHeight;  
  
  
  
          szTxt[file_index] += bmpFHeader.bfOffBits;    
  
          nDataLen[file_index] = nLen-bmpFHeader.bfOffBits;    
  
  
  
          printf(" Read [%s] width:%d, height:%d, data len:%d.\n", image_file[file_index], nWidth, nHeight, nDataLen[file_index]);
  
      }    
  
  
  
      av_register_all();    
  
      avcodec_register_all();    
  
  
  
      AVFormatContext *pFmtCtx = NULL;
  
      AVCodec *pCodec;
  
      AVStream *pVideoStream;
  
      AVCodecContext *pCodecCtx;
  
      AVFrame *pFrame;
  
      AVFrame *pRGBFrame;
  
      AVPacket pPkt;
  
      unsigned char *yuv_buff; 
  
      unsigned char *rgb_buff;
  
      struct SwsContext * pSwsCtx;
  
      int size;
  
      AVRational sRate;
  
  
  
      sRate.num = 2000;
  
      sRate.den = 1000;
  
  
  
      pFmtCtx = avformat_alloc_context();
  
      pFmtCtx->oformat = av_guess_format(NULL, output_filename, NULL);
  
      avio_open(&pFmtCtx->pb, output_filename, AVIO_FLAG_WRITE);
  
  
  
      pCodec = avcodec_find_encoder(AV_CODEC_ID_HEVC);
  
      printf(" Found h265 codec...\n");
  
  
  
      pVideoStream = avformat_new_stream(pFmtCtx, pCodec);
  
  
  
      pVideoStream->time_base = sRate;
  
      pVideoStream->avg_frame_rate = sRate;
  
      pCodecCtx = pVideoStream->codec;
  
  
  
      if (pFmtCtx->oformat->flags | AVFMT_GLOBALHEADER)
  
      {
  
          pCodecCtx->flags |= CODEC_FLAG_GLOBAL_HEADER;
  
      }
  
  
  
      av_opt_set(pCodecCtx->priv_data, "preset", "ultrafast", 0);
  
      av_opt_set(pCodecCtx->priv_data, "tune", "zerolatency", 0);
  
      av_opt_set(pCodecCtx->priv_data, "x265-params", "qp=20", 0);
  
      av_opt_set(pCodecCtx->priv_data, "crf", "18", 0);
  
  
  
      pCodecCtx->codec_id = AV_CODEC_ID_HEVC;//from lxh's case
  
      pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
  
      pCodecCtx->ticks_per_frame = 2;
  
      pCodecCtx->max_b_frames = 1;//0
  
      pCodecCtx->bit_rate_tolerance = 1;
  
      pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
  
      pCodecCtx->width = nWidth;
  
      pCodecCtx->height = nHeight;
  
      pCodecCtx->thread_count = 1;
  
  
  
      pCodecCtx->time_base.num = pVideoStream->avg_frame_rate.num;
  
      pCodecCtx->time_base.den = pVideoStream->avg_frame_rate.den;
  
  
  
      pCodecCtx->gop_size = 10;
  
  
  
      pCodecCtx->bit_rate = 3000000;//no use
  
      pCodecCtx->qmin = 1;
  
      pCodecCtx->qmax = 5;
  
  
  
      pFrame = av_frame_alloc();
  
      pRGBFrame = av_frame_alloc();
  
  
  
      pFrame->width = pCodecCtx->width;
  
      pFrame->height = pCodecCtx->height;
  
      pFrame->format = pCodecCtx->pix_fmt;
  
  
  
      ret = avcodec_open2(pCodecCtx, pCodec, NULL);
  
      if (ret < 0)
  
      {
  
        char msg[128];
  
        av_strerror(ret, msg, 128);
  
        printf("err: %s\n", msg);
  
      }
  
  
  
      printf(" Create and open codec...\n");    
  
  
  
      ret = avformat_write_header(pFmtCtx, NULL);
  
      if (ret < 0)
  
      {
  
          static char msg[128];
  
          av_strerror(ret, msg, 128);
  
          av_assert0(ret >= 0);
  
      }
  
  
  
      size = avpicture_get_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);  
  
      yuv_buff = (unsigned char*)av_malloc(size); 
  
  
  
      pSwsCtx= sws_getContext(pCodecCtx->width,pCodecCtx->height,AV_PIX_FMT_BGR24,
  
                      pCodecCtx->width,pCodecCtx->height,AV_PIX_FMT_YUV420P,SWS_POINT,NULL,NULL,NULL);    
  
  
  
      printf(" Begin encode...\n");
  
  
  
      pFrame->pts = 0;
  
  
  
      for (file_index = 0; file_index < IMAGE_FILE_NUMBER; file_index ++)    
  
      {
  
          rgb_buff = (unsigned char*)av_malloc(nDataLen[file_index]);  
  
          memcpy(rgb_buff, szTxt[file_index], nDataLen[file_index]);    
  
  
  
          avpicture_fill((AVPicture*)pRGBFrame, (unsigned char*)rgb_buff, AV_PIX_FMT_RGB24, nWidth, nHeight);    
  
          //        av_image_fill_arrays
  
          avpicture_fill((AVPicture*)pFrame, (unsigned char*)yuv_buff, AV_PIX_FMT_YUV420P, nWidth, nHeight);    
  
  
  
          // rotate image
  
          pRGBFrame->data[0]  += pRGBFrame->linesize[0] * (nHeight - 1);    
  
          pRGBFrame->linesize[0] *= -1;                       
  
          pRGBFrame->data[1]  += pRGBFrame->linesize[1] * (nHeight / 2 - 1);    
  
          pRGBFrame->linesize[1] *= -1;    
  
          pRGBFrame->data[2]  += pRGBFrame->linesize[2] * (nHeight / 2 - 1);    
  
          pRGBFrame->linesize[2] *= -1;    
  
  
  
          //rgb -> yuv    
  
          sws_scale(pSwsCtx,pRGBFrame->data,pRGBFrame->linesize,0,pCodecCtx->height,pFrame->data,pFrame->linesize);    
  
  
  
          av_init_packet(&pPkt);
  
          pPkt.data = NULL;    // packet data will be allocated by the encoder
  
          pPkt.size = 0;
  
  
  
          pFrame->pts = (int64_t)file_index * ((pVideoStream->time_base.den * pVideoStream->avg_frame_rate.den)
  
            / (pVideoStream->time_base.num * pVideoStream->avg_frame_rate.num));
  
  
  
          /* encode the image */
  
          int out;
  
          ret = avcodec_encode_video2(pVideoStream->codec, &pPkt, pFrame, &out);
  
  
  
          if (ret < 0)
  
          {
  
              static char msg[128];
  
              av_strerror(ret, msg, 128);
  
              av_assert0(ret >= 0);
  
          }
  
          else
  
          {
  
              printf(" [%d]encoding ...\n", file_index);        
  
          }
  
  
  
          pPkt.stream_index = 0;
  
          ret = av_interleaved_write_frame(pFmtCtx, &pPkt);
  
          if (ret < 0)
  
          {
  
              static char msg[128];
  
              av_strerror(ret, msg, 128);
  
              av_assert0(ret >= 0);
  
          }
  
  
  
          av_free_packet(&pPkt);
  
          av_free(rgb_buff);
  
      }
  
  
  
      av_write_trailer(pFmtCtx);
  
  
  
      printf(" Finish encode... \n");
  
  
  
      avcodec_close(pCodecCtx);
  
      av_frame_free(&pFrame);
  
      av_frame_free(&pRGBFrame);
  
      avio_closep(&pFmtCtx->pb);
  
      sws_freeContext(pSwsCtx);
  
      avformat_free_context(pFmtCtx);
  
  
  
      return;
  
  }

  This is encoding information of generated MP4 file, including incorrect duration time.
  

• open source CMS and server for video streaming platform

  30 mai 2016, par Infinite

  I have to propose a platform that allows streaming video services employing the MPEEG-DASH standard. This platform blocks must be implemented with open source tools. I proposed FFmpeg to encode and MP4Box/GPAC tool for encryption and packaging. For the DRM case my propose is to use Widewine (I didn’t find any other open source tool) which is compatible with dash.js (the player proposed by me), it can be integrated to Chrome and according to CastLabs it’s also compatible with MP4Box. So, I have to select an open source CMS, and at the same time I need it to be compatible with dash.js. I read that it’s possible to add any JavaScript to these CMS, that it’s only necessary to create some modules to do so. I’d like to know which one of the following CMS you suggest me : MediaDrop, Drupal or Wordpress.
  I also have some doubts about the server. I know that in order to offer this service it only takes a traditional HTTP server. In a first moment I chose Nginx over Apache because the latter presents some problems associated to performance (the server will receive a large amount of simultaneous requests), nevertheless, I discarded Nginx (Nginx-rtmp module) due to its constraints : it’s only for live streaming (I need the service to be offered also on demand) and the inputs must be RTMP. I found something about Nginx-based VOD packager, do you know if this one can be used as a server to offer live and on demand streaming service ?