Recherche avancée

Sur d’autres sites (7795)

• How to Choose the Optimal Multi-Touch Attribution Model for Your Organisation

  13 mars 2023, par Erin — Analytics Tips

  If you struggle to connect the dots on your customer journeys, you are researching the correct solution. 

  Multi-channel attribution models allow you to better understand the users’ paths to conversion and identify key channels and marketing assets that assist them.

  That said, each attribution model has inherent limitations, which make the selection process even harder.

  This guide explains how to choose the optimal multi-touch attribution model. We cover the pros and cons of popular attribution models, main evaluation criteria and how-to instructions for model implementation. 

  Pros and Cons of Different Attribution Models 

  

  First Interaction 

  First Interaction attribution model (also known as first touch) assigns full credit to the conversion to the first channel, which brought in a lead. However, it doesn’t report other interactions the visitor had before converting.

  Marketers, who are primarily focused on demand generation and user acquisition, find the first touch attribution model useful to evaluate and optimise top-of-the-funnel (ToFU). 

  Pros 

  • Reflects the start of the customer journey
  • Shows channels that bring in the best-qualified leads 
  • Helps track brand awareness campaigns

  Cons 

  • Ignores the impact of later interactions at the middle and bottom of the funnel 
  • Doesn’t provide a full picture of users’ decision-making process 

  Last Interaction 

  Last Interaction attribution model (also known as last touch) shifts the entire credit allocation to the last channel before conversion. But it doesn’t account for the contribution of all other channels. 

  If your focus is conversion optimization, the last-touch model helps you determine which channels, assets or campaigns seal the deal for the prospect. 

  Pros 

  • Reports bottom-of-the-funnel events
  • Requires minimal data and configurations 
  • Helps estimate cost-per-lead or cost-per-acquisition

  Cons 

  • No visibility into assisted conversions and prior visitor interactions 
  • Overemphasise the importance of the last channel (which can often be direct traffic) 

  Last Non-Direct Interaction 

  Last Non-Direct attribution excludes direct traffic from the calculation and assigns the full conversion credit to the preceding channel. For example, a paid ad will receive 100% of credit for conversion if a visitor goes directly to your website to buy a product. 

  Last Non-Direct attribution provides greater clarity into the bottom-of-the-funnel (BoFU). events. Yet, it still under-reports the role other channels played in conversion. 

  Pros 

  • Improved channel visibility, compared to Last-Touch 
  • Avoids over-valuing direct visits
  • Reports on lead-generation efforts

  Cons 

  • Doesn’t work for account-based marketing (ABM) 
  • Devalues the quality over quantity of leads 

  Linear Model

  Linear attribution model assigns equal credit for a conversion to all tracked touchpoints, regardless of their impact on the visitor’s decision to convert.

  It helps you understand the full conversion path. But this model doesn’t distinguish between the importance of lead generation activities versus nurturing touches.

  Pros 

  • Focuses on all touch points associated with a conversion 
  • Reflects more steps in the customer journey 
  • Helps analyse longer sales cycles

  Cons 

  • Doesn’t accurately reflect the varying roles of each touchpoint 
  • Can dilute the credit if too many touchpoints are involved 

  Time Decay Model 

  Time decay models assumes that the closer a touchpoint is to the conversion, the greater its influence. Pre-conversion touchpoints get the highest credit, while the first ones are ranked lower (5%-5%-10%-15%-25%-30%).

  This model better reflects real-life customer journeys. However, it devalues the impact of brand awareness and demand-generation campaigns. 

  Pros 

  • Helps track longer sales cycles and reports on each touchpoint involved 
  • Allows customising the half-life of decay to improve reporting 
  • Promotes conversion optimization at BoFu stages

  Cons 

  • Can prompt marketers to curtail ToFU spending, which would translate to fewer qualified leads at lower stages
  • Doesn’t reflect highly-influential events at earlier stages (e.g., a product demo request or free account registration, which didn’t immediately lead to conversion)

  Position-Based Model 

  Position-Based attribution model (also known as the U-shaped model) allocates the biggest credit to the first and the last interaction (40% each). Then distributes the remaining 20% across other touches. 

  For many marketers, that’s the preferred multi-touch attribution model as it allows optimising both ToFU and BoFU channels. 

  Pros 

  • Helps establish the main channels for lead generation and conversion
  • Adds extra layers of visibility, compared to first- and last-touch attribution models 
  • Promotes budget allocation toward the most strategic touchpoints

  Cons 

  • Diminishes the importance of lead nurturing activities as more credit gets assigned to demand-gen and conversion-generation channels
  • Limited flexibility since it always assigns a fixed amount of credit to the first and last touchpoints, and the remaining credit is divided evenly among the other touchpoints

  How to Choose the Right Multi-Touch Attribution Model For Your Business 

  If you’re deciding which attribution model is best for your business, prepare for a heated discussion. Each one has its trade-offs as it emphasises or devalues the role of different channels and marketing activities.

  To reach a consensus, the best strategy is to evaluate each model against three criteria : Your marketing objectives, sales cycle length and data availability. 

  Marketing Objectives 

  Businesses generate revenue in many ways : Through direct sales, subscriptions, referral fees, licensing agreements, one-off or retainer services. Or any combination of these activities. 

  In each case, your marketing strategy will look different. For example, SaaS and direct-to-consumer (DTC) eCommerce brands have to maximise both demand generation and conversion rates. In contrast, a B2B cybersecurity consulting firm is more interested in attracting qualified leads (as opposed to any type of traffic) and progressively nurturing them towards a big-ticket purchase. 

  When selecting a multi-touch attribution model, prioritise your objectives first. Create a simple scoreboard, where your team ranks various channels and campaign types you rely on to close sales. 

  Alternatively, you can survey your customers to learn how they first heard about your company and what eventually triggered their conversion. Having data from both sides can help you cross-validate your assumptions and eliminate some biases. 

  Then consider which model would best reflect the role and importance of different channels in your sales cycle. Speaking of which….

  Sales Cycle Length 

  As shoppers, we spend less time deciding on a new toothpaste brand versus contemplating a new IT system purchase. Factors like industry, business model (B2C, DTC, B2B, B2BC), and deal size determine the average cycle length in your industry. 

  Statistically, low-ticket B2C sales can happen within just several interactions. The average B2B decision-making process can have over 15 steps, spread over several months. 

  That’s why not all multi-touch attribution models work equally well for each business. Time-decay suits better B2B companies, while B2C usually go for position-based or linear attribution. 

  Data Availability 

  Businesses struggle with multi-touch attribution model implementation due to incomplete analytics data. 

  Our web analytics tool captures more data than Google Analytics. That’s because we rely on a privacy-focused tracking mechanism, which allows you to collect analytics without showing a cookie consent banner in markets outside of Germany and the UK. 

  Cookie consent banners are mandatory with Google Analytics. Yet, almost 40% of global consumers reject it. This results in gaps in your analytics and subsequent inconsistencies in multi-touch attribution reports. With Matomo, you can compliantly collect more data for accurate reporting. 

  Some companies also struggle to connect collected insights to individual shoppers. With Matomo, you can cross-attribute users across browning sessions, using our visitors’ tracking feature. 

  When you already know a user’s identifier (e.g., full name or email address), you can track their on-site behaviours over time to better understand how they interact with your content and complete their purchases. Quick disclaimer, though, visitors’ tracking may not be considered compliant with certain data privacy laws. Please consult with a local authority if you have doubts. 

  How to Implement Multi-Touch Attribution

  Multi-touch attribution modelling implementation is like a “seek and find” game. You have to identify all significant touchpoints in your customers’ journeys. And sometimes also brainstorm new ways to uncover the missing parts. Then figure out the best way to track users’ actions at those stages (aka do conversion and events tracking). 

  Here’s a step-by-step walkthrough to help you get started. 

  Select a Multi-Touch Attribution Tool 

  The global marketing attribution software is worth $3.1 billion. Meaning there are plenty of tools, differing in terms of accuracy, sophistication and price.

  To make the right call prioritise five factors :

  • Available models : Look for a solution that offers multiple options and allows you to experiment with different modelling techniques or develop custom models. 
  • Implementation complexity : Some providers offer advanced data modelling tools for creating custom multi-touch attribution models, but offer few out-of-the-box modelling options. 
  • Accuracy : Check if the shortlisted tool collects the type of data you need. Prioritise providers who are less dependent on third-party cookies and allow you to identify repeat users. 
  • Your marketing stack : Some marketing attribution tools come with useful add-ons such as tag manager, heatmaps, form analytics, user session recordings and A/B testing tools. This means you can collect more data for multi-channel modelling with them instead of investing in extra software. 
  • Compliance : Ensure that the selected multi-attribution analytics software wouldn’t put you at risk of GDPR non-compliance when it comes to user privacy and consent to tracking/analysis. 

  Finally, evaluate the adoption costs. Free multi-channel analytics tools come with data quality and consistency trade-offs. Premium attribution tools may have “hidden” licensing costs and bill you for extra data integrations. 

  Look for a tool that offers a good price-to-value ratio (i.e., one that offers extra perks for a transparent price). 

  Set Up Proper Data Collection 

  Multi-touch attribution requires ample user data. To collect the right type of insights you need to set up : 

  • Website analytics : Ensure that you have all tracking codes installed (and working correctly !) to capture pageviews, on-site actions, referral sources and other data points around what users do on page. 
  • Tags : Add tracking parameters to monitor different referral channels (e.g., “facebook”), campaign types (e.g., ”final-sale”), and creative assets (e.g., “banner-1”). Tags help you get a clearer picture of different touchpoints. 
  • Integrations : To better identify on-site users and track their actions, you can also populate your attribution tool with data from your other tools – CRM system, A/B testing app, etc. 

  Finally, think about the ideal lookback window — a bounded time frame you’ll use to calculate conversions. For example, Matomo has a default windows of 7, 30 or 90 days. But you can configure a custom period to better reflect your average sales cycle. For instance, if you’re selling makeup, a shorter window could yield better results. But if you’re selling CRM software for the manufacturing industry, consider extending it.

  Configure Goals and Events 

  Goals indicate your main marketing objectives — more traffic, conversions and sales. In web analytics tools, you can measure these by tracking specific user behaviours. 

  For example : If your goal is lead generation, you can track :

  • Newsletter sign ups 
  • Product demo requests 
  • Gated content downloads 
  • Free trial account registration 
  • Contact form submission 
  • On-site call bookings 

  In each case, you can set up a unique tag to monitor these types of requests. Then analyse conversion rates — the percentage of users who have successfully completed the action. 

  To collect sufficient data for multi-channel attribution modelling, set up Goal Tracking for different types of touchpoints (MoFU & BoFU) and asset types (contact forms, downloadable assets, etc). 

  Your next task is to figure out how users interact with different on-site assets. That’s when Event Tracking comes in handy. 

  Event Tracking reports notify you about specific actions users take on your website. With Matomo Event Tracking, you can monitor where people click on your website, on which pages they click newsletter subscription links, or when they try to interact with static content elements (e.g., a non-clickable banner). 

  Using in-depth user behavioural reports, you can better understand which assets play a key role in the average customer journey. Using this data, you can localise “leaks” in your sales funnel and fix them to increase conversion rates.

  Test and Validated the Selected Model 

  A common challenge of multi-channel attribution modelling is determining the correct correlation and causality between exposure to touchpoints and purchases. 

  For example, a user who bought a discounted product from a Facebook ad would act differently than someone who purchased a full-priced product via a newsletter link. Their rate of pre- and post-sales exposure will also differ a lot — and your attribution model may not always accurately capture that. 

  That’s why you have to continuously test and tweak the selected model type. The best approach for that is lift analysis. 

  Lift analysis means comparing how your key metrics (e.g., revenue or conversion rates) change among users who were exposed to a certain campaign versus a control group. 

  In the case of multi-touch attribution modelling, you have to monitor how your metrics change after you’ve acted on the model recommendations (e.g., invested more in a well-performing referral channel or tried a new brand awareness Twitter ad). Compare the before and after ROI. If you see a positive dynamic, your model works great. 

  The downside of this approach is that you have to invest a lot upfront. But if your goal is to create a trustworthy attribution model, the best way to validate is to act on its suggestions and then test them against past results. 

  Conclusion

  A multi-touch attribution model helps you measure the impact of different channels, campaign types, and marketing assets on metrics that matter — conversion rate, sales volumes and ROI. 

  Using this data, you can invest budgets into the best-performing channels and confidently experiment with new campaign types. 

  As a Matomo user, you also get to do so without breaching customers’ privacy or compromising on analytics accuracy.

  Start using accurate multi-channel attribution in Matomo. Get your free 21-day trial now. No credit card required.

• Parsing The Clue Chronicles

  30 décembre 2018, par Multimedia Mike — Game Hacking

  A long time ago, I procured a 1999 game called Clue Chronicles : Fatal Illusion, based on the classic board game Clue, a.k.a. Cluedo. At the time, I was big into collecting old, unloved PC games so that I could research obscure multimedia formats.

  
  
  

  Surveying the 3 CD-ROMs contained in the box packaging revealed only Smacker (SMK) videos for full motion video which was nothing new to me or the multimedia hacking community at the time. Studying the mix of data formats present on the discs, I found a selection of straightforward formats such as WAV for audio and BMP for still images. I generally find myself more fascinated by how computer games are constructed rather than by playing them, and this mix of files has always triggered a strong “I could implement a new engine for this !” feeling in me, perhaps as part of the ScummVM project which already provides the core infrastructure for reimplementing engines for 2D adventure games.

  Tying all of the assets together is a custom high-level programming language. I have touched on this before in a blog post over a decade ago. The scripts are in a series of files bearing the extension .ini (usually reserved for configuration scripts, but we’ll let that slide). A representative sample of such a script can be found here :

  clue-chronicles-scarlet-1.txt

  What Is This Language ?
  At the time I first analyzed this language, I was still primarily a C/C++-minded programmer, with a decent amount of Perl experience as a high level language, and had just started to explore Python. I assessed this language to be “mildly object oriented with C++-type comments (‘//’) and reliant upon a number of implicit library functions”. Other people saw other properties. When I look at it nowadays, it reminds me a bit more of JavaScript than C++. I think it’s sort of a Rorschach test for programming languages.

  Strangely, I sort of had this fear that I would put a lot of effort into figuring out how to parse out the language only for someone to come along and point out that it’s a well-known yet academic language that already has a great deal of supporting code and libraries available as open source. Google for “spanish dolphins far side comic” for an illustration of the feeling this would leave me with.

  It doesn’t matter in the end. Even if such libraries exist, how easy would they be to integrate into something like ScummVM ? Time to focus on a workable approach to understanding and processing the format.

  Problem Scope
  So I set about to see if I can write a program to parse the language seen in these INI files. Some questions :

  1. How large is the corpus of data that I need to be sure to support ?
  2. What parsing approach should I take ?
  3. What is the exact language format ?
  4. Other hidden challenges ?

  To figure out how large the data corpus is, I counted all of the INI files on all of the discs. There are 138 unique INI files between the 3 discs. However, there are 146 unique INI files after installation. This leads to a hidden challenge described a bit later.

  What parsing approach should I take ? I worried a bit too much that I might not be doing this the “right” way. I’m trying to ignore doubts like this, like how “SQL Shame” blocked me on a task for a little while a few years ago as I concerned myself that I might not be using the purest, most elegant approach to the problem. I know I covered language parsing a lot time ago in university computer science education and there is a lot of academic literature to the matter. But sometimes, you just have to charge in and experiment and prototype and see what falls out. In doing so, I expect to have a better understanding of the problems that need to solved and the right questions to ask, not unlike that time that I wrote a continuous integration system from scratch because I didn’t actually know that “continuous integration” was the keyword I needed.

  Next, what is the exact language format ? I realized that parsing the language isn’t the first and foremost problem here– I need to know exactly what the language is. I need to know what the grammar are keywords are. In essence, I need to reverse engineer the language before I write a proper parser for it. I guess that fits in nicely with the historical aim of this blog (reverse engineering).

  Now, about the hidden challenges– I mentioned that there are 8 more INI files after the game installs itself. Okay, so what’s the big deal ? For some reason, all of the INI files are in plaintext on the CD-ROM but get compressed (apparently, according to file size ratios) when installed to the hard drive. This includes those 8 extra INI files. I thought to look inside the CAB installation archive file on the CD-ROM and the files were there… but all in compressed form. I suspect that one of the files forms the “root” of the program and is the launching point for the game.

  Parsing Approach
  I took a stab at parsing an INI file. My approach was to first perform lexical analysis on the file and create a list of 4 types : symbols, numbers, strings, and language elements ([]{}()=., :). Apparently, this is the kind of thing that Lex/Flex are good at. This prototyping tool is written in Python, but when I port this to ScummVM, it might be useful to call upon the services of Lex/Flex, or another lexical analyzer, for there are many. I have a feeling it will be easier to use better tools when I understand the full structure of the language based on the data available.
  
  The purpose of this tool is to explore all the possibilities of the existing corpus of INI files. To that end, I ran all 138 of the plaintext files through it, collected all of the symbols, and massaged the results, assuming that the symbols that occurred most frequently are probably core language features. These are all the symbols which occur more than 1000 times among all the scripts :

     6248 false
     5734 looping
     4390 scripts
     3877 layer
     3423 sequentialscript
     3408 setactive
     3360 file
     3257 thescreen
     3239 true
     3008 autoplay
     2914 offset
     2599 transparent
     2441 text
     2361 caption
     2276 add
     2205 ge
     2197 smackanimation
     2196 graphicscript
     2196 graphic
     1977 setstate
     1642 state
     1611 skippable
     1576 desc
     1413 delayscript
     1298 script
     1267 seconds
     1019 rect
  

  About That Compression
  I have sorted out at least these few details of the compression :

  bytes 0-3    "COMP" (a pretty strong sign that this is, in fact, compressed data)
  bytes 4-11   unknown
  bytes 12-15  size of uncompressed data
  bytes 16-19  size of compressed data (filesize - 20)
  bytes 20-    compressed payload
  

  The compression ratios are on the same order of gzip. I was hoping that it was stock zlib data. However, I have been unable to prove this. I wrote a Python script that scrubbed through the first 100 bytes of payload data and tried to get Python’s zlib.decompress to initialize– no luck. It’s frustrating to know that I’ll have to reverse engineer a compression algorithm that deals with just 8 total text files if I want to see this effort through to fruition.

  Update, January 15, 2019
  Some folks expressed interest in trying to sort out the details of the compression format. So I have posted a followup in which I post some samples and go into deeper details about things I have tried :

  Reverse Engineering Clue Chronicles Compression

  The post Parsing The Clue Chronicles first appeared on Breaking Eggs And Making Omelettes.

• FFmpeg encoding produces slightly incompatible MKV/MP4 container

  11 juin 2018, par james2048

  I’ve been using the FFmpeg libraries to read and write media files using the C API.

  So far, reading seems to be pretty straightforward. I am able to read frames which I can then process, convert to RGB, process, and then convert back to YUV420 to be encoded.

  The encoded files play back with VLC media player fine, and Windows Media Player if I have a codec pack installed. However, they do behave strangely : the stock Windows 10 player won’t play them, same for Adobe Premiere. Also thumbnailers don’t work on it.
  Basically it seems like nothing other than VLC or FFmpeg itself can play/process the file. I have seen this with both MP4 and MKV, so it is not a format-specific issue.

  The problems go away once you remux the file with FFmpeg, for example "ffmpeg -i input.mkv -c copy output.mkv". Everything can play the file correctly.
  Also, the "remuxing.c" sample from the official samples works as well, with the same library version and compilers that I’m using (Visual Studio 2017, FFmpeg compiled with MinGW). It will fix the file and make it playable in all software.

  I’m not sure what could be causing this. I also don’t understand what the remuxing "fixed". It must be a container issue as the frames aren’t touched by remuxing.
  I have analysed the output MKVs with FFprobe -show_packets. It seems to have budged the packet timestamps a little constant factor, and the output stream now has
  is_avc=true and nal_length_size=4 instead of is_avc=false and nal_length_size=0, but apart from that the files are identical.

  Now here’s the output of FFprobe with the 3 last test packets, stream info and format info for both streams. As you can see, they are identical except for a couple of field. But something in here must have been "fixed" during remuxing to make it work.

  [PACKET]
  
  codec_type=video
  
  stream_index=0
  
  pts=59050
  
  pts_time=59.050000
  
  dts=58890
  
  dts_time=58.890000
  
  duration=1
  
  duration_time=0.001000
  
  convergence_duration=N/A
  
  convergence_duration_time=N/A
  
  size=427
  
  pos=277358
  
  flags=__
  
  [/PACKET]
  
  [PACKET]
  
  codec_type=video
  
  stream_index=0
  
  pts=58970
  
  pts_time=58.970000
  
  dts=58970
  
  dts_time=58.970000
  
  duration=1
  
  duration_time=0.001000
  
  convergence_duration=N/A
  
  convergence_duration_time=N/A
  
  size=205
  
  pos=277792
  
  flags=__
  
  [/PACKET]
  
  [PACKET]
  
  codec_type=video
  
  stream_index=0
  
  pts=59130
  
  pts_time=59.130000
  
  dts=59050
  
  dts_time=59.050000
  
  duration=1
  
  duration_time=0.001000
  
  convergence_duration=N/A
  
  convergence_duration_time=N/A
  
  size=268
  
  pos=278004
  
  flags=__
  
  [/PACKET]
  
  [STREAM]
  
  index=0
  
  codec_name=h264
  
  codec_long_name=H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10
  
  profile=Main
  
  codec_type=video
  
  codec_time_base=1/2000
  
  codec_tag_string=[0][0][0][0]
  
  codec_tag=0x0000
  
  width=720
  
  height=576
  
  coded_width=720
  
  coded_height=576
  
  has_b_frames=2
  
  sample_aspect_ratio=N/A
  
  display_aspect_ratio=N/A
  
  pix_fmt=yuv420p
  
  level=50
  
  color_range=unknown
  
  color_space=unknown
  
  color_transfer=unknown
  
  color_primaries=unknown
  
  chroma_location=left
  
  field_order=progressive
  
  timecode=N/A
  
  refs=1
  
  is_avc=false
  
  nal_length_size=0
  
  id=N/A
  
  r_frame_rate=299/12
  
  avg_frame_rate=1000/1
  
  time_base=1/1000
  
  start_pts=0
  
  start_time=0.000000
  
  duration_ts=N/A
  
  duration=N/A
  
  bit_rate=N/A
  
  max_bit_rate=N/A
  
  bits_per_raw_sample=8
  
  nb_frames=N/A
  
  nb_read_frames=N/A
  
  nb_read_packets=737
  
  DISPOSITION:default=1
  
  DISPOSITION:dub=0
  
  DISPOSITION:original=0
  
  DISPOSITION:comment=0
  
  DISPOSITION:lyrics=0
  
  DISPOSITION:karaoke=0
  
  DISPOSITION:forced=0
  
  DISPOSITION:hearing_impaired=0
  
  DISPOSITION:visual_impaired=0
  
  DISPOSITION:clean_effects=0
  
  DISPOSITION:attached_pic=0
  
  DISPOSITION:timed_thumbnails=0
  
  TAG:DURATION=00:00:59.211000000
  
  [/STREAM]
  
  [FORMAT]
  
  filename=testEncLeft.mkv
  
  nb_streams=1
  
  nb_programs=0
  
  format_name=matroska,webm
  
  format_long_name=Matroska / WebM
  
  start_time=0.000000
  
  duration=59.211000
  
  size=278349
  
  bit_rate=37607
  
  probe_score=100
  
  TAG:COMMENT=Slickline Player Export
  
  TAG:ENCODER=Lavf57.83.100
  
  [/FORMAT]

  And the info after remuxing, which works :

  [PACKET]
  
  codec_type=video
  
  stream_index=0
  
  pts=59050
  
  pts_time=59.050000
  
  dts=58890
  
  dts_time=58.890000
  
  duration=1
  
  duration_time=0.001000
  
  convergence_duration=N/A
  
  convergence_duration_time=N/A
  
  size=427
  
  pos=277418
  
  flags=__
  
  [/PACKET]
  
  [PACKET]
  
  codec_type=video
  
  stream_index=0
  
  pts=58970
  
  pts_time=58.970000
  
  dts=58970
  
  dts_time=58.970000
  
  duration=1
  
  duration_time=0.001000
  
  convergence_duration=N/A
  
  convergence_duration_time=N/A
  
  size=205
  
  pos=277852
  
  flags=__
  
  [/PACKET]
  
  [PACKET]
  
  codec_type=video
  
  stream_index=0
  
  pts=59130
  
  pts_time=59.130000
  
  dts=59050
  
  dts_time=59.050000
  
  duration=1
  
  duration_time=0.001000
  
  convergence_duration=N/A
  
  convergence_duration_time=N/A
  
  size=268
  
  pos=278064
  
  flags=__
  
  [/PACKET]
  
  [STREAM]
  
  index=0
  
  codec_name=h264
  
  codec_long_name=H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10
  
  profile=Main
  
  codec_type=video
  
  codec_time_base=1/2000
  
  codec_tag_string=[0][0][0][0]
  
  codec_tag=0x0000
  
  width=720
  
  height=576
  
  coded_width=720
  
  coded_height=576
  
  has_b_frames=2
  
  sample_aspect_ratio=N/A
  
  display_aspect_ratio=N/A
  
  pix_fmt=yuv420p
  
  level=50
  
  color_range=unknown
  
  color_space=unknown
  
  color_transfer=unknown
  
  color_primaries=unknown
  
  chroma_location=left
  
  field_order=progressive
  
  timecode=N/A
  
  refs=1
  
  is_avc=true
  
  nal_length_size=4
  
  id=N/A
  
  r_frame_rate=299/12
  
  avg_frame_rate=1000/1
  
  time_base=1/1000
  
  start_pts=0
  
  start_time=0.000000
  
  duration_ts=N/A
  
  duration=N/A
  
  bit_rate=N/A
  
  max_bit_rate=N/A
  
  bits_per_raw_sample=8
  
  nb_frames=N/A
  
  nb_read_frames=N/A
  
  nb_read_packets=737
  
  DISPOSITION:default=1
  
  DISPOSITION:dub=0
  
  DISPOSITION:original=0
  
  DISPOSITION:comment=0
  
  DISPOSITION:lyrics=0
  
  DISPOSITION:karaoke=0
  
  DISPOSITION:forced=0
  
  DISPOSITION:hearing_impaired=0
  
  DISPOSITION:visual_impaired=0
  
  DISPOSITION:clean_effects=0
  
  DISPOSITION:attached_pic=0
  
  DISPOSITION:timed_thumbnails=0
  
  TAG:DURATION=00:00:59.212000000
  
  [/STREAM]
  
  [FORMAT]
  
  filename=fixedLeft.mkv
  
  nb_streams=1
  
  nb_programs=0
  
  format_name=matroska,webm
  
  format_long_name=Matroska / WebM
  
  start_time=0.000000
  
  duration=59.212000
  
  size=278409
  
  bit_rate=37615
  
  probe_score=100
  
  TAG:COMMENT=Slickline Player Export
  
  TAG:ENCODER=Lavf58.12.100
  
  [/FORMAT]

  Here is how I’m setting up the output context, for reference : it’s pretty standard, following the sample code.

  int ret;
  
  
  
  avformat_alloc_output_context2(&outputFormatCtx, nullptr, nullptr, outFilePath.c_str());
  
  
  
  av_dict_set(&outputFormatCtx->metadata, "comment", "FFmpeg Export", 0);
  
  
  
  if (!outputFormatCtx)
  
  {
  
      LOG_AND_THROW("Could not allocate output context");
  
  }
  
  
  
  outputVideoStream = avformat_new_stream(outputFormatCtx, nullptr);
  
  outputVideoStream->time_base = AVRational{ 1, AV_TIME_BASE }; // Stream timebase will be used by codec
  
  
  
  if (!outputVideoStream)
  
  {
  
      LOG_AND_THROW("Failed allocating output stream");
  
  }
  
  
  
  // defaults to "libx264"
  
  AVCodec *outCodec = avcodec_find_encoder_by_name(selectedCodecName.c_str());
  
  
  
  if (!outCodec)
  
  {
  
      LOG_AND_THROW("Failed finding output codec");
  
  }
  
  
  
  AVDictionary *opts = nullptr;
  
  
  
  if (selectedCodecName == "libx264")
  
  {
  
      opts = getX264CodecOptions();
  
  }
  
  
  
  encoderCtx = avcodec_alloc_context3(outCodec);
  
  
  
  if (!encoderCtx)
  
  {
  
      LOG_AND_THROW("Failed to allocate the encoder context");
  
  }
  
  
  
  encoderCtx->width = width;
  
  encoderCtx->height = height;
  
  encoderCtx->pix_fmt = AV_PIX_FMT_YUV420P;
  
  // time base for the frames we will provide to the encoder
  
  encoderCtx->time_base = AVRational{ 1, AV_TIME_BASE };
  
  // convert framerate from double to rational
  
  encoderCtx->framerate = AVRational{ (int)(frameRate * AV_TIME_BASE), AV_TIME_BASE};
  
  
  
  // Match encoderCtx time base for the stream
  
  outputVideoStream->time_base = encoderCtx->time_base;
  
  
  
  ret = avcodec_open2(encoderCtx, outCodec, &opts);
  
  
  
  if (ret < 0)
  
  {
  
      LOG_AND_THROW_PARAM("Cannot open video encoder for stream: %d", ret);
  
  }
  
  
  
  // Fill in some params for MP4 stream, details about encoder
  
  ret = avcodec_parameters_from_context(outputVideoStream->codecpar, encoderCtx);
  
  
  
  if (ret < 0)
  
  {
  
      LOG_AND_THROW_PARAM("Failed to copy encoder parameters to output stream: %d", ret);
  
  }
  
  
  
  if (outputFormatCtx->oformat->flags & AVFMT_GLOBALHEADER)
  
  {
  
      encoderCtx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
  
  }
  
  
  
  av_dump_format(outputFormatCtx, 0, filePath.c_str(), 1);
  
  
  
  // End of encoder settings, setting up MP4
  
  if (!(outputFormatCtx->oformat->flags & AVFMT_NOFILE))
  
  {
  
      ret = avio_open(&outputFormatCtx->pb, outFilePath.c_str(), AVIO_FLAG_WRITE);
  
  
  
      if (ret < 0)
  
      {
  
          LOG_AND_THROW_PARAMSTR("Could not open output file '%s'", outFilePath.c_str());
  
      }
  
  }
  
  
  
  ret = avformat_write_header(outputFormatCtx, nullptr);
  
  
  
  if (ret < 0)
  
  {
  
      LOG_AND_THROW_PARAM("Error occurred when opening output file for writing: %d", ret);
  
  }

  Can anyone help me figure out why the container is not playing properly ?

  Thanks in advance.

  -James