Recherche avancée

Sur d’autres sites (5290)

• Use libav to copy raw H264 stream as mp4 without codec

  11 décembre 2018, par cKt 1010

  Since my platform didn’t include libx264 some I can’t use H264 codec in libav.
  I know this question is similar to Raw H264 frames in mpegts container using libavcodec. But trust me, I test bob2’s method but didn’t work.
  There are some problem here :

  1. How to set PTS and DTS ?

  If I use setting below which was bob2 told, Libav will print : "Timestamps are unset in a packet for stream 0. This is deprecated and will stop working in the future. Fix your code to set the timestamps properly"

  packet.flags |= AV_PKT_FLAG_KEY; 
  
  packet.pts = packet.dts = 0;

  So should I use frame rate to calculate it manually？

  2. How to set PPS and SPS ?

  bob2 didn’t told it in his code, but it seems we can’t skip this step. Someone told me that it should be set to extradata which is in AVCodecContext struct. But what is formate ? should it include H264 header ?

  3. Should we delete 0x00 0x00 0x00 0x01 header one by one ?

  Seems we must delete H264 header for every H264 frame. But it cost time anyway. Should we must do it ?

  My code is mess (I tried to many method, lost in it now...). I past it below, and hope not confuse you.

  Init :

  AVOutputFormat *fmt;
  
  AVFormatContext *oc;
  
  AVCodec *audio_codec = NULL, *video_codec = NULL;
  
  Int32 ret;
  
  
  
  assert(video_st != NULL);
  
  assert(audio_st != NULL);
  
  /* Initialize libavcodec, and register all codecs and formats. */
  
  av_register_all();
  
  /* allocate the output media context */
  
  printf("MediaSave: save file to %s", pObj->filePath);
  
  avformat_alloc_output_context2(&oc, NULL, NULL, pObj->filePath);
  
  if (!oc) {
  
      Vps_printf(
  
          "Could not deduce output format from file extension: using MPEG.");
  
      avformat_alloc_output_context2(&oc, NULL, "mpeg", pObj->filePath);
  
  }
  
  if (!oc)
  
      return SYSTEM_LINK_STATUS_EFAIL;
  
  pObj->oc = oc;
  
  
  
  fmt = oc->oformat;
  
  fmt->video_codec = AV_CODEC_ID_H264;
  
  Vps_printf("MediaSave: codec is %s", fmt->name);
  
  /* Add the video streams using the default format codecs
  
   * and initialize the codecs. */
  
  if ((fmt->video_codec != AV_CODEC_ID_NONE) &&
  
      (pObj->formate_type & MEDIA_SAVE_TYPE_VIDEO)) {
  
      add_stream(video_st, oc, &video_codec, fmt->video_codec);
  
      //open_video(oc, video_codec, video_st);
  
      pObj->video_st = video_st;
  
      pObj->video_codec = video_codec;
  
  }
  
  if ((fmt->audio_codec != AV_CODEC_ID_NONE) &&
  
      (pObj->formate_type & MEDIA_SAVE_TYPE_AUDIO)) {
  
      add_stream(audio_st, oc, &audio_codec, fmt->audio_codec);
  
      //open_audio(oc, audio_codec, audio_st);
  
      pObj->audio_codec = audio_codec;
  
      pObj->audio_st = audio_st;
  
  }
  
  
  
  /* open the output file, if needed */
  
  if (!(fmt->flags & AVFMT_NOFILE)) {
  
      ret = avio_open(&oc->pb, pObj->filePath, AVIO_FLAG_WRITE);
  
      if (ret < 0) {
  
          Vps_printf("Could not open '%s': %s", pObj->filePath,
  
                  av_err2str(ret));
  
          return SYSTEM_LINK_STATUS_EFAIL;
  
      }
  
  }

  Write h264

  /* Write the stream header, if any. */
  
  ret = avformat_write_header(oc, NULL);
  
  
  
  int nOffset = 0;
  
  int  nPos =0;
  
  uint8_t sps_pps[4] = { 0x00, 0x00, 0x00, 0x01 };
  
  while(1) 
  
  {
  
      AVFormatContext *oc = pObj->oc;
  
      nPos = ReadOneNaluFromBuf(&naluUnit, bitstreamBuf->bufAddr + nOffset, bitstreamBuf->fillLength - nOffset);
  
      if(naluUnit.type == 7 || naluUnit.type == 8) {
  
          Vps_printf("Get type 7 or 8, Store it to extradata");
  
          video_st->st->codec->extradata_size = naluUnit.size + sizeof(sps_pps);
  
          video_st->st->codec->extradata = OSA_memAllocSR(OSA_HEAPID_DDR_CACHED_SR1, naluUnit.size + AV_INPUT_BUFFER_PADDING_SIZE, 32U);
  
          memcpy(video_st->st->codec->extradata, sps_pps , sizeof(sps_pps));
  
          memcpy(video_st->st->codec->extradata + sizeof(sps_pps), naluUnit.data, naluUnit.size);
  
          break;
  
      }
  
      nOffset += nPos;
  
      write_video_frame(oc, video_st, naluUnit);
  
      if (nOffset >= bitstreamBuf->fillLength) {
  
          FrameCounter++;
  
          break;
  
      }
  
  }
  
  
  
  static Int32 write_video_frame(AVFormatContext *oc, OutputStream *ost,
  
      NaluUnit bitstreamBuf) {
  
  Int32 ret;
  
  static Int32 waitkey = 1, ptsInc = 0;
  
  
  
  if (0 > ost->st->index) {
  
      Vps_printf("Stream index less than 0");
  
      return SYSTEM_LINK_STATUS_EFAIL;
  
  }
  
  AVStream *pst = oc->streams[ost->st->index];
  
  
  
  // Init packet
  
  AVPacket pkt;
  
  av_init_packet(&pkt);
  
  pkt.flags |= (0 >= getVopType(bitstreamBuf.data, bitstreamBuf.size))
  
      ? AV_PKT_FLAG_KEY
  
      : 0;
  
  pkt.stream_index = pst->index;
  
  
  
  // Wait for key frame
  
  if (waitkey) {
  
      if (0 == (pkt.flags & AV_PKT_FLAG_KEY)){
  
          return SYSTEM_LINK_STATUS_SOK;
  
      }
  
      else {
  
          waitkey = 0;
  
          Vps_printf("First frame");
  
      }
  
  }
  
  
  
  pkt.pts = (ptsInc) * (90000 / STREAM_FRAME_RATE);
  
  pkt.dts = (ptsInc) * (90000/STREAM_FRAME_RATE);
  
  
  
  pkt.duration = 3000;
  
  pkt.pos = -1;
  
  ptsInc++;
  
  ret = av_interleaved_write_frame(oc, &pkt);
  
  if (ret < 0) {
  
      Vps_printf("cannot write frame");
  
  }
  
  return SYSTEM_LINK_STATUS_SOK;

  }

• How can I quantitatively measure gstreamer H264 latency between source and display ?

  10 août 2018, par KevinM

  I have a project where we are using gstreamer , x264, etc, to multicast a video stream over a local network to multiple receivers (dedicated computers attached to monitors). We’re using gstreamer on both the video source (camera) systems and the display monitors.

  We’re using RTP, payload 96, and libx264 to encode the video stream (no audio).

  But now I need to quantify the latency between (as close as possible to) frame acquisition and display.

  Does anyone have suggestions that use the existing software ?

  Ideally I’d like to be able to run the testing software for a few hours to generate enough statistics to quantify the system. Meaning that I can’t do one-off tests like point the source camera at the receiving display monitor displaying a high resolution and manually calculate the difference...

  I do realise that using a pure software-only solution, I will not be able to quantify the video acquisition delay (i.e. CCD to framebuffer).

  I can arrange that the system clocks on the source and display systems are synchronised to a high accuracy (using PTP), so I will be able to trust the system clocks (else I will use some software to track the difference between the system clocks and remove this from the test results).

  In case it helps, the project applications are written in C++, so I can use C event callbacks, if they’re available, to consider embedding system time in a custom header (e.g. frame xyz, encoded at time TTT - and use the same information on the receiver to calculate a difference).

• First-party data explained : Benefits, use cases and best practices

  25 juillet, par Joe

  Third-party cookies are being phased out, and marketers who still depend on them for user insights need to find alternatives.

  Google delayed the complete deprecation of third-party cookies until early 2025, but many other browsers, such as Mozilla, Brave, and Safari, have already put a stop to them. Plus, looking at the number of data leak incidents, like the one where Twitter leaked 200 million user emails, collecting and using first-party data is a great alternative. 

  In this post, we explore the ins and outs of first-party data and examine how to collect it. We’ll also look at various use cases and best practices to implement first-party data collection.

  What is first-party data ?

  First-party data is information organisations collect directly from customers through their owned channels. 

  Organisations can capture data without intermediaries when people interact with their website, mobile app, social media accounts or other customer-facing systems.

  For example, businesses can track visitor behaviour, such as bounce rates and time spent browsing particular pages. This activity is considered first-party data when it occurs on the brand’s digital property.

  Some examples include :

  • Demographics : Age, gender, location, income level
  • Contact information : Email addresses, phone numbers
  • Behavioural insights : Topics of interest, content engagement, browsing history
  • Transactional data : Purchase history, shopping preferences

  A defining characteristic is that this information comes straight from the source, with the customer’s willingness and consent. This direct collection method is why first-party data is widely regarded as more reliable and accurate than second or third-party data. With browsers like Chrome fully phasing out third-party cookies by the end of 2025, the urgency for adopting more first-party data strategies is accelerating across industries.

  How to collect first-party data 

  Organisations can collect first-party data in various ways. 

  Website pixels

  In this method, organisations place small pieces of code that track visitor actions like page views, clicks and conversions. When visitors land on the page, the pixel activates and collects data about their behaviour without interrupting the user experience. 

  Website analytics tools

  With major browsers like Safari and Firefox already blocking third-party cookies (and Chrome is phasing them out soon, there’s even more pressure on organisations to adopt first-party data strategies.

  Website analytics tools like Matomo help organisations collect first-party data with features like visitor tracking and acquisition analysis to analyse the best channels to attract more users. 

  Multi-attribution modelling that helps businesses understand how different touchpoints (social media channels or landing pages) persuade visitors to take a desired action (like making a purchase). 

  

  (Image Source)

  Other activities include :

  • Cohort analysis 
  • Heatmaps and session recordings 
  • SEO keyword tracking
  • A/B testing 
  • Paid ads performance tracking

  

  Heatmap feature in Matomo

  Account creation on websites

  When visitors register on websites, they provide information like names, email addresses and often demographic details or preferences.

  Newsletters and subscriptions 

  With email subscriptions and membership programs, businesses can collect explicit data (preferences selected during signup) and implicit data (engagement metrics like open rates and click patterns).

  Gated content

  Whitepapers, webinars or exclusive articles often ask for contact information when users want access. This approach targets specific audience segments interested in particular topics.

  Customer Relationship Management (CRM) systems

  CRM platforms collect information from various touchpoints and centralise it to create unified customer profiles. These profiles include detailed user information, like interaction history, purchase records, service inquiries and communication preferences.

  Mobile app activity

  Mobile in-app behaviours can assist businesses in gathering data such as :

  • Precise location information (indicating where customers interact with the app)
  • Which features they use most often
  • How long they stay on different screens
  • Navigation patterns

  This mobile-specific data helps organisations understand how their customers behave on smaller screens and while on the move, insights that website data alone cannot provide.

  Point of Sale (PoS) systems

  Modern checkout systems don’t just process payments. PepsiCo proved this by growing its first-party data stores by more than 50% through integrated PoS systems. 

  Today’s PoS technology captures detailed information about each transaction :

  • Item(s) sold
  • Price (discounts, taxes, tip)
  • Payment type (card, cash, digital wallet)
  • Time and date
  • Loyalty/rewards number
  • Store/location

  Plus, when connected with loyalty programs where customers identify themselves (by scanning a card or entering a phone number), these systems link purchase information to individuals. 

  This creates valuable historical records showing how customer preferences evolve and offering insight into :

  • Which products are frequently purchased together
  • The time of the day, week, month, or year when items sell best
  • Which promotions or special offers are most effective

  Server-side tracking 

  Most websites track user behaviour through code that runs in the visitor’s web browser (client-side tracking). 

  Server-side tracking takes a different approach by collecting data directly on the company’s own servers. 

  Because the tracking happens on company servers rather than browsers, ad-blocking software doesn’t block it. 

  Organisations gain more consistent data collection and greater control over their customer information. This privacy-friendly approach lets companies get the data they need without relying on third-party tracking scripts.

  Now that we understand how organisations can gather first-party data, let us explore its use cases. 

  Use cases of first-party data 

  Businesses can use first-party data in many ways, from creating customer profiles to personalising user experiences.

  Developing comprehensive customer profiles

  First-party data can help create detailed customer profiles. 

  Here are some examples :

  • Demographic profiles : Age, gender, location, job role and other personal characteristics.
  • Behavioural profiles : Website activity, purchase history and engagement with marketing campaigns that focus on how users interact with businesses and their offerings. 
  • Psychographic profiles : Customer’s interests, values and lifestyle preferences.
  • Transactional profiles : Purchase patterns, including the types of products they buy, how often they purchase and their total spending.

  The benefit of developing these profiles is that businesses can then create specific campaigns for each profile, instead of running random campaigns. 

  For example, a subscription service business may have a behavioural profile of ‘inactive users’. To reignite interest, they can offer discounts or limited-time freebies to these users.

  Crafting relevant content

  First-party data shows what types of content customers engage with most. 

  If customers love watching videos, businesses can create more video content. If a blog gets more readership for its tech articles, it can focus on tech-related content to adjust to readers’ preferences. 

  Uncovering new marketing opportunities

  First-party data lets businesses analyse customer interactions in a way that can reveal untapped markets. 

  For example, if a company sees that many website visitors are from a particular region, it might consider launching campaigns in that area to boost sales. 

  Personalising experiences

  89% of decision-makers believe personalisation is key to business success in the next three years. 

  First-party data helps organisations to tailor experiences based on individual preferences. 

  

  For example, an e-commerce site can recommend products based on previous purchases or browsing history. Shoppers with abandoned carts can get reminders. 

  It’s also helpful to see how customers respond to different types of communication. Certain groups may prefer emails, and some may prefer text messages. Similarly, some users spend more time on quizzes and interactive content like wizards or calculators. 

  By analysing this, businesses can adjust their strategies so that users get a personal experience when they visit a website.

  Optimising operations

  The use cases of first-party data don’t just apply to the marketing domain. They’re also valuable for operations. When businesses analyse customer order patterns, they can spot the best locations for fulfilment centres that reduce shipping time and costs.

  For example, an online retailer might discover that most customers are concentrated in urban areas and decide to open fulfilment centres closer to those locations.

  Or, in the public sector, transport companies can use first-party data to optimise routes and fine-tune fare simulation tools. By analysing rider queries, travel preferences and interaction data, they can :

  • Prioritise high-demand routes during peak hours 
  • Adjust fare structures to reflect common trip or rider patterns
  • Make personalised travel suggestions based on individual user history.

  Benefits of first-party data 

  First-party data offers two significant benefits : accuracy and compliance. It comes directly from the customers and can be considered more accurate and reliable. But that’s not it. 

  First-party data aligns with many data privacy regulations, like the GDPR and CCPA. That’s because first-party data collection requires explicit consent, which means the data remains confidential. This builds compliance, and customers develop more trust in the business.

  Best practices to collect and manage first-party data 

  Though first-party data comes with many benefits, how should organisations collect and manage it ? What are the best practices ? Let’s take a look. 

  Define clear goals

  Though defining clear goals seems like overused advice, it’s one of the most important. If a business doesn’t know why it’s collecting first-party data, all the information gathering becomes purposeless. 

  Businesses can think of different goals to achieve from first-party data collection : improving customer relationships, enhancing personalisation or increasing ROI. 

  Once these goals are concrete, they can guide data collection strategies and help understand whether they’re working.

  Establish a privacy policy

  A privacy policy is a document that explains why a business is collecting a user’s data and what it will do with it. By being open and honest, this policy builds trust with customers, so customers feel safe sharing their information. 

  For example, an e-commerce privacy policy may read like : 

  “At (Business name), your privacy is important to us. We collect your information when you create an account or buy something. This information includes your name, email and purchase history. We use this data to give you a better shopping experience and suggest products that you’ll find useful. We follow all data privacy laws like GDPR to keep your personal information safe.” 

  For organisations that use Matomo, we suggest updating the privacy policy to explain how Matomo is used and what data it collects. Here’s a privacy policy template for Matomo users that can be easily copied and pasted. 

  For a GDPR compatible privacy policy, read How to complete your privacy policy with Matomo analytics under GDPR.

  Simplify consent processes

  Businesses should obtain explicit user consent before collecting their data, as shown in the image below. 

  

  (Image Source) 

  To do this, integrate user-friendly consent management platforms that let customers easily access, view, opt out of, or delete their information.

  To ensure consent practices align with GDPR standards, follow these key steps :
  

  GDPR-compliant consent checklist
  ✅ State the purpose clearly	Describe data usage in plain terms.
  ✅ Use granular opt-ins	Separate consents by purpose.
  ✅ Avoid pre-ticked boxes	Active choices only.
  ✅ Enable easy opt-out	Simple and accessible withdrawal.
  ✅ Log consent	Timestamp and record every opt-in.
  ✅ Review periodically	Audit for accuracy and relevance.

  Comply with platform-specific restrictions

  In addition to general consent practices, businesses must comply with platform-specific restrictions. This includes obtaining explicit permissions for :

  • Location services : Users must consent to sharing their location data.
  • Contact lists : Businesses need permission to access and use contact information.
  • Camera and microphone Use : Users must consent to using the camera and microphone 
  • Advertising IDs : On platforms like iOS, businesses must obtain consent to use advertising IDs. 

  For example, Zoom asks the user if it can access the camera and the microphone by default.

  Utilise multiple data collection channels

  Instead of relying on just one source to collect first-party data, it is better to use multiple channels. Gather first-party data from diverse sources such as websites, mobile apps, CRM systems, email campaigns, and in-store interactions (for richer datasets). This way, businesses get a more complete picture of their customers.

  Implementing a strong data governance framework with proper tooling, taxonomy, and maintenance practices is also vital for better data usability.

  Use privacy-focused analytics tools 

  Focus on not just collecting data but also doing it in a way that’s secure and ethical. 

  Use tools like Matomo to track user interactions and gather meaningful analytics. For example, Matomo heatmaps can give you a visual insight into where users click and scroll, all while following all the data privacy laws.

  

  (Image Source) 

  What is second-party data ? 

  Second-party data is information that one company collects from its customers and shares with another company. It’s like “second-hand” first-party data because it’s collected directly from customers but used by a different business.

  Companies purchase second-party data from trusted partners instead of getting it directly from the customer. For example, hotel chains can use customer insights from online travel agencies, like popular destinations and average stay lengths, to refine their pricing strategies and offer more relevant perks.

  When using second-party data, it’s essential to :

  • Be transparent : Share with customers that their data is being shared with partners. 
  • Conduct regular audits : Ensure the data is accurate and handled properly to maintain strong privacy standards. If their data standards don’t seem that great, consider looking elsewhere.

  What is third-party data ? 

  Third-party data is collected from various sources, such as public records, social media or other online platforms. It’s then aggregated and sold to businesses. Organisations get third-party data from data brokers, aggregators and data exchanges or marketplaces. 

  Some examples of third-party data include life events from user social media profiles, like graduation or facts about different organisations, like the number of employees and revenue.

  For example, a data broker might collect information about people’s interests from social media and sell it to a company that wants to target ads based on those interests.

  Third-party data often raises privacy concerns due to its collection methods. One major issue is the lack of transparency in how this data is obtained. 

  Consumers often don’t know that their information is being collected and sold by third-party brokers, leading to feelings of mistrust and violation of privacy. This is why data privacy guidelines have evolved. 

  What is zero-party data ? 

  Zero-party data is the information that customers intentionally share with a business. Some examples include surveys, product ratings and reviews, social media polls and giveaways.

  Organisations collect first-party data by observing user behaviours, but zero-party data is the information that customers voluntarily provide. 

  

  Zero-party data can provide helpful insights, but self-reported information isn’t always accurate. People don’t always do what they say. 

  For example, customers in a survey may share that they consider quality above all else when purchasing. Still, looking at their actual behaviour, businesses can see that they make a purchase only when there’s a clearance or a sale.

  First-party data can give a broader view of customer behaviours over time, which zero-party data may not always be able to capture. 

  Therefore, while zero-party data offers insights into what customers say they want, first-party data helps understand how they behave in real-world scenarios. Balancing both data types can lead to a deeper understanding of customer needs.

  Getting valuable customer insights without compromising privacy 

  Matomo is a powerful tool for organisations that want to collect first-party data. We’re a full-featured web analytics tool that offers features that allow businesses to track user interactions without compromising the user’s personal information. Below, we share how.

  Data ownership

  Matomo allows organisations to own their analytics data, whether on-premise or in their chosen cloud. This means we don’t share your data with anyone else. This aligns with GDPR’s requirement for data sovereignty and minimises third-party risks.

  Pseudonymisation of user IDs

  Matomo allows organisations to pseudonymise user IDs, replacing them with a salted hash function. 

  

  (Image Source)

  Since the user IDs have different names, no one can trace them back to a specific person.

  IP address anonymisation

  Data anonymisation refers to removing personally identifiable information (PII) from datasets so individuals can’t be readily identified.

  Matomo automatically anonymises visitor IP addresses, which helps respect user privacy. For example, if the visitor’s IP address is 199.513.1001.123, Matomo can mask it to 199.0.0.0. 

  It can also anonymise geo-location information, such as country, region and city, ensuring this data doesn’t directly identify users.

  

  (Image Source) 

  Consent management

  Matomo offers an opt-out option that organisations can add to their website, privacy policy or legal page. 

  Matomo tracks everyone by default, but visitors can opt out by clicking the opt-out checkbox. 

  Our DoNotTrack technology helps businesses respect user choices to opt out of tracking from specific websites, such as social media or advertising platforms. They can simply select the “Support Do Not Track preference.”

  These help create consent workflows and support audit trails for regulators. 

  Data storage and deletion

  Keeping visitor data only as long as necessary is a good practice by default. 

  To adhere to this principle, organisations can configure Matomo to automatically delete old raw data and old aggregated report data. 

  Here’s a quick case study summarising how Matomo features can help organisations collect first-party data. CRO:NYX found that Google Analytics struggled to capture accurate data from their campaigns, especially when running ads on the Brave browser, which blocks third-party cookies.

  They then switched to Matomo, which uses first-party cookies by default. This approach allowed them to capture accurate data from Brave users without putting user privacy at stake. 

  The value of Matomo in first-party data strategies 

  First-party data gives businesses a reliable way to connect with audiences and to improve marketing strategies. 

  Matomo’s ethical web analytics lets organisations collect and analyse this data while prioritising user privacy. 

  With over 1 million websites using Matomo, it’s a trusted choice for organisations of all sizes. As a cloud-hosted service and a fully self-hosted solution, Matomo supports organisations with strong data sovereignty needs, allowing them to maintain full control over their analytics infrastructure.

  Ready to collect first-party data while securing user information ? Start your free 21-day trial, no credit card required.