Recherche avancée

Sur d’autres sites (6859)

• The Ultimate List of Alternatives to Google Products

  2 août 2022, par Erin — Privacy

  For many businesses, Google products can play an integral part in the productivity, function and even success of the company. This is because Google has designed their digital ecosystem to infiltrate every aspect of your work and personal life at low-to-no cost.

  On the surface, this seems like a no-brainer. Why not have a cost-effective and seamlessly connected tech stack ? It’s the complete package. 

  From Gmail to Google Analytics, it becomes hard to untangle yourself from this intricate web Google has managed to spin. But like a web, you know there’s also a catch.

  This leads us to the big question… Why stop ?

  In this blog, we’ll cover :

  Why de-Google ?

  Google products are convenient and seemingly free. However, in recent years, Google’s name has become synonymous with privacy breaches, data leaks and illegal under the General Data Protection Regulation (GDPR).

  As their track record shows a glaring disregard for data protection, a growing list of EU member countries like Austria, France, Denmark and Italy have banned Google products, such as Google Analytics, Google Workspace and Google Chromebook.

  Google offers free products and services, but not out of altruism. There’s a trade-off. By using Google’s “free” products, your customers’ and your own online activity becomes a commodity that can be sold to advertisers.

  When the risks of using Google products are considered, it becomes clear the need to plot a pathway to de-Google your business. If you’re wondering how in the world to uncoil from this web, fortunately, there are plenty of privacy-friendly, secure alternatives to Google products that you can choose.

  Disclaimer : Below, we’ve tried our best to provide a comprehensive list of alternatives to Google products for businesses, but because you know your business best, we’d also encourage you to do your own research to ensure the tool will suit your unique needs.

  Best Google alternative tools for business

  Overall business tools

  Google Workspace alternatives

  Google Workspace isn’t GDPR compliant by default, so businesses are at risk of fines and reputational damage. More EU countries are reaching the same conclusion that Google products are violating EU law. Data Protection Authorities from Norway and Denmark have deemed Google Workspace illegal in accordance with the GDPR. 

  Nextcloud

  Nextcloud is an open-source and self-hosted productivity platform that offers a suite of services to replace the major features found in Google Workspace, such as Google Drive, Calendar, Docs, Forms and Tasks. 

  You can share files and collaborate without worrying about data being shared with unauthorised individuals or companies. As a self-hosted suite, you’re in full control of where your data is, who has access to it and can comply with the strictest of data protection legislations.

  

  Zoho

  Zoho is a Google Workspace alternative built on the same principles as Google’s productivity suite. It offers a suite of online office tools, including email, calendar and task management, but with an emphasis on privacy protection. Zoho doesn’t rely on advertising revenue to support their business which means your personal data will never be sold or used for targeted ads. 

  With over 75 million users globally, Zoho offers data encryption at rest and at transit, multi-factor authentication and complies with strict security standards set by HIPAA, the Cloud Security Alliance and the GDPR.

  

  Gmail alternatives

  Google only encrypts emails via STARTTLS. In other words, your data isn’t end-to-end encrypted and can be decrypted by them at any time. Gmail also has a history of allowing third-party app developers that work with Gmail to access private and personal Gmail messages for their own market research purposes.

  ProtonMail

  ProtonMail is a secure, open-source email service that provides end-to-end encryption, so only the sender and receiver can access the messages. Proton deliberately doesn’t possess the key needed to decrypt any part of the message, so you know your sensitive business information is always private. 

  To protect users from digital surveillance, they also provide enhanced tracking protections and don’t rely on ads, so your data isn’t mined for advertising purposes. Not only that, you can also sync ProtonMail with a host of other Google alternative products, such as Proton Calendar and Proton Drive.

  

  Mailfence

  Mailfence is a highly secure communications and planning platform that offers a complete email suite, as well as, Documents, a Calendar and Groups. It provides end-to-end encryption and comes with a built-in data loss prevention system that prevents unauthorised access to your sensitive information. 

  Mailfence is completely ad-free and promises to never commercialise its databases or share data with third parties for targeted ads.

  

  Tutanota

  Tutanota is an open-source email service known as one of the first to offer end-to-end encryption. It boasts a user-friendly interface and offers a fast, simple and secure email service that works on web and mobile platforms. Stringent security, in addition to TOTP and U2F for two-factor authentication means you control who has access to your email and messages. 

  It requires no phone number or personal information to register for a free account. In addition, Tutanota doesn’t earn money through ads, its servers are based in Europe and it is fully GDPR compliant.

  

  Google Calendar alternatives

  Calendars can contain a lot of personal information (who you are meeting, location, contact info, etc.), which is well worth keeping private. 

  Proton Calendar

  With Proton Calendar all event details – participants, locations, event names, descriptions and notes are end-to-end encrypted. It has a clean and easy-to-use interface, and you get a full set of advanced features to replace Google Calendar, such as the ability to create events and reminders, add multiple calendars and set up repeating events. You can easily sync all your calendars between mobile and desktop apps.

  

  Mailfence Calendar

  Mailfence Calendar lets you manage, schedule and track your events and meetings. Similar to Google Calendar, you can invite people to events using their Mailfence email IDs, but it doesn’t track your location or email address.

  

  Tutanota Calendar

  Tutanota Calendar offers built-in encryption, so no one else can decrypt and read your information.

  You can keep track of your appointments and meetings in a secure environment that only you have access to. You get features, such as day/week/month view, all-day events, recurring events, upcoming events view and shared calendars. You can also sync it with other apps such as Outlook.

  

  Nextcloud Calendar app

  Nextcloud also offers a Calendar app which easily syncs events from different devices with your Nextcloud account. You can integrate it with other Nextcloud apps like Contacts, Talk and Tasks.

  

  Google Drive alternatives

  The GDPR emphasises end-to-end encryption as a safeguard against data leaks, but Google Drive isn’t end-to-end encrypted, so Google has access to the data on its servers. 

  In their privacy policy, they also state that this data can be analysed for advertising purposes, so although you’re using “free” Cloud storage, users need to be aware that they’re paying for this by giving Google access to any and all data stored in Google Drive.

  Proton Drive

  Proton Drive is a secure and private Cloud storage service that provides you with an easy-to-use, customisable and secure file management system.

  It uses end-to-end encryption to secure your data and keep it safe from prying eyes. As you have full control over your data, you can decide how long it’s stored and who has access to it. You can also choose how much of your information is shared with other users.

  

  Nextcloud

  Nextcloud works on your own server, so you can access and share your data wherever you are. It’s a file hosting service that lets you store files, sync them across your devices and collaborate with others on projects. 

  It also provides encryption for all the files that you store on its servers, so you can rest assured that no one can see your information without your permission.

  

  Syncthing

  Syncthing is a free, open-source file synchronisation program that allows you to store and access your files wherever you are. It’s designed to be fast, secure and easy to use, making it a great alternative to Google Drive. 

  With Syncthing, you can sync files across multiple computers and mobile devices at once. So if you create, delete or modify files on one machine, they will automatically be replicated on other devices. Data is saved directly to a location you choose, so you can securely backup your data without needing a third-party cloud service.

  Google Docs alternatives

  Google states they can “collect information” from Google-hosted content such as Docs by means of automated scanning. 

  Not only does this stoke spying fears, it also raises concerns over who holds power over your content. If they look through your docs and decide that you’ve violated their terms of service, you can get locked out of your Google Docs – as was the case when a National Geographic crime reporter had her story “frozen” by Google.

  LibreOffice

  LibreOffice is a free, open-source office suite with all the features you need to create and edit documents, presentations and spreadsheets. It’s compatible with many different languages and all Microsoft Office file formats. 

  Unlike Google Docs, LibreOffice doesn’t store your documents on the Cloud. As it runs on your own computer, you maintain complete control and the data is kept as private and as secure as you wish. LibreOffice also has an online version that works with most web browsers and can be used on Windows, Mac and Linux operating systems. 

  The open-source nature ensures security as the code is constantly improved and scouted for vulnerabilities.

  

  Nextcloud Office

  Like Google Docs, Nextcloud Office lets you create new documents and spreadsheets and collaborate with teammates or colleagues. But unlike Google Docs, Nextcloud doesn’t collect any data on who is using its platform, or what they’re doing on it. You can even encrypt the files you store in Nextcloud, so no one else can see them unless you give them access to your account.

  

  Google Keep alternative

  Standard Notes

  Standard Notes is an open-source online notebook app that offers a variety of useful features, such as tasks, to-dos and spreadsheets. 

  Unlike Google Keep, which has access to your notes, Standard Notes is end-to-end encrypted, which protects all your information and keeps it securely synced across all your devices. Standard Notes supports text, images and audio notes. As open-source software, they value transparency and trust and don’t rely on tracking or intrusive ads.

  

  Google Chrome alternatives

  Google Chrome is notorious for stalking users and collecting information for their own gains. Their browser fuels their data gathering infrastructure by being able to collect info about your search history, location, personal data and product interaction data for “personalisation” purposes – essentially to build a profile of you to sell to advertisers.

  Firefox

  Firefox is one of the most secure browsers for privacy and is trusted by 220 million users. It easily compares with Chrome in terms of ease of use and performance. 

  On top of that it offers enhanced privacy protections, so you get a browser that doesn’t stalk you and isn’t riddled with ads.

  

• Introducing Crash Analytics for Matomo

  30 août 2023, par Erin — Community, Plugins

  Bugs and development go hand in hand. As code matures, it contends with new browser iterations, clashes with ad blockers and other software quirks, resulting in the inevitable emergence of bugs. In fact, a staggering 13% of all pageviews come with lurking JavaScript errors.

  Monitoring for crashes becomes an unrelenting task. Amidst this never-ending effort to remove bugs, a SurveyMonkey study unveils a shared reality : a resounding 66% of individuals have encountered bug-ridden websites.

  These bugs lead to problems like malfunctioning shopping carts, glitchy checkout procedures and contact forms that just won’t cooperate. But they’re not just minor annoyances – they pose a real danger to your conversion rates and revenue.

  According to a study, 58% of visitors are inclined to abandon purchases as a result of bugs, while an astonishing 75% are driven to completely abandon websites due to these frustrating experiences.

  Imagine a website earning approximately 25,000 EUR per month. Now, factor in errors occurring in 13% of all pageviews. The result ? A potential monthly loss of 1,885 EUR.

  Meet Crash Analytics

  Driven by our vision to create an empowering analytics product, we’re excited to introduce Crash Analytics, an innovative plugin for Matomo On-Premise that automatically tracks bugs on your website.

  

  By offering insights into the precise bug location and the user’s interactions that triggered it, along with details about their device type, browser and more, Crash Analytics empowers you to swiftly address crashes, leading to an improved user experience, higher conversion rates and revenue growth.

  Soon, Crash Analytics will become available to Matomo Cloud users as well, so stay tuned for further updates and announcements.

  Say goodbye to lost revenue – never miss a bug again

  Even if you put your website through the toughest tests, it’s hard to predict every little hiccup that can pop up across different browsers, setups and situations. Factors such as ad blockers, varying internet speeds for visitors and browser updates can add an extra layer of complexity.

  When these crashes happen, you want to know immediately. However, according to a study, only 29% of surveyed respondents would report the existence of the site bug to the website operator. These bugs that go unnoticed can really hurt your bottom line and conversion rates, causing you to lose out on revenue and leaving your users frustrated and disappointed.

  

  Crash Analytics is here to bridge this gap. Armed with scheduled reporting (via email or texts) and automated alert functionalities, you gain the power to instantly detect bugs as they occur on your site. This proactive approach ensures that even the subtlest of issues are brought to your attention promptly. 

  With automated reports and alerts, you can also opt to receive notifications when crashes increase or ignore specific crashes that you deem insignificant. This keeps you in the loop with only the issues that truly matter, helping you cut out the noise and take immediate action.

  

  Easily forward crash data to developers and synchronise the efforts of technical teams and marketing experts. Track emerging, disappearing and recurring errors, ensuring that crash data is efficiently relayed to developers to prioritise fixes that matter.

  

  Plus, your finger is always on the pulse with real-time reports that offer a live view of crashes happening at the moment, an especially helpful feature after deploying changes. Use annotations to mark deploys and correlate them with crash data, enabling you to quickly identify if a new bug is linked to recent updates or modifications.

  

  And with our mobile app, you can effortlessly stay connected to your website’s performance, conveniently accessing crash information anytime and anywhere. This ensures you’re in complete control of your site’s health, even when you’re on the move.

  Streamline bug resolution with combined web and crash analytics

  Crash Analytics for Matomo doesn’t just stop at pinpointing bug locations ; it goes a step further by providing you with a holistic perspective of user interactions. Seamlessly combining Matomo’s traditional and behavioural web analytics features—like segments, session recordings and visitor logs—with crash data, this integrated approach unveils a wealth of insights so you can quickly resolve bugs. 

  For instance, let’s say a user encounters a bug while attempting to complete a purchase on your e-commerce website. Crash Analytics reveals the exact point of failure, but to truly grasp the situation, you delve into the session recordings. These recordings offer a front-row seat to the user’s journey—every click and interaction that led to the bug. Session recordings are especially helpful when you are struggling to reproduce an issue.

  

  Additionally, the combination of visitor logs with crash data offers a comprehensive timeline of a user’s engagement. This helps you understand their activity leading up to the bug, such as pages visited, actions taken and devices used. Armed with these multifaceted insights, you can confidently pinpoint the root causes and address the crash immediately.

  With segments, you have the ability to dissect the data and compare experiences among distinct user groups. For example, you can compare mobile visitors to desktop visitors to determine if the issue is isolated or widespread and what impact the issue is having on the user experience of different user groups. 

  The combination of crash data with Matomo’s comprehensive web analytics equips you with the tools needed to elevate user experiences and ultimately drive revenue growth.

  Start in seconds, shape as needed : Your path to a 100% reliable website

  Crash Analytics makes the path to a reliable website simple. You don’t have to deal with intricate setups—crash detection starts without any configuration. 

  Plus, Crash Analytics excels in cross-stack proficiency, seamlessly extending its capabilities beyond automatically tracking JavaScript errors to covering server-side crashes as well, whether they occur in PHP, Android, iOS, Java or other frameworks. This versatile approach ensures that Crash Analytics comprehensively supports your website’s health and performance across various technological landscapes.

  Elevate your website with Crash Analytics

  Experience the seamless convergence of bug tracking and web analytics, allowing you to delve into user interactions, session recordings and visitor logs. With the flexibility of customising real-time alerts and scheduled reports, alongside cross-stack proficiency, Crash Analytics becomes your trusted ally in enhancing your website’s reliability and user satisfaction to increase conversions and drive revenue growth. Equip yourself to swiftly address issues and create a website where user experiences take precedence.

  Start your 30-day free trial of our Crash Analytics plugin today, and stay tuned for its availability on Matomo Cloud.

• Libavformat/FFMPEG : Muxing into mp4 with AVFormatContext drops the final frame, depending on the number of frames

  27 octobre 2020, par Galen Lynch

  I am trying to use libavformat to create a .mp4 video
with a single h.264 video stream, but the final frame in the resulting file
often has a duration of zero and is effectively dropped from the video.
Strangely enough, whether the final frame is dropped or not depends on how many
frames I try to add to the file. Some simple testing that I outline below makes
me think that I am somehow misconfiguring either the AVFormatContext or the
h.264 encoder, resulting in two edit lists that sometimes chop off the final
frame. I will also post a simplified version of the code I am using, in case I'm
making some obvious mistake. Any help would be greatly appreciated : I've been
struggling with this issue for the past few days and have made little progress.

  


  I can recover the dropped frame by creating a new mp4 container using ffmpeg
binary with the copy codec if I use the -ignore_editlist option. Inspecting
the file with a missing frame using ffprobe, mp4trackdump, or mp4file --dump, shows that the final frame is dropped if its sample time is exactly the
same the end of the edit list. When I make a file that has no dropped frames, it
still has two edit lists : the only difference is that the end time of the edit
list is beyond all samples in files that do not have dropped frames. Though this
is hardly a fair comparison, if I make a .png for each frame and then generate
a .mp4 with ffmpeg using the image2 codec and similar h.264 settings, I
produce a movie with all frames present, only one edit list, and similar PTS
times as my mangled movies with two edit lists. In this case, the edit list
always ends after the last frame/sample time.

  


  I am using this command to determine the number of frames in the resulting stream,
though I also get the same number with other utilities :

  


  ffprobe -v error -count_frames -select_streams v:0 -show_entries stream=nb_read_frames -of default=nokey=1:noprint_wrappers=1 video_file_name.mp4


  


  Simple inspection of the file with ffprobe shows no obviously alarming signs to
me, besides the framerate being affected by the missing frame (the target was
24) :

  


  $ ffprobe -hide_banner testing.mp4
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'testing.mp4':
  Metadata:
    major_brand     : isom
    minor_version   : 512
    compatible_brands: isomiso2avc1mp41
    encoder         : Lavf58.45.100
  Duration: 00:00:04.13, start: 0.041016, bitrate: 724 kb/s
    Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 100x100, 722 kb/s, 24.24 fps, 24 tbr, 12288 tbn, 48 tbc (default)
    Metadata:
      handler_name    : VideoHandler


  


  The files that I generate programatically always have two edit lists, one of
which is very short. In files both with and without a missing frame, the
duration one of the frames is 0, while all the others have the same duration
(512). You can see this in the ffmpeg output for this file that I tried to put
100 frames into, though only 99 are visible despite the file containing all 100
samples.

  


  $ ffmpeg -hide_banner -y -v 9 -loglevel 99 -i testing.mp4  &#xA;...&#xA;<edited to="to" remove="remove" the="the" class="class" printing="printing">&#xA;type:&#x27;edts&#x27; parent:&#x27;trak&#x27; sz: 48 100 948&#xA;type:&#x27;elst&#x27; parent:&#x27;edts&#x27; sz: 40 8 40&#xA;track[0].edit_count = 2&#xA;duration=41 time=-1 rate=1.000000&#xA;duration=4125 time=0 rate=1.000000&#xA;type:&#x27;mdia&#x27; parent:&#x27;trak&#x27; sz: 808 148 948&#xA;type:&#x27;mdhd&#x27; parent:&#x27;mdia&#x27; sz: 32 8 800&#xA;type:&#x27;hdlr&#x27; parent:&#x27;mdia&#x27; sz: 45 40 800&#xA;ctype=[0][0][0][0]&#xA;stype=vide&#xA;type:&#x27;minf&#x27; parent:&#x27;mdia&#x27; sz: 723 85 800&#xA;type:&#x27;vmhd&#x27; parent:&#x27;minf&#x27; sz: 20 8 715&#xA;type:&#x27;dinf&#x27; parent:&#x27;minf&#x27; sz: 36 28 715&#xA;type:&#x27;dref&#x27; parent:&#x27;dinf&#x27; sz: 28 8 28&#xA;Unknown dref type 0x206c7275 size 12&#xA;type:&#x27;stbl&#x27; parent:&#x27;minf&#x27; sz: 659 64 715&#xA;type:&#x27;stsd&#x27; parent:&#x27;stbl&#x27; sz: 151 8 651&#xA;size=135 4CC=avc1 codec_type=0&#xA;type:&#x27;avcC&#x27; parent:&#x27;stsd&#x27; sz: 49 8 49&#xA;type:&#x27;stts&#x27; parent:&#x27;stbl&#x27; sz: 32 159 651&#xA;track[0].stts.entries = 2&#xA;sample_count=99, sample_duration=512&#xA;sample_count=1, sample_duration=0&#xA;...&#xA;AVIndex stream 0, sample 99, offset 5a0ed, dts 50688, size 3707, distance 0, keyframe 1&#xA;Processing st: 0, edit list 0 - media time: -1, duration: 504&#xA;Processing st: 0, edit list 1 - media time: 0, duration: 50688&#xA;type:&#x27;udta&#x27; parent:&#x27;moov&#x27; sz: 98 1072 1162&#xA;...&#xA;</edited>

  


  The last frame has zero duration :

  


  $ mp4trackdump -v testing.mp4
...
mp4file testing.mp4, track 1, samples 100, timescale 12288
sampleId      1, size  6943 duration      512 time        0 00:00:00.000 S
sampleId      2, size  3671 duration      512 time      512 00:00:00.041 S
...
sampleId     99, size  3687 duration      512 time    50176 00:00:04.083 S
sampleId    100, size  3707 duration        0 time    50688 00:00:04.125 S


  


  Non-mangled videos that I generate have similar structure, as you can see in
this video that had 99 input frames, all of which are visible in the output.
Even though the sample_duration is set to zero for one of the samples in the
stss box, it is not dropped from the frame count or when reading the frames back
in with ffmpeg.

  


  $ ffmpeg -hide_banner -y -v 9 -loglevel 99 -i testing_99.mp4  
...
type:'elst' parent:'edts' sz: 40 8 40
track[0].edit_count = 2
duration=41 time=-1 rate=1.000000
duration=4084 time=0 rate=1.000000
...
track[0].stts.entries = 2
sample_count=98, sample_duration=512
sample_count=1, sample_duration=0
...
AVIndex stream 0, sample 98, offset 5d599, dts 50176, size 3833, distance 0, keyframe 1
Processing st: 0, edit list 0 - media time: -1, duration: 504
Processing st: 0, edit list 1 - media time: 0, duration: 50184
...


  


  $ mp4trackdump -v testing_99.mp4
...
sampleId     98, size  3814 duration      512 time    49664 00:00:04.041 S
sampleId     99, size  3833 duration        0 time    50176 00:00:04.083 S


  


  One difference that jumps out to me is that the mangled file's second edit list
ends at time 50688, which coincides with the last sample, while the non-mangled
file's edit list ends at 50184, which is after the time of the last sample
at 50176. As I mentioned before, whether the last frame is clipped depends on
the number of frames I encode and mux into the container : 100 input frames
results in 1 dropped frame, 99 results in 0, 98 in 0, 97 in 1, etc...

  


  Here is the code that I used to generate these files, which is a MWE script
version of library functions that I am modifying. It is written in Julia,
which I do not think is important here, and calls the FFMPEG library version
4.3.1. It's more or less a direct translation from of the FFMPEG muxing
demo, although the codec
context here is created before the format context. I am presenting the code that
interacts with ffmpeg first, although it relies on some helper code that I will
put below.

  


  The helper code just makes it easier to work with nested C structs in Julia, and
allows . syntax in Julia to be used in place of C's arrow (->) operator for
field access of struct pointers. Libav structs such as AVFrame appear as a
thin wrapper type AVFramePtr, and similarly AVStream appears as
AVStreamPtr etc... These act like single or double pointers for the purposes
of function calls, depending on the function's type signature. Hopefully it will
be clear enough to understand if you are familiar with working with libav in C,
and I don't think looking at the helper code should be necessary if you don't
want to run the code.

  


  # Function to transfer array to AVPicture/AVFrame
function transfer_img_buf_to_frame!(frame, img)
    img_pointer = pointer(img)
    data_pointer = frame.data[1] # Base-1 indexing, get pointer to first data buffer in frame
    for h = 1:frame.height
        data_line_pointer = data_pointer + (h-1) * frame.linesize[1] # base-1 indexing
        img_line_pointer = img_pointer + (h-1) * frame.width
        unsafe_copyto!(data_line_pointer, img_line_pointer, frame.width) # base-1 indexing
    end
end

# Function to transfer AVFrame to AVCodecContext, and AVPacket to AVFormatContext
function encode_mux!(packet, format_context, frame, codec_context; flush = false)
    if flush
        fret = avcodec_send_frame(codec_context, C_NULL)
    else
        fret = avcodec_send_frame(codec_context, frame)
    end
    if fret < 0 && !in(fret, [-Libc.EAGAIN, VIO_AVERROR_EOF])
        error("Error $fret sending a frame for encoding")
    end

    pret = Cint(0)
    while pret >= 0
        pret = avcodec_receive_packet(codec_context, packet)
        if pret == -Libc.EAGAIN || pret == VIO_AVERROR_EOF
             break
        elseif pret < 0
            error("Error $pret during encoding")
        end
        stream = format_context.streams[1] # Base-1 indexing
        av_packet_rescale_ts(packet, codec_context.time_base, stream.time_base)
        packet.stream_index = 0
        ret = av_interleaved_write_frame(format_context, packet)
        ret < 0 && error("Error muxing packet: $ret")
    end
    if !flush && fret == -Libc.EAGAIN && pret != VIO_AVERROR_EOF
        fret = avcodec_send_frame(codec_context, frame)
        if fret < 0 && fret != VIO_AVERROR_EOF
            error("Error $fret sending a frame for encoding")
        end
    end
    return pret
end

# Set parameters of test movie
nframe = 100
width, height = 100, 100
framerate = 24
gop = 0
codec_name = "libx264"
filename = "testing.mp4"

((width % 2 !=0) || (height % 2 !=0)) && error("Encoding error: Image dims must be a multiple of two")

# Make test images
imgstack = map(x->rand(UInt8,width,height),1:nframe);

pix_fmt = AV_PIX_FMT_GRAY8
framerate_rat = Rational(framerate)

codec = avcodec_find_encoder_by_name(codec_name)
codec == C_NULL && error("Codec '$codec_name' not found")

# Allocate AVCodecContext
codec_context_p = avcodec_alloc_context3(codec) # raw pointer
codec_context_p == C_NULL && error("Could not allocate AVCodecContext")
# Easier to work with pointer that acts like a c struct pointer, type defined below
codec_context = AVCodecContextPtr(codec_context_p)

codec_context.width = width
codec_context.height = height
codec_context.time_base = AVRational(1/framerate_rat)
codec_context.framerate = AVRational(framerate_rat)
codec_context.pix_fmt = pix_fmt
codec_context.gop_size = gop

ret = avcodec_open2(codec_context, codec, C_NULL)
ret < 0 && error("Could not open codec: Return code $(ret)")

# Allocate AVFrame and wrap it in a Julia convenience type
frame_p = av_frame_alloc()
frame_p == C_NULL && error("Could not allocate AVFrame")
frame = AVFramePtr(frame_p)

frame.format = pix_fmt
frame.width = width
frame.height = height

# Allocate picture buffers for frame
ret = av_frame_get_buffer(frame, 0)
ret < 0 && error("Could not allocate the video frame data")

# Allocate AVPacket and wrap it in a Julia convenience type
packet_p = av_packet_alloc()
packet_p == C_NULL && error("Could not allocate AVPacket")
packet = AVPacketPtr(packet_p)

# Allocate AVFormatContext and wrap it in a Julia convenience type
format_context_dp = Ref(Ptr{AVFormatContext}()) # double pointer
ret = avformat_alloc_output_context2(format_context_dp, C_NULL, C_NULL, filename)
if ret != 0 || format_context_dp[] == C_NULL
    error("Could not allocate AVFormatContext")
end
format_context = AVFormatContextPtr(format_context_dp)

# Add video stream to AVFormatContext and configure it to use the encoder made above
stream_p = avformat_new_stream(format_context, C_NULL)
stream_p == C_NULL && error("Could not allocate output stream")
stream = AVStreamPtr(stream_p) # Wrap this pointer in a convenience type

stream.time_base = codec_context.time_base
stream.avg_frame_rate = 1 / convert(Rational, stream.time_base)
ret = avcodec_parameters_from_context(stream.codecpar, codec_context)
ret < 0 && error("Could not set parameters of stream")

# Open the AVIOContext
pb_ptr = field_ptr(format_context, :pb)
# This following is just a call to avio_open, with a bit of extra protection
# so the Julia garbage collector does not destroy format_context during the call
ret = GC.@preserve format_context avio_open(pb_ptr, filename, AVIO_FLAG_WRITE)
ret < 0 && error("Could not open file $filename for writing")

# Write the header
ret = avformat_write_header(format_context, C_NULL)
ret < 0 && error("Could not write header")

# Encode and mux each frame
for i in 1:nframe # iterate from 1 to nframe
    img = imgstack[i] # base-1 indexing
    ret = av_frame_make_writable(frame)
    ret < 0 && error("Could not make frame writable")
    transfer_img_buf_to_frame!(frame, img)
    frame.pts = i
    encode_mux!(packet, format_context, frame, codec_context)
end

# Flush the encoder
encode_mux!(packet, format_context, frame, codec_context; flush = true)

# Write the trailer
av_write_trailer(format_context)

# Close the AVIOContext
pb_ptr = field_ptr(format_context, :pb) # get pointer to format_context.pb
ret = GC.@preserve format_context avio_closep(pb_ptr) # simply a call to avio_closep
ret < 0 && error("Could not free AVIOContext")

# Deallocation
avcodec_free_context(codec_context)
av_frame_free(frame)
av_packet_free(packet)
avformat_free_context(format_context)


  


  Below is the helper code that makes accessing pointers to nested c structs not a
total pain in Julia. If you try to run the code yourself, please enter this in
before the logic of the code shown above. It requires
VideoIO.jl, a Julia wrapper to libav.

  


  # Convenience type and methods to make the above code look more like C
using Base: RefValue, fieldindex

import Base: unsafe_convert, getproperty, setproperty!, getindex, setindex!,
    unsafe_wrap, propertynames

# VideoIO is a Julia wrapper to libav
#
# Bring bindings to libav library functions into namespace
using VideoIO: AVCodecContext, AVFrame, AVPacket, AVFormatContext, AVRational,
    AVStream, AV_PIX_FMT_GRAY8, AVIO_FLAG_WRITE, AVFMT_NOFILE,
    avformat_alloc_output_context2, avformat_free_context, avformat_new_stream,
    av_dump_format, avio_open, avformat_write_header,
    avcodec_parameters_from_context, av_frame_make_writable, avcodec_send_frame,
    avcodec_receive_packet, av_packet_rescale_ts, av_interleaved_write_frame,
    avformat_query_codec, avcodec_find_encoder_by_name, avcodec_alloc_context3,
    avcodec_open2, av_frame_alloc, av_frame_get_buffer, av_packet_alloc,
    avio_closep, av_write_trailer, avcodec_free_context, av_frame_free,
    av_packet_free

# Submodule of VideoIO
using VideoIO: AVCodecs

# Need to import this function from Julia's Base to add more methods
import Base: convert

const VIO_AVERROR_EOF = -541478725 # AVERROR_EOF

# Methods to convert between AVRational and Julia's Rational type, because it's
# hard to access the AV rational macros with Julia's C interface
convert(::Type{Rational{T}}, r::AVRational) where T = Rational{T}(r.num, r.den)
convert(::Type{Rational}, r::AVRational) = Rational(r.num, r.den)
convert(::Type{AVRational}, r::Rational) = AVRational(numerator(r), denominator(r))

"""
    mutable struct NestedCStruct{T}

Wraps a pointer to a C struct, and acts like a double pointer to that memory.
The methods below will automatically convert it to a single pointer if needed
for a function call, and make interacting with it in Julia look (more) similar
to interacting with it in C, except '->' in C is replaced by '.' in Julia.
"""
mutable struct NestedCStruct{T}
    data::RefValue{Ptr{T}}
end
NestedCStruct{T}(a::Ptr) where T = NestedCStruct{T}(Ref(a))
NestedCStruct(a::Ptr{T}) where T = NestedCStruct{T}(a)

const AVCodecContextPtr = NestedCStruct{AVCodecContext}
const AVFramePtr = NestedCStruct{AVFrame}
const AVPacketPtr = NestedCStruct{AVPacket}
const AVFormatContextPtr = NestedCStruct{AVFormatContext}
const AVStreamPtr = NestedCStruct{AVStream}

function field_ptr(::Type{S}, struct_pointer::Ptr{T}, field::Symbol,
                           index::Integer = 1) where {S,T}
    fieldpos = fieldindex(T, field)
    field_pointer = convert(Ptr{S}, struct_pointer) +
        fieldoffset(T, fieldpos) + (index - 1) * sizeof(S)
    return field_pointer
end

field_ptr(a::Ptr{T}, field::Symbol, args...) where T =
    field_ptr(fieldtype(T, field), a, field, args...)

function check_ptr_valid(p::Ptr, err::Bool = true)
    valid = p != C_NULL
    err && !valid && error("Invalid pointer")
    valid
end

unsafe_convert(::Type{Ptr{T}}, ap::NestedCStruct{T}) where T =
    getfield(ap, :data)[]
unsafe_convert(::Type{Ptr{Ptr{T}}}, ap::NestedCStruct{T}) where T =
    unsafe_convert(Ptr{Ptr{T}}, getfield(ap, :data))

function check_ptr_valid(a::NestedCStruct{T}, args...) where T
    p = unsafe_convert(Ptr{T}, a)
    GC.@preserve a check_ptr_valid(p, args...)
end

nested_wrap(x::Ptr{T}) where T = NestedCStruct(x)
nested_wrap(x) = x

function getproperty(ap::NestedCStruct{T}, s::Symbol) where T
    check_ptr_valid(ap)
    p = unsafe_convert(Ptr{T}, ap)
    res = GC.@preserve ap unsafe_load(field_ptr(p, s))
    nested_wrap(res)
end

function setproperty!(ap::NestedCStruct{T}, s::Symbol, x) where T
    check_ptr_valid(ap)
    p = unsafe_convert(Ptr{T}, ap)
    fp = field_ptr(p, s)
    GC.@preserve ap unsafe_store!(fp, x)
end

function getindex(ap::NestedCStruct{T}, i::Integer) where T
    check_ptr_valid(ap)
    p = unsafe_convert(Ptr{T}, ap)
    res = GC.@preserve ap unsafe_load(p, i)
    nested_wrap(res)
end

function setindex!(ap::NestedCStruct{T}, i::Integer, x) where T
    check_ptr_valid(ap)
    p = unsafe_convert(Ptr{T}, ap)
    GC.@preserve ap unsafe_store!(p, x, i)
end

function unsafe_wrap(::Type{T}, ap::NestedCStruct{S}, i) where {S, T}
    check_ptr_valid(ap)
    p = unsafe_convert(Ptr{S}, ap)
    GC.@preserve ap unsafe_wrap(T, p, i)
end

function field_ptr(::Type{S}, a::NestedCStruct{T}, field::Symbol,
                           args...) where {S, T}
    check_ptr_valid(a)
    p = unsafe_convert(Ptr{T}, a)
    GC.@preserve a field_ptr(S, p, field, args...)
end

field_ptr(a::NestedCStruct{T}, field::Symbol, args...) where T =
    field_ptr(fieldtype(T, field), a, field, args...)

propertynames(ap::T) where {S, T<:NestedCStruct{S}} = (fieldnames(S)...,
                                                       fieldnames(T)...)


  


  ---

  


  Edit : Some things that I have already tried

  


  

  • Explicitly setting the stream duration to be the same number as the number of frames that I add, or a few more beyond that

  


  • Explicitly setting the stream start time to zero, while the first frame has a PTS of 1

  


  • Playing around with encoder parameters, as well as gop_size, using B frames, etc.

  


  • Setting the private data for the mov/mp4 muxer to set the movflag negative_cts_offsets

  


  • Changing the framerate

  


  • Tried different pixel formats, such as AV_PIX_FMT_YUV420P

  


  


  Also to be clear while I can just transfer the file into another while ignoring the edit lists to work around this problem, I am hoping to not make damaged mp4 files in the first place.