
[Descript](https://www.descript.com/) provides transcription as part of their service, but if you already have transcripts, why not use them?

You can use this command to generate a Descript compatible transcript from a DeepGram transcript using [`jq`](https://stedolan.github.io/jq/).

You'll need to update the speaker labels and may need to make some minor corrections like joining split paragraphs from the same speaker due to mislabelling before importing.

<Gist id="e8998234d0a6e0d93d523d6ba1d54011" />


Use DeepGram transcripts in your Descript projects.

Convert DeepGram to Descript transcript format


There don't appear to be any social-media schedulers that support Mastodon yet, although there are a couple cross-posters to/from Twitter. If, however, you need to programmatically post to Mastodon through some service like [Make](https://www.make.com/en/register?pc=michele) (affiliate link) or [Zapier](https://zapier.com/), Mastodon conveniently has an API that you can use.

## Set up an Access Token

1. Create an application at `https://[YOUR MASTODON SERVER]/settings/applications` by clicking on **New Application**.

2. Set the **Application Name**, don't change the **Redirect URI**, and under **Scopes** check `write:statuses` and if you want to attach images `write:media`. You can uncheck the rest.

Once that is created, the application should now give you a **Client key**, **Client secret**, and **Your access token**. You only need the last.

## Post a Status

If you're setting up some sort of automation service, the module you're looking for will be `HTTP` in [Make](https://www.make.com/en/register?pc=michele) (affiliate link), the `POST` webhook in Zapier, or webhook in IFTTT.

Skip the next section if you don't need to attach media to your status, but even if I'm sharing a link, I prefer to attach an image over using the Mastodon link preview.

### Step 1. Upload media

Make a `POST` call to:

```
https://[YOUR MASTODON SERVER]/api/v1/media?access_token=[YOUR ACCESS TOKEN]
```

Set the type to `multipart/form-data` and attach your image (not an image URL) to the `file` field.

![My Mastodon publishing workflow on Make](make.jpg)

If like me you only have access to an image URL in your workflow, you'll also need to do some sort of file fetch. [Make](https://www.make.com/en/register?pc=michele) (affiliate link) conveniently has a 'Get a file' module for just such an occasion.

This call will return an object containing a media `id` that you will need for the next step.

More info: [Documentation](https://docs.joinmastodon.org/methods/media/) for the `/media` endpoint on Mastodon.

### Step 2. Post the status

Make a `POST` call to:

```
https://[YOUR MASTODON SERVER]/api/v1/statuses?access_token=[YOUR ACCESS TOKEN]
```

Set the type to `application/x-www-form-urlencoded` and pass the `status` field containing your status message. If you are attaching an image as well, pass the `media_ids[]` field with the media `id` you retrieved in the previous step.

More info: [Documentation](https://docs.joinmastodon.org/methods/statuses/) for the `/statuses` endpoint on Mastodon.

***

### Affiliate Promotion

I use [Make](https://www.make.com/en/register?pc=michele) for my personal, creator, and business automation needs. I am also an affiliate, so if you use my link to sign up for a [Make](https://www.make.com/en/register?pc=michele) account, you will also receive 1 month of Make's Pro plan free with 10,000 ops.


Use web requests to automate or programmatically post to Mastodon with Make.

Programmatically Post to Mastodon with Make


```
ffprobe -loglevel panic \
    -show_entries stream=bits_per_raw_sample \
    -select_streams v \
    filename.mp4
```


A beginners' guide to rendering intermediaries in DaVinci Resolve.

Rendering DNxHD/DNxHR intermediaries in DaVinci Resolve


I recently migrated this site to Next.JS from Gatsby. I wish I had a good reason for this, but I don't.

The Gatsby site used MDX and I wanted to carry that over. Little did I know what a pain in the arse it is to get MDX working *just so* on Next.JS.

I needed a setup that supported:

* frontmatter
* inlined components
* colocated images
* presentation templates

Next.js has [`@next/mdx`](https://www.npmjs.com/package/@next/mdx) which supports inlined components, and I guess colocated images through imports, but not frontmatter. Also, presentation templates need to be imported inline which is ugly, IMO. I could live with the image imports, but having to import the same components into every MDX file that I needed was not optimal. It's nice that you can keep your `mdx` files in `pages/` though.

So onward to [`next-mdx-remote`](https://www.npmjs.com/package/next-mdx-remote). This supports frontmatter using `grey-matter`, and you can pass common inline components through the template which you can set up through Next.JS dynamic routes. Ace. But no colocated images. In fact, images can only be served through `public/`. I attempted to dynamically `require` or `import` them. I tried a variation on [this solution](https://stackoverflow.com/a/65681762/6996864) to load the images, but kept getting runtime errors. Alas, etc.

Resolving that I didn't have the time to faff around with this just now (procrastination task), my solution was to use [`copy-webpack-plugin`](https://www.npmjs.com/package/copy-webpack-plugin) and have webpack copy the images to `public/`. I don't like it, but it works, and I can figure out if there's a nicer way of doing this later.

```javascript:title=next.config.js
webpack: (config) => {
    config.plugins.push(
        new CopyPlugin({
            patterns: [
                {
                    from: path.join(__dirname, 'path/**/*.jpg'),
                    to: path.join(__dirname, 'public/[path][name][ext]'),
                },
                ...
            ],
        })
    );
}
```

Update the `from` to point to where your colocated images will be, and the `to` will match the directory structure in `public/`. You also need to use `path.join` or whatever you want to use to have the full path. Relative paths won't work here.

You'll now be able to use markdown image syntax to reference the image:

```markdown
![Image description](colocated-image.jpg)
```

This will generate an `<img />` tag, which you can replace in your template by passing an `img` component to `MDXRemote`. You can replace it with `next/image` or a custom image component. `path` is a variable set to the path to the `mdx` file.

```javascript
const components = (path) => ({
    img: (props) => {
        return <Image {...props} src={`/assets/${path}/${props.src}`} fill lazy />;
    }
});

return (
    <MDXRemote {...mdxSource} components={components(path)} />
);
```

## See also

* [How to use images in a `.mdx` file outside of `public/` folder while using `next-mdx-remote` in Next JS? (StackOverflow)](https://stackoverflow.com/a/65681762/6996864))


An inelegant workaround to use colocated images with MDX on Next.JS.

Colocated images with MDX and Next.JS


There isn't a way to add custom STT adapters to [autoEdit](https://www.autoedit.io/), but you can modify the `transcriptions.json` directly.

Here's a fragment that will allow you to generate an autoEdit compatible transcript from a DeepGram transcript using [`jq`](https://stedolan.github.io/jq/).

There are a few modifications you will need to make to this gist to complete it for your own setup, but the following command will pull the bits of data you need and you can use variables to fill in the rest.

Just remember to take a backup of your current `transcriptions.json` file before you modify/replace it.

<Gist id="4b4f61c4e7b1c24c6a70f512430e737d" />


Use DeepGram as your Speech-to-Text (STT) engine in autoEdit 3.

Convert DeepGram to autoEdit transcript format


This is specifically if you're using [`sharp`](https://github.com/lovell/sharp) in [Next.js](https://nextjs.org/) API endpoints, which [Netlify](https://www.netlify.com/) deploy as [functions](https://docs.netlify.com/functions/overview/). It might be relevant even if you're *not* using Next.js, but I haven't tested this.

Netlify may fail to build, or the build will be successful but the API endpoint will crash/500 when invoked.

I was getting successful builds, but the endpoint would fail, and the Netlify function log would report `Error: Cannot find module 'sharp'` because it seems Netlify excludes this package for Reasons(TM).

[Next.js documentation](https://nextjs.org/docs/messages/sharp-missing-in-production) recommends adding the `NEXT_SHARP_PATH` environment variable:

```bash
NEXT_SHARP_PATH=/tmp/node_modules/sharp
```

But this doesn't affect Netlify functions. Good to have, though.

Another recommendation was to add `sharp` to `external_node_modules` in `netlify.toml`, which explicitly tells Netlify which external modules to include in the bundle:

```text:title=netlify.toml
[functions]
  external_node_modules = ["sharp"]
```

Nice thought, but this didn't change anything for me.

What did work for me was using a package alias to give the `sharp` package a custom name so that it doesn't get filtered out. [This ticket](https://github.com/netlify/next-runtime/issues/1195#issuecomment-1030533349)[1] uses the `yarn` syntax, but the `npm` syntax is similar:

```bash
npm i some-alias@npm:package@version
```

This allowed the package to be found, but the package build was now failing with the error `Module parse failed: Unexpected character '' (1:0)`. I've lost where I found this solution, but adding this to the `webpack` config in `next.config.js` worked for me:

```javascript:title=next.config.js
config.module.rules.push({
    test: /\.node$/,
    use: "node-loader"
});
```

Adjust the syntax to whatever it is you're doing in your webpack config.

Anyway, this took far longer than I would have liked to resolve, hopefully this saves you some time.

---

[1] Further down, another user suggested creating a separate plugin that forcibly includes the `sharp` module. Tried this, didn't work for me.


Deploy sharp with Next.js on Netlify


If you've tried deploying [`node-canvas`](https://github.com/Automattic/node-canvas) on Netlify, you may have encountered a few errors.

## Incompatible Architecture

If you're deploying to Netlify using the CLI and you're not running linux, the errors may involve complaints about incompatible architecture.

`node-canvas` will build its binaries based on the architecture doing the install, so if you're deploying what you built locally (not linux) to Netlify (linux), it will complain. Easiest thing here is to do deploys via the Netlify's auto-deploy or via the UI so that the packages are built on the right architecture.

There's a way to `npm install` forcing the architecture, but at first thought this sounds like it may not run or build locally if it depends on the availability of local libs. Not sure, haven't tried.

## Bundle Size Exceeded

If you're using `node-canvas` in functions you may get a successful build, but see an error to the effect of:

`The function zip XXX.zip size is X MB, which is larger than the maximum supported size of Y MB`

It will then show you the list of large files contributing to this issue, and they'll most likely be `.so` files in the `node-canvas` directory. The biggest offender tends to be `librsvg`.

If you need svg support, I'm sorry.

If you don't need svg support, the good news is that [svg support is optional](https://github.com/Automattic/node-canvas/issues/1954) in `node-canvas`. *You just* have to build it without the modules you don't want.

The bad news is that while there are instructions for how to do this on the `node-canvas` [wiki](https://github.com/Automattic/node-canvas/wiki), getting it going on Netlify is not entirely straight-forward.

If you're building on linux, this may work if you do the custom build locally then deploy via CLI. If you're not using linux, you'll likely encounter the architecture issue above.

One solution I saw was to [use a Docker/multipass instance to build a custom version of `node-canvas`](https://answers.netlify.com/t/node-canvas-error-libuuid-so-1-cannot-open-shared-object-file-no-such-file-or-directory/30179/6) then as part of the build process, copy those files the shared instance folder into `node_modules` before running the app build, but that sounded like a right pain in the derrière.

Some people said that worked for them though, so yay for them.

## My Solution

Use [`pureimage`](https://github.com/joshmarinacci/node-pureimage) instead.

It's not entirely a drop-in replacement for `node-canvas`, but it's close. There are a few quirks, but nothing I haven't got a comparatively straight-forward workaround for, and it beats faffing around with complicated build and deploy strategies.


Server-Side Canvas on Netlify


Working on a side-project which I'll be releasing soon-ish, and one of the issues I encountered was this manky display of a font I was rendering using `canvas`.

![Letters with cutouts](share-card.jpg)

The font is [Jost](https://fonts.google.com/specimen/Jost?query=jost) and it displays perfectly fine on Google Fonts and when rendered as a variable font through CSS, but would have this odd cut-out thing going on when rendered with `canvas`.

I found a few tickets about this on GitHub:

* [https://github.com/google/fonts/issues/2602](https://github.com/google/fonts/issues/2602)
* [https://github.com/google/fonts/issues/2666](https://github.com/google/fonts/issues/2666)
* [https://github.com/indestructible-type/Jost/issues/85](https://github.com/indestructible-type/Jost/issues/85)

It didn't matter from where you sourced the `woff` font files, the issue would persist.

One suggestion that seemed to have positive results was to use the variable font, however this isn't supported with the [`node-canvas`](https://github.com/Automattic/node-canvas) package I was using to use `canvas` server-side. Using a local copy of the standard `ttf` seemed to do the trick, though. Just register it as you would other fonts before use.

Using client-side `canvas`:

```javascript
const font = new FontFace('Font Family', 'url(/assets/fonts/FontName.ttf)');
await font.load();
document.fonts.add(font);
```

Using server-side `node-canvas`:

```javascript
Canvas.registerFont(path.resolve('public/assets/fonts/FontName.ttf'), {
    family: 'Font Family',
});
```

Using server-side `pureimage`:

```javascript
const font = PureImage.registerFont(path.resolve('public/assets/fonts/FontName.ttf'), 'Font Family', fontWeight, fontStyle, fontVariant);
font.loadSync();
```


Workarounds for letters displaying with cutouts on MacOS.

Buggy Font Display on MacOS


Let's say you have a web service that you've managed to launch. And let's say you've decided to separate the marketing content from the application because you want to be able to deploy updates to the marketing copy without having to redeploy the whole application.

You now have two sites set up on Netlify: `https://www.myshiny.com` for the marketing content, and `https://app.myshiny.com` for the application.

But say your application generates some pages that are publicly visible, and you want these to be accessible through the marketing site. For example, your app might result in user generated pages like `https://app.myshiny.com/@username`, but wouldn't it look much better if it was accessible via `https://www.myshiny.com/@username` instead?

Provided both sites are under the same team in Netlify, you can set up proxy redirects.

In the marketing site `netlify.toml` (or in the equivalent syntax for `_redirects`) create redirect directives for the paths you want proxied:

```text:title=netlify.toml
[[redirects]]
  from = "/@*"
  to = "https://app.myshiny.com/@:splat"
  status = 200
  force = true
```

The trick with this is that all your assets for your proxied application pages will also use the marketing page url so the application will need to be updated to include the app domain as the URL prefix.

### `create-react-app`

In CRA, it should just be a matter of explicitly setting `PUBLIC_URL` to the application domain. If you have `i18n` set up, your translation paths also need to have the `PUBLIC_URL` prepended. With `react-i18next`, this may mean updating the `backeend.loadPath`.

### NextJS

In NextJS, `next.config.js` will need to have:

```javascript:title=next.config.js
assetPrefix: "https://app.myshiny.com",
images: {
  ...
  path: 'https://app.myshiny.com/_next/image',
},
```

## Limitations

As I mentioned before, both sites need to be under the same team on Netlify. There are other limitations but you can see what they are in Netlify's documentation below.

## See also

* [Netlify: Rewrites and proxies](https://docs.netlify.com/routing/redirects/rewrites-proxies/)


Proxy redirect parts of one Netlify site to another.

Proxy Redirect Netlify Sites

The life of a creator is one of continuous, iterative improvements.

Very Zen. Much philosophy. And you know, so's life in general.

A while ago, I noticed issues where my video and audio exports had audible clicks where there was none in the timeline. With each re-render they would be in a slightly different spot. More infuriatingly, I didn't notice them because I only played back the video exports at 1.5x speed and not the audio as well, and at a faster speed the clicks wouldn't usually come through[1].

Things were going fine, but I was doing audio specific work, and I noticed the exports sounded *off*. Not as bad as a cooked mp3, but sort of flat-sounding with compression-like artefacting at the edges. I couldn't hear the problem in my source files and the files I was getting out of Izotope RX in pre-processing so there was something definitely happening in DaVinci Resolve.

Good news, I worked out how to fix the problem. Bad news, I don't have the time to go back through my old content to reprocess everything again, so I have to live with the older releases having defects unless there's a solid justification for me to dedicate those hours to do it.

## Step 1. Check your source

Don't waste time mucking around in Resolve. GIGO (Garbage In, Garbage Out) is key here. Make sure the problems you're hearing aren't present in your source files.

## Step 2. Use wavs (if applicable)

For those using separate audio tracks, apparently, Resolve will devote precious processing power to converting audio into wavs on the fly if that's not the format they're imported in. Unless you can throw more hardware at the problem, convert your audio to wav first.

## Step 3. Pre-process your audio files before importing them into DaVinci Resolve

Resolve has some nice audio processing tools in Fairlight, but I find third-party presets can increase rendering time, and adds extra processing load that could cause artefacts. Instead of using the presets for RX in Resolve, I'll process the files in the RX standalone app, export as wav, and use those instead.

**Additional:** I download the separate audio only track from [riverside.fm](https://riverside.fm/?via=steampoweredshow) to process for this reason. There aren't sync issues either as long as you don't use the constant bitrate video.

## Step 4. Set audio export settings

Update your audio export settings to be:

* Format: QuickTime
* Codec: LinearPCM
* Sample rate: 48000
* Bit depth: 24

`QuickTime` with `LinearPCM` is the combination most commonly suggested by Resolve users for general audio problems. When the Bit depth is lower than `24`, I get the flat compression issues. `24` clears that up.

![DaVinci Resolve file export settings](audio-export-settings.png)

## Step 5. Slow down the render speed

Slowing down the render speed will help with both click and artefacting problems. With my hardware, on free DaVinci Resolve with CPU rendering I needed `50` to get rid of the clicks. In paid DaVinci Resolve Studio using my graphics card, I could get away with `75`.

![DaVinci Resolve file export settings](file-export-settings.png)

For those on free and not great hardware, I'm sorry, your render time is going to suck. But at least you won't have these problems in your exports anymore.


---

[1] Also super annoyed that I can't replace the video on YouTube without losing stats, but you have to pick your battles.


Reduce artefacts in audio exports from DaVinci Resolve.

Improve DaVinci Resolve Audio Export Quality

This is specifically for Gatsby as that's what I was using, but I suppose the implementation will be similar in other React/GraphQL environments.

When using [@contentful/rich-text-react-renderer](https://www.npmjs.com/package/@contentful/rich-text-react-renderer) to render a Contentful entry, they suggest passing a custom rendering component for embedded entries.

However, I was unable to get a fully populated `node` in the render handlers that would contain all the fields I require, with only access to the `contentful_id` and the entry type. Whatever I fetched in graphql was available in the `references` key of the content `body`, but it wasn't being sent on. Didn't bother to check how this works under the hood, but managed to achieve what I wanted by passing the `references` object to the custom renderer and searching for the relevant entry by `contentful_id`.

<Gist id="589b178b6454c3c640105cee3af4d4dd" />


Integration and rendering of Contentful embedded assets and entries.

Contentful Embedded Content in Gatsby

To be quite honest, the summary of this post is that I'm just too old for this shit. Gone are the days where I had all the time in the world to faff around with customising builds to my heart's content.

![Source: [Reddit](https://www.reddit.com/r/howtonotgiveafuck/comments/78pe0r/behold_the_field_in_which_i_grow_my_fucks/)](barren.jpg)

## The problems

The matter with [configuring audio over Xrdp](/2020/12/23/configure-audio-over-xrdp-centos) was one hurdle. Annoying, but not a show-stopper.

But other things that cropped up included:

### Limited export formats on DaVinci Resolve

I couldn't export H.264 MP4 with AAC audio which is what I was using on macOS. I had to use LinearPCM which would fail to successfully upload on more than one platform I needed it on. I tried a variety of other combinations of audio and video to no avail. Some combinations even failed to play back in QuickTime or VLC let alone get anywhere online.

The only option in these cases was to transcode them with `ffmpeg` or Handbrake after the initial render. But, why.

### Audio over Xrdp was fragile

Even after all that setup, things just didn't quite work, but only sometimes? Audio would cut out or not be in sync over remote. If I wanted to switch to working from the box directly, audio would not transfer back. Restarting services sometimes worked, but most of the time I'd have to restart the box entirely. I'm sure if I had figured out the right combination of services to restart it would have done the thing, but then I'd have to restart the services every time I needed to do that. Again, why.

### Laggy interface

This one perplexes me. I noticed the DaVinci Resolve UI was particularly laggy. I thought perhaps it was because I was using it remotely, but even on local it was janky if marginally better. Resources weren't being unusually taxed, other things were working fine, it was just kind of rubbish even when it was the only thing actively running. It was sort of tolerable in the way you're alright with the sound of dripping water for a little while, but not for extended periods of editing. No workaround.

## The last straw

But really the big one was the codec issue. I was not going to sit through two extended periods of rendering just to get the file in the format I wanted. One render in DaVinci Resolve run already took 1.5-2 times the length of the video to be rendered on its own let alone what I'd have to do with it using `ffmpeg` or Handbrake. Just, no.

Given I am comfortable and familiar with macOS, I did briefly entertain the idea of a hackintosh. But, just, no. If my field of fucks was barren for CentOS, it would not be less barren for a hackintosh.

And this is why I tapped out and went to Windows.


How do I regret thee, let me count the ways.

CentOS regret

I cannot recall the number of times I've been doing something and stumbled on something else completely unrelated, but because it's not what I'm looking for at the time, I've just thought 'Oh, that's interesting', closed the tab, and moved on, only to find that it is very relevant a couple months later for something else entirely.

It might be a paper, panel, innovation, or initiative that was worth a few minutes of my time, but not worth long-term storage. Or so I thought.

So something I've started to do is bookmark everything with enough metadata so when some random conversation I'm having down the road triggers a vague memory of having encountered a related bit of info, I have a better chance of finding it again.

I also wanted to be able to share this repository of my internet wanderings because I'm not a unique snowflake, and if I found something interesting, I'm sure someone else might as well.

## So why not just use Raindrop.io or just Tumblr? Why both?

Certainly, I could have just used Raindrop.io because they do have shareable pages for collections, but I haven't determined if the SEO for these pages are any good (I haven't stumbled on any Raindrop.io pages, for example), and Tumblr lends itself to being used in a social way so is more likely to reach a wider audience.

I did try just posting everything to Tumblr directly, but it was a bit inconsistent with presentation. The preview card didn't always load, and I still needed to manually add the title or text description. It was time-consuming.

So now I add a link in Raindrop.io using the browser extension, it pulls in the necessary metadata and allows me to add tags as I like, then Zapier populates a Tumblr Link post that will present consistently and be reasonably searchable.

Raindrop.io is the tool, and Tumblr is the vehicle.

Clone my Zap here: [Raindrop.io → Tumblr](https://zapier.com/shared/b5773b0dd1d926a590fab8c6ab73605509a27165)


Automatically post Raindrop.io bookmarks to Tumblr.

Bookmark everything (Raindrop.io to Tumblr with Zapier)

MDX on GatsbyJS nests JSX components in paragraph tags which can produce invalid HTML so you end up with invalid HTML resembling:

```html
<p>
	<div class="jsx-component">...</div>
</p>
```

When using Markdown tables, it can also leave extra whitespace that can produce HTML syntax warnings. Not showstopping, but annoying all the same.

Create this plugin in your `./plugins` directory and add it to the end of your `gatsbyRemarkPlugins` in `gatsby-config.js`.

<Gist id="c5321b66ef8afabd6f0fdf67055aabc8" />


MDX wraps components with paragraph tags and can add extra whitespace in tables which produce invalid HTML. This GatsbyJS plugin cleans up the markup.

Clean-up Extraneous Paragraph Tags and Table Whitespace in MDX on GatsbyJS

For [STEAM Powered](https://steampoweredshow.com) Facebook videos and YouTube allow you to attach an SRT file for captions. However, Twitter and Instagram do not and captions need to be baked-in.

Use this bash script create new videos with the SRT captions baked-in. The script needs to be run in the directory that contains video files with their corresponding SRT files (with the `.en_US` language suffix). New videos with the captions baked-in will be created in the same directory.

<Gist id="97e0b54ef35929bf05a3dcf1ae316ff5" />


How to create baked-in captions in videos using srt files and ffmpeg.

Bake-in SRT Captions into Videos Using ffmpeg

If you have multiple timelines that need to be exported with the same settings:

<Callout type="warning" icon="⚠️">
This won't work if you have captions.
</Callout>

1. Select the timelines
2. Context menu → "Create New Timeline Using Selected Clips"
3. Deliver → Custom
4. Set Location for output
5. Under Video, select "Individual Clips"
6. Under File, Filename uses "Source name" (filename will be timeline name)
7. Other settings as needed.

If your video size is non-standard, you will need to set the size to Custom to match the source content, and Crop to Fit.


Exporting multiple timelines at one in DaVinci Resolve.

Batch Export Timelines

These are the steps I took to configure Xrdp on CentOS to allow me to hear audio over Microsoft Remote Desktop on OSX. YMMV.

Install the [pulseaudio-module-xrdp](https://github.com/neutrinolabs/pulseaudio-module-xrdp) module using the instructions based on those provided by [neutrinolabs](https://github.com/neutrinolabs/pulseaudio-module-xrdp/wiki/README) with modifications that I needed to make it work on my install.

## CentOS 8

### **Prerequisites**

Xrdp needs to have been installed.

Some build tools and package development tools are required. Make sure you install the tools.

```bash
yum groupinstall "Development Tools"
yum install rpmdevtools yum-utils
rpmdev-setuptree
```

### **Prepare & build**

Install pulseaudio and requisite packages to build pulseaudio.

**Note:** The *powertools* and *okay* repos needed to be added for `yum-builddep`. The *okay* repo was current at time of writing, you may need to update this.

```bash
yum install pulseaudio pulseaudio-libs pulseaudio-libs-devel
yum config-manager --set-enabled powertools
rpm -ivh http://repo.okay.com.mx/centos/8/x86_64/release/okay-release-1-3.el8.noarch.rpm?
yum-builddep pulseaudio
```

Fetch the pulseaudio source and extract. You'll see `~/rpmbuild/BUILD/`

```bash
yumdownloader --source pulseaudio
rpm --install pulseaudio*.src.rpm
```

If the source download fails due to being unavailable, manually download the source rpm. Use the name that it says it failed to find and have a dig around for the source. I found the version I needed here, but you can dig further up the tree to see if you can find yours:

[https://vault.centos.org/8.3.2011/AppStream/Source/SPackages/pulseaudio-13.99.1-1.el8.src.rpm](https://vault.centos.org/8.3.2011/AppStream/Source/SPackages/pulseaudio-13.99.1-1.el8.src.rpm)

When executing `rpm --install` you might see:

```bash
warning: user mockbuild does not exist - using root
warning: group mockbuild does not exist - using root
```

It's okay, these are just warnings, it probably worked. You'll find out shortly.

Build the pulseaudio source. In this phase, pulseaudio is not necessarily needed to be built but configured however there's no way to do only configure.

```bash
rpmbuild -bb --noclean ~/rpmbuild/SPECS/pulseaudio.spec
```

Finally, let's build Xrdp source / sink modules. You'll have two .so files `module-xrdp-sink.so` and `module-xrdp-source.so`.

```bash
git clone https://github.com/neutrinolabs/pulseaudio-module-xrdp.git
cd pulseaudio-module-xrdp
./bootstrap && ./configure PULSE_DIR=~/rpmbuild/BUILD/pulseaudio-[YOUR VERSION]
make
```

## **Install**

Just `make install` should install built modules to the correct directory.

You can confirm if the modules properly installed by following command:

```bash
ls $(pkg-config --variable=modlibexecdir libpulse)
```

If you can see lots of `module-*.so` and `module-xrdp-sink.so`, `module-xrdp-source.so`, PulseAudio modules should be properly built and installed.

`module-xrdp-sink.la` and `module-xrdp-source.so` may be installed to the target directory, these files are not necessary and you can remove them safely.

Enjoy!

## **See if it works**

To see if it works, run `pavumeter` in the xrdp session. Playback any YouTube video in Firefox. You'll see "Showing signal levels of **xrdp sink**" and volume meter moving.

## Troubleshooting

* Audio pitch is lower than it should be

    Modify `/etc/pulse/daemon.conf`, uncomment or add `default-sample-rate = 44100`

* Choppy audio

    No actual solution set, unfortunately. YouTube playback is choppy, but straight audio playback is fine.


## Additional Sources

* [https://okay.network/blog-news/rpm-repositories-for-centos-6-and-7.html](https://okay.network/blog-news/rpm-repositories-for-centos-6-and-7.html)


Configuring Xrdp on CentOS for use over Microsoft Remote Desktop.

Configure audio over Xrdp on CentOS

tl;dr: I need to generate my own SRT files for my videos because Facebook Creator Studio makes me angry.

Long: [Backstory](/rail-yard/video-captions).

## Requirements

- python
- [ffmpeg](https://www.ffmpeg.org/)
- Google Cloud API Key with the Speech to Text product enabled. ([instructions](https://cloud.google.com/speech-to-text/docs/quickstart-client-libraries))

More details for installation and usage in the script below.

## Notes

Default GCS only works for videos no longer than 60 seconds, and the script will only send the first 60 seconds of video to accommodate this. Modifications are required to use GCS for longer videos[1].

I find the `video` transcription model more accurate than the `default`, but `video` is a premium model if that matters to you. I still need to make corrections, but far fewer than Facebook's auto-captioning feature.

For bin length, I've set it to a default of 3 seconds with a line break of 37 characters[2].

```text
1
00:00:05,100 --> 00:00:07,500
Big Bang Theory thank you. So
especially in that
```

<Gist id="abbabb693f37d49ccbd9348178c5963b" />

---

[1] See [https://towardsdatascience.com/how-to-use-google-speech-to-text-api-to-transcribe-long-audio-files-1c886f4eb3e9](https://towardsdatascience.com/how-to-use-google-speech-to-text-api-to-transcribe-long-audio-files-1c886f4eb3e9)

[2] 3 seconds seems to come up a bit, and the first subtitle style-guide I found is from the [BBC](https://bbc.github.io/subtitle-guidelines/) and I saw 37 characters on there because of teletext. For online it's based on percentage of screen-width and at that point I realised close enough is good enough. Got better numbers? Let me know.


Using Google Cloud Services Speech to Text to generate SRT files from short videos.

Generate SRT files with Google Cloud Services

Here's an example migration for automatically creating permissions on groups.

This specific install uses both `allauth` and `guardian` which is reflected in the migration dependencies, but as this uses Django core `Group` and `Permission` objects, it should work without those two modules.

As noted in the gist, YMMV.

<Gist id="6a8ac71539220b1f13a95bd559f2c4bd" />


How to create permissions on groups in Django in a migration.

Create Group Permissions with Migrations in Django


<Callout type="warning" icon="⚠️">

Decided I have better things to do with my time and picked up [Izotope RX Standard](https://www.izotope.com/en/shop/rx-8-standard.html) when it was about 50% off. Leaving this here for posterity. That said, the EQ stuff in Step 4 I still use.

</Callout>

Getting a decent mic has made a big difference to the sound quality of my local audio recordings[1] but I've been remiss in the audio aspect of post-production. In part because I have no idea what I'm doing and was spending more time than I had available faffing around with dials and knobs I didn't fully understand.

But I appear to have developed some electrical or signal interference in my recordings and while Garbage-In-Garbage-Out is absolutely a thing, I needed to figure out how to eliminate or at the very least minimise the annoying sound that to me sounds like I have a giant fan next to me, but apparently only I can hear[2].

Don't use wireless headphones for audio work. I also had issues with wired Apple earbuds. I had better luck with in-ear earbuds with the soft silicon tips, but circumaural (encloses ear) headsets were best. Learned this the hard way.

So, audio clean-up crash-course time. Will flesh this out more as I learn. Will use audio n00b terms that are in all likelihood wrong. But if you're using this as a guide, firstly, gods help you, secondly, this has got to be slightly better than the other tutorials I saw which were effectively "Dick around with the dials and levels until it sounds right, *et voila*."

### Step 1: Master Volume

I raised/lowered the individual speech track sliders so that Master sits mostly on the mid-to-lower end of 10-15 (yellow).

### Step 2: Noise Gate

Apply a Noise Gate. This defaults Threshold -35dB but may have to drop this some to avoid clipping too much voice. For the issue that I was having, -38dB is what worked. I set Attack to 1ms as that gives me better edges.[3] There was also some fiddling with Release but honestly, I can't tell what I'm listening for here. This was set to about 78.

This cleans up where there is no speech, and leaves it sounding a little stilted because of the aforementioned edges where the noise is under the speech.

You can also add Compression here by setting the Threshold to just below the peak. Didn't need or do much because of Step 1. Compression will clean up the extremes.

### Step 3: Noise Reduction

Apply the Noise Reduction plugin. I used the same settings as for the Noise Gate, jacked Smoothing up to 2. Wet/Dry (raw vs processed) defaults to 80% but I fiddled between 80-100% until it sounded okay. 80% was about right. I found the Auto speech mode produced more clipping, so I used Manual then hit Learn over a decent section of speech. Don't know if this is what you're meant to do. Will figure it out later.

This cleans up the noise behind the speech and makes it sound less clipped/stilted.

### Step 4: EQ (optional)

Activate bands 1 and 6 and set to curves up and curves down respectively. Set 2 and 5 to the round one.

Working from 2-5 (or 5-2) one at a time (not sure if there's a reason you should go one way or the other) max out Gain, playback speech while increasing the Frequency dial until the audio sounds the most whistley or the most annoying. Drag Gain back down to between -2 to -10dB. Stop when it sounds alright. Going too far down makes you sound like you're in a hole.

Repeat for other bands.

For the noise issue, once 1-3 was done, EQ didn't do too much.

### Step 5: Save changes as a preset

Follow this guide to save the setting for later use.

- Step 6: Properly learn audio editing or something

## Extra Things

- Some sections of laughter or exclamation can be quite loud. In Fairlight, select Normalise Audio Levels from the clip context menu. This also allows the volume for these to be more consistently set than from dragging the volume control in Cut or the volume line elsewhere.

---

[1] Although frankly almost anything is better compared to using my earbuds.

[2] And if I can hear it, good chance that other people younger than me can, too. So you know, probably most of my target audience.

[3] I have no idea if 'clipping' or 'edges' are even words I should be using in the audio context, but if I treat sound post like image processing it makes sense to me.


The technical details behind the creation of STEAM Powered.

Fairlight Audio Clean-Up


I use markers in DaVinci Resolve to annotate videos for show notes and navigation links in YouTube video descriptions.

![YouTube timeline](timeline.png)

To output the marker info as an EDL, activate the timeline whose markers you want to output, then in the **Media** tab, right-click on the timeline, select **Timelines** &rarr; **Export** &rarr; **Timeline Markers to EDL...** and save the EDL file.

<Callout type="warning" icon="⚠️">

If the timeline isn't open, the <strong>Timeline Markers to EDL</strong> menu item will not be available.

</Callout>

![DaVinci Resolve Screenshot](screenshot.png)

Then, use the following python script to output the marker info in the format:

```text
[00:00:00] Marker name
```

<Gist id="fe15ae724b1cc92bb88f7b6c7e5ac274" />


Use DaVinci Resolve marker EDLs to create timelines that can be used in show notes and YouTube timelines.

Convert DaVinci Resolve Markers to YouTube Compatible Timelines


I make short video clips for promoting [STEAM Powered](https://steampoweredshow.com) on social media by taking sections of the main timeline and pasting them into new timelines. This copies the raw track only and doesn't include any Fairlight settings I may have applied to the track in the original timeline.

To replicate track settings across multiple timelines, you'll need to use the **Fairlight** &rarr; **Presets Library...** menu option.

![DaVinci Resolve Menu](menu.png)

Select **Global track presets** option from the **Filter by** dropdown. You can target whatever you want from the list, but I needed Effects, EQ, and dB to be replicated, so global it was.

Select the track you want the settings copied from, then **Save New**.

![DaVinci Resolve Presets](presets.png)

To apply the preset, go to the target timeline, select the preset and the track and click on **Apply**.


Replicate Fairlight settings when using the same track on multiple timelines.

Tech Blog