Recherche avancée

Sur d’autres sites (4546)

• Stream Video from ios device

  29 avril 2014, par iJose

  I have integrated FFmpeg libraries to my project.

  Now

  i want stream a video that is captured using my ios device (iPhone, iPad, iPod)
  to an RTMP server using FFMpeg.

  I did post a similar question and googled for the same but did not end up with any solution.

  Can anyone of you suggest me a tutorial or atleast direct me as i am badly stuck over here and not able to move ahead.

  Kindly Pour your knowledge.

  Thanking you in advance.

• Cuda Memory Management : re-using device memory from C calls (multithreaded, ffmpeg), but failing on cudaMemcpy

  4 mars 2013, par Nuke Stollak

  I'm trying to CUDA-fy my ffmpeg filter that was taking over 90% of the CPU time, according to gprof. I first went from one core to OpenMP on 4 cores and got a 3.8x increase in frames encoded per second, but it's still too slow. CUDA seemed like the next natural step.

  I've gotten a modest (20% ?) increase by replacing one of my filter's functions with a CUDA kernel call, and just to get things up and running, I was cudaMalloc'ing and cudaMemcpy'ing on each frame. I suspected I would get better results if I weren't doing this each frame, so before I go ahead and move the rest of my code to CUDA, I wanted to fix this by allocating the memory before my filter is called and freeing it afterwards, but the device memory isn't having it. I'm only storing the device memory locations outside of code that knows about CUDA ; I'm not trying to use the data there, just save it for the next time I call a CUDA-aware function that needs it.

  Here's where I am so far :

  Environment : the last AMI Linux on EC2's GPU Cluster, latest updates installed. Everything is fairly standard.

  My filter is split into two files : vf_myfilter.c (compiled by gcc, like almost every other file in ffmpeg) and vf_myfilter_cu.cu (compiled by nvcc). My Makefile's link step includes -lcudart and both .o files. I build vf_myfilter_cu.o using (as one line)

  nvcc -I. -I./ -I/opt/nvidia/cuda/include $(CPPFLAGS) 
  
       -Xcompiler "$(CFLAGS)" 
  
        -c -o libfilter/vf_myfilter_cu.o libfilter/vf_myfilter_cu.cu

  When the variables (set by configure) are expanded, here's what I get, again all in one line but split up here for easier reading. I just noticed the duplicate include path directives, but it shouldn't hurt.

  nvcc -I. -I./ -I/opt/nvidia/cuda/include -I. -I./ -D_ISOC99_SOURCE 
  
      -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_POSIX_C_SOURCE=200112
  
      -D_XOPEN_SOURCE=600 -DHAVE_AV_CONFIG_H 
  
      -XCompiler "-fopenmp -std=c99 -fomit-frame-pointer -pthread -g 
  
                  -Wdeclaration-after-statment -Wall -Wno-parentheses 
  
                  -Wno-switch -Wno-format-zero-length -Wdisabled-optimization  
  
                  -Wpointer-arith -Wredundant-decls -Wno-pointer-sign 
  
                  -Wwrite-strings -Wtype-limits -Wundef -Wmissing-prototypes
  
                  -Wno-pointer-to-int-case -Wstrict-prototypes -O3 -fno-math-errno 
  
                  -fno-signed-zeros -fno-tree-vectorize 
  
                  -Werror=implicit-function-declaration -Werror=missing-prototypes 
  
                  -Werror=vla " 
  
      -c -o libavfilter/vf_myfilter_cu.o libavfilter/vf_myfilter_cu.cu

  vf_myfilter.c calls three functions from vf_myfilter_cu.cu file which handle memory and call the CUDA kernel code. I thought I would be able to save the device pointers from my memory initialization, which runs once per ffmpeg run, and re-use that space each time I called the wrapper for my kernel function, but when I cudaMemcpy from my host memory to my device memory that I stored, it fails with cudaInvalidValue. If I cudaMalloc my device memory on every frame, I'm fine.

  I plan on using pinned host memory, once I have everything up in CUDA code and have minimized the number of times I need to return to the main ffmpeg code.

  Steps taken :

  First sign of trouble : search the web. I found Passing a pointer to device memory between classes in CUDA and printed out the pointers at various places in my execution to ensure that the device memory values were the same everywhere, and they are. FWIW, they seem to start around 0x90010000.

  ffmpeg's configure gave me -pthreads, so I checked to see if my filter was being called from multiple threads according to how can I tell if pthread_self is the main (first) thread in the process ? and checking syscall(SYS_gettid) == getpid() to ensure that I'm not calling CUDA from different threads—I'm indeed in the primary thread at every step, according to those two funcs. I am still using OpenMP later around some for loops in the main .c filter function, but the calls to CUDA don't occur in those loops.

  Code Overview :

  ffmpeg provides me a MyfilterContext structure pointer on each frame, as well as on the filter's config_input and uninit routines (called once per file), so I added some *host_var and *dev_var variables (a few of each, float and unsigned char).

  There is a whole lot of code I skipped for this post, but most of it has to do with my algorithm and details involved in writing an ffmpeg filter. I'm actually using about 6 host variables and 7 device variables right now, but for demonstration I limited it to one of each.

  Here is, broadly, what my vf_myfilter.c looks like.

  // declare my functions from vf_myfilter_cu.cu 
  
  extern void cudaMyInit(unsigned char **dev_var, size_t mysize);
  
  extern void cudaMyUninit(unsigned char *dev_var);
  
  extern void cudaMyFunction(unsigned char *host_var, unsigned char *dev_var, size_t mysize);
  
  
  
  // part of the MyFilterContext structure, which ffmpeg keeps track of for me.
  
  typedef struct {
  
      unsigned char *host_var;
  
      unsigned char *dev_var;
  
  } MyFilterContext;
  
  
  
  // ffmpeg calls this function once per file, before any frames are processed.
  
  static int config_input(AVFilterLink *inlink) {
  
          // how ffmpeg passes me my context, fairly standard.
  
      MyfilterContext * myContext = inlink->dst->priv; 
  
          // compute the size one video plane of one frame of video
  
      size_t mysize = sizeof(unsigned char) * inlink->w * inlink->h;
  
          // av_mallocz is a malloc wrapper provided and required by ffmpeg
  
      myContext->host_var = (unsigned char*) av_mallocz(size);
  
          // Here's where I attempt to allocate my device memory.
  
      cudaMyInit( & myContext->dev_var, mysize);  
  
  }
  
  
  
  // Called once per frame of video
  
  static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *frame) {
  
      MyFilterContext *myContext = inlink->dst->priv;
  
  
  
      // sanity check to make sure that this isn't part of the multithreaded code
  
      if ( syscall(SYS_gettid) == getpid() ) 
  
          av_log(.... ); // This line never runs, so it's not threaded?
  
  
  
      // ...fill host_var with data from frame, 
  
      // set mysize to the size of the buffer
  
  
  
      // Call my wrapper function defined in the .cu file
  
      cudaMyFunction(myContext->host_var, myContext->dev_var, mysize);
  
  
  
      // ... take the results from host_var and apply them to frame
  
      // ... and return the processed frame to ffmpeg 
  
  }
  
  
  
  // called after everything else has happened:  free up the memory.
  
  static av_cold void uninit(AVFilterContext *ctx) {
  
      MyFilterContext *myContext = ctx->priv;
  
      // free my host_var
  
      if(myContext->host_var!=NULL) {
  
          av_free(myContext->host_var);
  
          myContext->host_var=NULL;
  
      }
  
      // free my dev_var
  
      cudaMyUninit(myContext->dev_var);
  
  }

  Here is, broadly, what my vf_myfilter_cu.cu looks like :

  // my kernel function that does the work.
  
  __global__ void myfunc(unsigned char *dev_var, size_t mysize) {
  
      // find the offset for this particular GPU thread to process
  
      // exit this function if the block/thread combo points to somewhere
  
      //     outside the frame
  
      // make sure we're less than mysize bytes from the beginning of dev_var
  
      // do things to dev_var[some_offset]
  
  } 
  
  // Allocate the device memory
  
  extern "C" void cudaMyInit(unsigned char **dev_var, size_t mysize) {
  
      if(cudaMalloc( (void**) dev_var, mysize) != cudaSuccess) {
  
          printf("Cannot allocate the memory\n");
  
      }
  
  }
  
  
  
  // Free the device memory.
  
  extern "C" void cudaMyUninit(unsigned char *dev_var) {
  
      cudaFree(dev_var);
  
  }
  
  
  
  // Copy data from the host to the device,
  
  // Call the kernel function, and 
  
  // Copy data from the device to the host.
  
  extern "C" void cudaMyFunction(
  
          unsigned char *host_var, 
  
          unsigned char *dev_var, 
  
          size_t mysize         ) 
  
  {
  
      cudaError_t cres;
  
  
  
      // dev_works is what I want to get rid of, but 
  
      // to make sure that there's not something more obvious going 
  
      // on, I made sure that my cudaMemcpy works if I'm allocating
  
      // the device memory in every frame.
  
      unsigned char *dev_works;  
  
      if(cudaMalloc( (void **) &dev_works, mysize)!=cudaSuccess) { 
  
          // I don't see this message
  
          printf("failed at per-frame malloc\n");
  
      }
  
  
  
      // THIS PART WORKS, copying host_var to dev_works
  
      cres=cudaMemcpy( (void *) dev_works, host_var, mysize, cudaMemcpyHostToDevice);
  
      if(cres!=cudaSuccess) {
  
          if(cres==cudaErrorInvalidValue) {
  
              // I don't see this message.
  
              printf("cudaErrorInvalidValue at per-frame cudaMemcpy\n");
  
          }
  
      }
  
  
  
      // THIS PART FAILS, copying host_var to dev_var
  
      cres=cudaMemcpy( (void *) dev_var, host_var, mysize, cudaMemcpyHostToDevice);
  
      if(cres!=cudaSuccess) {
  
          if(cres==cudaErrorInvalidValue) {
  
              // this is the error code that prints.
  
              printf("cudaErrorInvalidValue at per-frame cudaMemcpy\n");
  
          }
  
          // I check for other error codes, but they're not being hit.
  
      }
  
  
  
      // and this works with dev_works
  
      myfunc<<>>(dev_works, mysize);
  
  
  
      if(cudaMemcpy(host_var, dev_works, mysize, cudaMemcpyDeviceToHost)!=cudaSuccess) {
  
          // I don't see this message.
  
          printf("Failed to copy post-kernel func\n");
  
      }
  
  
  
      cudaFree(dev_works);
  
  
  
  }

  Any ideas ?

• Benefits and Shortcomings of Multi-Touch Attribution

  13 mars 2023, par Erin — Analytics Tips

  Few sales happen instantly. Consumers take their time to discover, evaluate and become convinced to go with your offer. 

  Multi-channel attribution (also known as multi-touch attribution or MTA) helps businesses better understand which marketing tactics impact consumers’ decisions at different stages of their buying journey. Then double down on what’s working to secure more sales. 

  Unlike standard analytics, multi-channel modelling combines data from various channels to determine their cumulative and independent impact on your conversion rates. 

  The main benefit of multi-touch attribution is obvious : See top-performing channels, as well as those involved in assisted conversions. The drawback of multi-touch attribution : It comes with a more complex setup process. 

  If you’re on the fence about getting started with multi-touch attribution, here’s a summary of the main arguments for and against it. 

  What Are the Benefits of Multi-Touch Attribution ?

  Remember an old parable of blind men and an elephant ?

  Each one touched the elephant and drew conclusions about how it might look. The group ended up with different perceptions of the animal and thought the others were lying…until they decided to work together on establishing the truth.

  Multi-channel analytics works in a similar way : It reconciles data from various channels and campaign types into one complete picture. So that you can get aligned on the efficacy of different campaign types and gain some other benefits too. 

  Better Understanding of Customer Journeys 

  On average, it takes 8 interactions with a prospect to generate a conversion. These interactions happen in three stages : 

  • Awareness : You need to introduce your company to the target buyers and pique their interest in your solution (top-of-the-funnel). 
  • Consideration : The next step is to channel this casual interest into deliberate research and evaluation of your offer (middle-of-the-funnel). 
  • Decision : Finally, you need to get the buyer to commit to your offer and close the deal (bottom-of-the-funnel). 

  You can analyse funnels using various attribution models — last-click, fist-click, position-based attribution, etc. Each model, however, will spotlight the different element(s) of your sales funnel. 

  For example, a single-touch attribution model like last-click zooms in on the bottom-of-the-funnel stage. You can evaluate which channels (or on-site elements) sealed the deal for the prospect. For example, a site visitor arrived from an affiliate link and started a free trial. In this case, the affiliate (referral traffic) gets 100% credit for the conversion. 

  This measurement tactic, however, doesn’t show which channels brought the customer to the very bottom of your funnel. For instance, they may have interacted with a social media post, your landing pages or a banner ad before that. 

  Multi-touch attribution modelling takes funnel analysis a notch further. In this case, you map more steps in the customer journey — actions, events, and pages that triggered a visitor’s decision to convert — in your website analytics tool.

  

  Then, select a multi-touch attribution model, which provides more backward visibility aka allows you to track more than one channel, preceding the conversion. 

  For example, a Position Based attribution model reports back on all interactions a site visitor had between their first visit and conversion. 

  A prospect first lands at your website via search results (Search traffic), which gets a 40% credit in this model. Two days later, the same person discovers a mention of your website on another blog and visits again (Referral traffic). This time, they save the page as a bookmark and revisit it again in two more days (Direct traffic). Each of these channels will get a 10% credit. A week later, the prospect lands again on your site via Twitter (Social) and makes a request for a demo. Social would then receive a 40% credit for this conversion. Last-click would have only credited social media and first-click — search engines. 

  The bottom line : Multi-channel attribution models show how different channels (and marketing tactics) contribute to conversions at different stages of the customer journey. Without it, you get an incomplete picture.

  Improved Budget Allocation 

  Understanding causal relationships between marketing activities and conversion rates can help you optimise your budgets.

  First-click/last-click attribution models emphasise the role of one channel. This can prompt you toward the wrong conclusions. 

  For instance, your Facebook ads campaigns do great according to a first-touch model. So you decide to increase the budget. What you might be missing though is that you could have an even higher conversion rate and revenue if you fix “funnel leaks” — address high drop-off rates during checkout, improve page layout and address other possible reasons for exiting the page.

  

  By knowing when and why people abandon their purchase journey, you can improve your marketing velocity (aka the speed of seeing the campaign results) and your marketing costs (aka the budgets you allocate toward different assets, touchpoints and campaign types). 

  Or as one of the godfathers of marketing technology, Dan McGaw, explained in a webinar :

  “Once you have a multi-touch attribution model, you [can] actually know the return on ad spend on a per-campaign basis. Sometimes, you can get it down to keywords. Sometimes, you can get down to all kinds of other information, but you start to realise, “Oh, this campaign sucks. I should shut this off.” And then really, that’s what it’s about. It’s seeing those campaigns that suck and turning them off and then taking that budget and putting it into the campaigns that are working”.

  More Accurate Measurements 

  The big boon of multi-channel marketing attribution is that you can zoom in on various elements of your funnel and gain granular data on the asset’s performance. 

  In other words : You get more accurate insights into the different elements involved in customer journeys. But for accurate analytics measurements, you must configure accurate tracking. 

  Define your objectives first : How do you want a multi-touch attribution tool to help you ? Multi-channel attribution analysis helps you answer important questions such as :

  • How many touchpoints are involved in the conversions ? 
  • How long does it take for a lead to convert on average ? 
  • When and where do different audience groups convert ? 
  • What is your average win rate for different types of campaigns ?

  Your objectives will dictate which multi-channel modelling approach will work best for your business — as well as the data you’ll need to collect. 

  At the highest level, you need to collect two data points :

  • Conversions : Desired actions from your prospects — a sale, a newsletter subscription, a form submission, etc. Record them as tracked Goals. 
  • Touchpoints : Specific interactions between your brand and targets — specific page visits, referral traffic from a particular marketing channel, etc. Record them as tracked Events. 

  Your attribution modelling software will then establish correlation patterns between actions (conversions) and assets (touchpoints), which triggered them. 

  The accuracy of these measurements, however, will depend on the quality of data and the type of attribution modelling used. 

  Data quality stands for your ability to procure accurate, complete and comprehensive information from various touchpoints. For instance, some data won’t be available if the user rejected a cookie consent banner (unless you’re using a privacy-focused web analytics tool like Matomo). 

  Different attribution modelling techniques come with inherent shortcomings too as they don’t accurately represent the average sales cycle length or track visitor-level data, which allows you to understand which customer segments convert best.

  Learn more about selecting the optimal multi-channel attribution model for your business.

  What Are the Limitations of Multi-Touch Attribution ?

  Overall, multi-touch attribution offers a more comprehensive view of the conversion paths. However, each attribution model (except for custom ones) comes with inherent assumptions about the contribution of different channels (e.g,. 25%-25%-25%-25% in linear attribution or 40%-10%-10%-40% in position-based attribution). These conversion credit allocations may not accurately represent the realities of your industry. 

  Also, most attribution models don’t reflect incremental revenue you gain from existing customers, which aren’t converting through analysed channels. For example, account upgrades to a higher tier, triggered via an in-app offer. Or warranty upsell, made via a marketing email. 

  In addition, you should keep in mind several other limitations of multi-touch attribution software.

  Limited Marketing Mix Analysis 

  Multi-touch attribution tools work in conjunction with your website analytics app (as they draw most data from it). Because of that, such models inherit the same visibility into your marketing mix — a combo of tactics you use to influence consumer decisions.

  Multi-touch attribution tools cannot evaluate the impact of :

  • Dark social channels 
  • Word-of-mouth 
  • Offline promotional events
  • TV or out-of-home ad campaigns 

  If you want to incorporate this data into your multi-attribution reporting, you’ll have to procure extra data from other systems — CRM, ad measurement partners, etc, — and create complex custom analytics models for its evaluation.

  Time-Based Constraints 

  Most analytics apps provide a maximum 90-day lookback window for attribution. This can be short for companies with longer sales cycles. 

  

  Marketing channels can be overlooked or underappreciated when your attribution window is too short. Because of that, you may curtail spending on brand awareness campaigns, which, in turn, will reduce the number of people entering the later stages of your funnel. 

  At the same time, many businesses would also want to track a look-forward window — the revenue you’ll get from one customer over their lifetime. In this case, not all tools may allow you to capture accurate information on repeat conversions — through re-purchases, account tier updates, add-ons, upsells, etc. 

  Again, to get an accurate picture you’ll need to understand how far into the future you should track conversions. Will you only record your first sales as a revenue number or monitor customer lifetime value (CLV) over 3, 6 or 12 months ? 

  The latter is more challenging to do. But CLV data can add another depth of dimension to your modelling accuracy. With Matomo, you set up this type of tracking by using our visitors’ tracking feature. We can help you track select visitors with known identifiers (e.g. name or email address) to discover their visiting patterns over time. 

  

  Limited Access to Raw Data 

  In web analytics, raw data stands for unprocessed website visitor information, stripped from any filters, segmentation or sampling applied. 

  Data sampling is a practice of analysing data subsets (instead of complete records) to extrapolate findings towards the entire data set. Google Analytics 4 applies data sampling once you hit over 500k sessions at the property level. So instead of accurate, real-life reporting, you receive approximations, generated by machine learning models. Data sampling is one of the main reasons behind Google Analytics’ accuracy issues. 

  In multi-channel attribution modelling, usage of sampled data creates further inconsistencies between the reports and the actual state of affairs. For instance, if your website generates 5 million page views, GA multi-touch analytical reports are based on the 500K sample size aka only 90% of the collected information. This hardly represents the real effect of all marketing channels and can lead to subpar decision-making. 

  With Matomo, the above is never an issue. We don’t apply data sampling to any websites (no matter the volume of traffic) and generate all the reports, including multi-channel attribution ones, based on 100% real user data. 

  AI Application 

  On the other hand, websites with smaller traffic volumes often have limited sampling datasets for building attribution models. Some tracking data may also be not available because the visitor rejected a cookie banner, for instance. On average, less than 50% of users in Australia, France, Germany, Denmark and the US among other countries always consent to all cookies. 

  To compensate for such scenarios, some multi-touch attribution solutions apply AI algorithms to “fill in the blanks”, which impacts the reporting accuracy. Once again, you get approximate data of what probably happened. However, Matomo is legally exempt from showing a cookie consent banner in most EU markets. Meaning you can collect 100% accurate data to make data-driven decisions.

  Difficult Technical Implementation 

  Ever since attribution modelling got traction in digital marketing, more and more tools started to emerge.

  

  Most web analytics apps include multi-touch attribution reports. Then there are standalone multi-channel attribution platforms, offering extra features for conversion rate optimization, offline channel tracking, data-driven custom modelling, etc. 

  Most advanced solutions aren’t available out of the box. Instead, you have to install several applications, configure integrations with requested data sources, and then use the provided interfaces to code together custom data models. Such solutions are great if you have a technical marketer or a data science team. But a steep learning curve and high setup costs make them less attractive for smaller teams. 

  Conclusion 

  Multi-touch attribution modelling lifts the curtain in more steps, involved in various customer journeys. By understanding which touchpoints contribute to conversions, you can better plan your campaign types and budget allocations. 

  That said, to benefit from multi-touch attribution modelling, marketers also need to do the preliminary work : Determine the key goals, set up event and conversion tracking, and then — select the optimal attribution model type and tool. 

  Matomo combines simplicity with sophistication. We provide marketers with familiar, intuitive interfaces for setting up conversion tracking across the funnel. Then generate attribution reports, based on 100% accurate data (without any sampling or “guesstimation” applied). You can also get access to raw analytics data to create custom attribution models or plug it into another tool ! 

  Start using accurate, easy-to-use multi-channel attribution with Matomo. Start your free 21-day trial now. No credit card requried.