Knowledge Base (Posts about video)

Jitsi reenable self view

bgstack15 — Fri, 31 Jan 2025 13:38:00 GMT

Jitsi Meet is great software. It's gotten better and better over time! Unfortunately, there's one little tiny problem. If you hide your self-view, you see a little notification that says you can re-enable the view from Settings. This information is wrong, however. So you have to run a little javascript scriptlet and somehow reload the page, without it overwriting this value. I haven't quite settled on what exact order of operations (run javascript, reload page, log out of meeting?) needs to happen, but hopefully somebody else can move this further along and make it work in the end.

a = JSON.parse(localStorage["features/base/settings"]);
a["disableSelfView"] = false;
localStorage.setItem("features/base/settings",JSON.stringify(a));

Lua script for mpv to keep xscreensaver from running

bgstack15 — Wed, 29 May 2024 12:53:06 GMT

As noted in the file itself, this is adapted from MPV script that deactivates XScreensaver when video playback is active, and it was officially listed at User Scripts · mpv-player/mpv Wiki#lua-scripts

files/2024/listings/xscreensaver.lua (Source)

	`-- Ripped from https://gist.github.com/elenril/f8ff9475a7882b7a16cdd723c7dce150 and configured by bgstack15`
	`-- linked at https://github.com/mpv-player/mpv/wiki/User-Scripts`
	`-- this script periodically deactivates xscreensaver`
	`-- when video playback is active`

	`local function heartbeat()`
	`if mp.get_property_native("pause") or`
	`mp.get_property_native("idle") or`
	`not mp.get_property_native("vo-configured") then`
	`return`
	`end`

	`mp.command_native_async(`
	`{`
	`name = "subprocess",`
	`args = { "xscreensaver-command", "-deactivate" },`
	`capture_stdout = true,`
	`},`
	`function () end)`
	`end`

	`mp.add_periodic_timer(10, heartbeat)`

	`for _, prop in ipairs({"pause", "idle", "vo-configured"}) do`
	`mp.observe_property(prop, nil, heartbeat)`
	`end`

Tells mpv to keep running command xscreensaver-command -deactivate which simulates user activity. Ergo, it is designed actually for this use case.

You can place this file as ~/.config/mpv/scripts/xscreensaver.lua.

Save videos: 2022 edition

bgstack15 — Thu, 20 Oct 2022 12:35:53 GMT

My current process for running yt-dlp involves detoxing the filenames.

File save-videos.sh.

	`#!/bin/sh`
	`# Startdate: 2022-09-20`
	`# Purpose: single utility that downloads and safely renames provided files`
	`# Dependencies:`
	`# yt-dlp`
	`# detox`
	`# rename`
	`# files: config/detoxrc config/safe.tbl`
	`cd "/path/${SUBDIR:+${SUBDIR}}"`
	`mkdir -p temp && { cd temp && USED_TEMP=1 ; }`
	`LANG=latin-1 PYTHONIOENCODING=latin-1 yt-dlp "${@}"`
	`if test "${USED_TEMP}" = "1" ;`
	`then`
	`# remove weird characters`
	`detox -f "config/detoxrc" -v *`
	`# strip the dash that precedes the youtube VID`
	`rename 's/ -([a-zA-Z0-9_]{11}\.)/ $1/' *`
	`mv -i * ..`
	`fi`

File config/detoxrc:

sequence default {
  uncgi;
  iso8859_1 {
    filename "/usr/share/detox/iso8859_1.tbl";
  };
  safe {
    filename "config/safe.tbl";
  };
  wipeup {
    remove_trailing;
  };
};

And my only differences for config/safe.tbl are:

--- /usr/share/detox/safe.tbl   2022-09-20 15:02:16.000000000 -0400
+++ config/safe.tbl 2022-09-20 10:08:23.326100599 -0400
@@ -99,11 +99,11 @@
 0x09       _   # tab
 0x0A       _   # new line
 0x0D       _   # carriage return
-0x20       _   # space
-0x21       _   # !
+#0x20      _   # space
+0x21       ''  # !
 0x22       _   # "
 0x24       _   # $
-0x27       _   # '
+0x27       ''  # '
 0x2a       _   # *
 0x2f       _   # /
 0x3a       _   # :

I entirely discard exclamation mark ! and single quote ', and do not replace spaces at all.

My dvd ripping solution, 2022 edition

bgstack15 — Sat, 10 Sep 2022 13:16:48 GMT

Last year, I wrote about my dvd-ripping solution. Of course, over time my process has improved and evolved.

Ripping the DVDs

I now use makemkv again, because Handbrake itself suggests that other tools are better for ripipng from removable media. Handbrake is for transcoding.

When I stick discs in my (3) drives, I then run a command inside GNU screen.

time APPLY=1 INPUT=/dev/sr0:/dev/sr1:/dev/sr2 JOBNAME=s3d6 sh -x makemkv.sh

The jobname is arbitrary and helps keep job outputs distinct when I let them pile up. Here is the script makemkv.sh.

	`#!/bin/sh`
	`# Startdate: 2021-10-02 19:21`
	`# Purpose: rip disc automatically`
	`# History:`
	`# This is the second version of makemkv.sh (first one was renamed to makemkv-2019.sh)`
	`# 2022-08-03 13:11 add unshare to keep makemkv from accessing the network`
	`# Reference:`
	`# /mnt/public/Support/Programs/DVDs/handbrake-internal.sh`

	`# Flow: use makemkv to make the original rip, and then handbrake to convert to the preferred size/format.`

	`test -z "${INPUT}" && INPUT="/dev/sr0" # colon-delimited`
	`test -z "${OUTPUTDIR}" && OUTPUTDIR=/mnt/public/Video/temp/makemkv`
	`test -z "${JOBNAME}" && JOBNAME="$( < /dev/urandom tr -dc 'A-Z0-9' \| head -c6 )"`
	`test -z "${step1file}" && step1file="${OUTPUTDIR}/1-${JOBNAME}-run-makemkv.sh"`
	`test -z "${step2file}" && step2file="${OUTPUTDIR}/2-${JOBNAME}-run-handbrake.sh"`
	`printf '' > "${step1file}"`
	`printf '' > "${step2file}"`

	`for line in $( echo ":${INPUT}:" \| tr ':' '\n' \| grep -viE '^\s*$' ) ;`
	`do`
	`bline="$( basename "${line}" )"`
	`echo "process ${line}"`
	`mminfo="$( unshare -r -n makemkvcon info dev:"${line}" )"`
	`#echo "${mminfo}" >> "${TMPFILE}"`
	`count="$( echo "${mminfo}" \| sed -r -e '1,/Total/d' \| grep -c Title )"`
	`raw="$( HandBrakeCLI --markers --format mkv --min-duration 125 --scan --input "${line}" --output "${OUTPUT}" --encoder x264 --rate 30 --native-language eng --title 0 2>&1 )"`
	`disctitle="$( echo "${raw}" \| sed -n -r -e '/DVD Title:/{s/.*DVD Title: //;p}' )"`
	`x=0`
	`while test $x -lt $count ;`
	`do`
	`OUTDIR="${OUTPUTDIR}/${JOBNAME:+${JOBNAME}_}${bline}/${disctitle}_${x}" ; OUTDIR="$( echo "${OUTDIR}" \| tr ' ' '_' )"`
	`#mkdir -p "${OUTDIR}"`
	`#echo makemkvcon mkv "dev:${line}" "${x}" "${OUTDIR}"`
	`echo "mkdir -p \"${OUTDIR}\" ; unshare -r -n makemkvcon mkv \"dev:${line}\" \"${x}\" \"${OUTDIR}\"" >> "${step1file}"`
	`newfile="$( find "${OUTDIR}" -mindepth 1 -maxdepth 1 ! -type d -print -quit 2>/dev/null )"`
	`test -z "${newfile}" && newfile="${OUTDIR}/*.mkv"`
	`outfilename="$( echo "${OUTPUTDIR}/${JOBNAME:+${JOBNAME}_}${bline}_${disctitle}v${x}.mkv" \| tr ' ' '_' )"`
	`echo "HandBrakeCLI --markers --format mkv --input "${OUTDIR}"/*.mkv --output \"${outfilename}\" --encoder x264 --rate 30 --native-language eng --mixdown 6ch --aencoder ffaac --audio 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, --subtitle 0,1,2,3,4,5,6,7,8,10,11,12,13,14,15,scan" >> "${step2file}"`
	`x=$((x+1))`
	`done`
	`done`

	`# So after all the prep work is done, we need to run step 1 and then step 2`
	`echo "BEGIN STEP 1"`
	`if test -n "${APPLY}" ;`
	`then`
	`sh -x "${step1file}"`
	`else`
	`cat "${step1file}"`
	`fi`
	`echo "####################################################################"`
	`echo "####################################################################"`
	`echo "You may now eject the disc(s)."`
	`echo "####################################################################"`
	`echo "####################################################################"`
	`echo "BEGIN STEP 2"`
	`if test -n "${APPLY}" ;`
	`then`
	`sh -x "${step2file}"`
	`else`
	`cat "${step2file}"`
	`fi`
	`echo "DONE"`
	`date`

Once that is done, the raw ripped files are stored at glob /mnt/public/Video/temp/makemkv/JOBNAME_sr*/*/*.mkv, and the handbrake-transcoded files are at glob /mnt/public/Video/temp/makemkv/JOBNAME_sr*_namefromdisc.mkv.

Now I manually inspect each video file and rename them to the correct episode name, or extra file name (which probably won't be updated in the next step).

For show episodes, I run a script which I described in that previous post. I have an input csv which I hand-curate from the Wikipedia pages usually, that includes columns s, sep, ep, airdate, filename.

have,s,ep,sep,title,airdate,filename
1,1,1,01-e02,Encounter at Farpoint,1987-09-28,s01e01-e02 - Encounter at Farpoint
1,1,3,3,The Naked Now,1987-10-05,s01e03 - The Naked Now
1,1,4,4,Code of Honor,1987-10-12,s01e04 - Code of Honor
1,1,5,5,The Last Outpost,1987-10-19,s01e05 - The Last Outpost
1,1,6,6,Where No One Has Gone Before,1987-10-26,s01e06 - Where No One Has Gone Before

I describe my csv generation process a little more in that previous post.

Then I run the next script:

time tv-mkv-helper.py --inputcsv "/mnt/public/Video/TV/Star Trek The Next Generation (1987)/STTNG.csv" -d /mnt/public/Video/temp/

This script is still exactly the same as in the previous post. I like the metadata of the original airdate on the episode, as well as of course video title. And I have never found a use for the "next file" tags that mkvtoolnix can show you, but I populate them because I can. Maybe it'll be useful someday.

And then I manually move the files to their intended destinations.

Running Jitsi Meet on a virtual directory

bgstack15 — Sun, 26 Jun 2022 12:56:17 GMT

It is possible to configure Jitsi Meet to use a subdirectory, so that you can use https://www.example.com/jitsi/ but it breaks the Jitsi mobile app. If the entire user base uses desktop-based web browsers, a virtual directory is feasible.

Select a virtual directory. I used /jitsi/.

Modify Meet server

Modify file web/Dockerfile to have a second RUN statement:

RUN printf '%s\n' '<base href="/jitsi/" />' > /usr/share/jitsi-meet/base.html && \
    sed -i -r -e '/#include virtual/{s/"\//"/;};' /usr/share/jitsi-meet/index.html

Build this image with docker build . when running from inside that web/ directory. Record the image name or id number. Modify docker-compose.yml to use this new image id for service web, e.g.:

services:
    # Frontend
    web:
        image: e16e8216e37b

Modify attribute PUBLIC_URL in file .env:

PUBLIC_URL=https://www.example.com/jitsi/

An optional step, which supports the legacy http-bind method instead of the current websocket method, is to prepare file ~/.jitsi-meet-cfg/web/config.js by extracting it from a running web instance and modifying it in the following manner.

sed -i -r -e '/bosh:/{s/\/http-bind/\/jitsi\/http-bind/;};' /config/config.js

The file will then resemble included file config.js.subdir.example.

Restart docker-compose.

cd ~/docker-jitsi-meet-stable-7287
docker-compose down
docker-compose up -d

Modify httpd server

In my public https virtual host, add the directives for this Jitsi meet instance.

<VirtualHost *:443>
   ServerName www.example.com
   ServerAlias www.ipa.internal.com www.internal.com
   DocumentRoot /var/www/external
   Include conf.d/ssl-common.cnf
   Include conf.d/ssl-443.cnf
   ProxyPreserveHost On
   # Below here is for Jitsi Meet
   <IfModule mod_proxy.c>
      <IfModule mod_proxy_wstunnel.c>
         ProxyTimeout 900
         <Location "/jitsi/xmpp-websocket">
            ProxyPass "ws://server4:8000/xmpp-websocket"
         </Location>
         <Location "/jitsi/colibri-ws/">
            ProxyPass "ws://server4:8000/colibri-ws/"
         </Location>
      </IfModule>
   </IfModule>
   Proxypass         /jitsi/     http://server4:8000/
   ProxypassReverse  /jitsi/     http://server4:8000/
</VirtualHost>

Reload httpd. The virtual directory should now work on desktop browsers.

Files involved

server4:/home/jitsi/docker-jitsi-meet-stable-7287/web/Dockerfile
server4:/home/jitsi/.jitsi-meet-cfg/web/config.js

References

Weblinks

https://stackoverflow.com/questions/32295168/make-jitsi-meet-work-with-apache-on-a-sub-url

Self-hosted Jitsi Meet

bgstack15 — Wed, 22 Jun 2022 12:54:46 GMT

Overview

I set up a self-hosted Jitsi Meet instance, which is of course the video conferencing software. These are the steps I took and additional research options for future use. No custom SELinux rules were necessary, which is a departure from the norm. I guess docker handles the SELinux parts?

Devices

I used these systems.

System	OS	IP address	Role
server1	CentOS 7	10.43.20.155	apache httpd server
server4	CentOS 7	10.44.153.156	docker host
net1	ddwrt	10.43.20.1	ingress for port forwarding

Setting up Jitsi Meet

Installing Meet server

I already had docker and docker-compose installed on server4. Those steps are outside the scope of this document.

Follow the directions from reference 1 which are included here briefly.

Fetch latest release: https://github.com/jitsi/docker-jitsi-meet/releases/latest and do not clone the git repo. I etracted to the home directory of my service account, so use the directory name from the tarball.

Configure a .env file from the env.example file. Mine is included file env.internal. Note that DOCKER_HOST_ADDRESS should point to the public IP address, so the IPv4 address for www.example.com. This attribute is important because groups of 3 and more participants use the server as a central point, rather than the peer-to-peer connection of just 2 participants.

Make directories:

mkdir -p ~/.jitsi-meet-cfg/{web,transcripts,prosody/config,prosody/prosody-plugins-custom,jicofo,jvb,jigasi,jibri}

Start the application.

docker-compose up -d

Open the host firewall on server4.

tf=/usr/lib/firewalld/services/jitsi-meet.xml
sudo touch "${tf}" ; sudo chmod 0644 "${tf}"
cat <<EOF | sudo tee "${tf}" 1>/dev/null
<?xml version="1.0" encoding="utf-8"?>
<service>
  <short>jitsi-meet</short>
  <description>Jitsi Meet is a web conferencing solution. These rules expect a different host to handle encryption.</description>
  <port protocol="tcp" port="8000"/>
  <port protocol="udp" port="10000"/>
</service>
EOF

sudo firewall-cmd --reload
sudo firewall-cmd --permanent --add-service=jitsi-meet
sudo firewall-cmd --reload

Configuring Apache httpd for reverse proxy

Host server1 is the main web server for the Internal network. Modify the main configuration file, /etc/httpd/conf.d/local_mirror.conf with a new virtual host and listen directive.

This snippet depends on ssl-pre being included at the top, and also the relevant included files.

# 5443 is jitsi
Listen *:5443
<VirtualHost *:5443>
   Include conf.d/ssl-common.cnf
   Include conf.d/ssl-5443.cnf
   ProxyPreserveHost On
   <IfModule mod_proxy.c>
      <IfModule mod_proxy_wstunnel.c>
         ProxyTimeout 900
         <Location "/xmpp-websocket">
            ProxyPass "ws://server4:8000/xmpp-websocket"
         </Location>
         <Location "/colibri-ws/">
            ProxyPass "ws://server4:8000/colibri-ws/"
         </Location>
      </IfModule>
   </IfModule>
   Proxypass         /     http://server4:8000/
   ProxypassReverse  /     http://server4:8000/
</VirtualHost>

Modify SELinux rules to allow httpd to listen on port 5443.

sudo semanage port -a -t http_port_t -p tcp 5443

Reload httpd after testing it.

sudo httpd -t
sudo systemctl reload httpd

Open the host firewall on server1. I updated my custom firewall service xml rule and reloaded firewalld.

Configure router

Device net1 is the current edge router for Internal network. Modify the port forwarding rules to include the following:

Application	Protocol	Port from	IP address	Port to
jitsi1	Both	5443	10.43.20.155	5443
jitsi2	Both	10000	10.44.153.156	10000

Files involved

server4:/home/jitsi/stable-7287.tar.gz
server4:/home/jitsi/docker-jitsi-meet-stable-7287/.env
server4:/usr/lib/firewalld/services/jitsi-meet.xml
server1:/usr/lib/firewalld/services/http-internal.xml
server1:/etc/httpd/conf.d/local_mirror.conf

References

Weblinks

https://jitsi.github.io/handbook/docs/devops-guide/devops-guide-docker/

Other

Original research

My DVD-ripping solution

bgstack15 — Thu, 12 Aug 2021 13:14:52 GMT

This is a work in progress, but its current status is as follows.

Ripping the DVDs

To rip my DVD collection, use my handbrake wrapper script. My ripping machine uses two disc drives. Run the script once per drive, and save all output to a temporary file.

{ INPUT=/dev/sr0 handbrake.sh ; INPUT=/dev/sr1 handbrake.sh ; } > ~/handbrake1

Inspect the script for correctness. Mine looks like:

HandBrakeCLI --markers --format mkv --min-duration 125 --input /dev/sr0 --output /mnt/public/Video/temp/TNGS2D3_V1.mkv --encoder x264 --rate 30 --native-language eng --title 1 --audio 1,2, --subtitle 1,2,scan --native-language eng --mixdown 6ch --aencoder ffaac
HandBrakeCLI --markers --format mkv --min-duration 125 --input /dev/sr0 --output /mnt/public/Video/temp/TNGS2D3_V2.mkv --encoder x264 --rate 30 --native-language eng --title 2 --audio 1,2, --subtitle 1,2,scan --native-language eng --mixdown 6ch --aencoder ffaac

The handbrake.sh script can be found at the bottom of this post and is explained further there. Run the temp file's commands. I like to do this in a GNU screen session.

time sh -x ~/handbrake1

Adding TV show metadata

Prepare a csv with s, sep, ep, airdate, title, and filename columns.

have,s,ep,sep,title,airdate,filename
1,1,1,01-e02,Encounter at Farpoint,1987-09-28,s01e01-e02 - Encounter at Farpoint
1,1,3,3,The Naked Now,1987-10-05,s01e03 - The Naked Now
1,1,4,4,Code of Honor,1987-10-12,s01e04 - Code of Honor
1,1,5,5,The Last Outpost,1987-10-19,s01e05 - The Last Outpost
1,1,6,6,Where No One Has Gone Before,1987-10-26,s01e06 - Where No One Has Gone Before

This filename output is supposed to be what Jellyfin wants for TV shows. I used the information from Wikipedia and some LibreOffice Calc functions to make this csv file, and some hand-munging for the double-long episodes.

="s" & TEXT(A2,"\00") & "e" & TEXT(C2,"00") & " - " & REGEX($D2,"[,!']","")

I'm a bit obsessive about removing commas, exclamation marks, question marks, and quote marks from my filenames. Inspect the saved files and rename each one to the filename string from the csv that corresponds to the correct episode. To add the mkv metadata including airdate, and next and previous episodes, run the next script on the directory. This does not currently recurse into subdirectories.

time tv-mkv-helper.py --inputcsv "/mnt/public/Video/TV/Star Trek The Next Generation (1987)/STTNG.csv" -d /mnt/public/Video/temp/

Alternatives

Automatic Ripping Machine is just too fully-featured for me.

References

Jellyfin TV show naming scheme

Scripts

handbrake.sh

My handbrake.sh wrapper reads the disc contents to learn the disc title and the number of video tracks longer than 125 seconds.

	`#!/bin/sh`
	`# startdate: 2021-03-10 11:36`
	`# Alternatives:`
	`# handbrake preset: /mnt/public/Support/Programs/DVDs/1920x1080.json`

	`test -z "${INPUT}" && INPUT=/dev/sr0 ; export INPUT`
	`test -z "${OUTPUT}" && OUTPUT=/mnt/public/Video/temp ; export OUTPUT`

	`raw="$( HandBrakeCLI --markers --format mkv --min-duration 125 --scan --input "${INPUT}" --output "${OUTPUT}" --encoder x264 --rate 30 --native-language eng --title 0 2>&1 )"`
	`disctitle="$( echo "${raw}" \| sed -n -r -e '/DVD Title:/{s/.*DVD Title: //;p}' )"`
	`array="$( echo "${raw}" \| grep -E '^\s*\+' \| awk 'BEGIN{x=0} /title [0-9]/{gsub(":","",$NF);x++;title[x]=$NF} /kbps/{audio[x]=audio[x]""$2} !/subtitle tracks:/ && !/\+ [0-9]+,/ {us=0} /subtitle tracks:/{us=1} us == 1 && $2 ~ /[0-9]+,/{subtitle[x]=subtitle[x]""$2} END {for(i in title) {{print title[i],audio[i],subtitle[i]}}}' )"`
	`commands="$( echo "${array}" \| awk -v "disctitle=${disctitle}" -v "input=${INPUT}" -v "output=${OUTPUT}" '{a=$1;b=$2;c=$3;print "HandBrakeCLI --markers --format mkv --min-duration 125 --input "input" --output "output"/"disctitle"_V"a".mkv --encoder x264 --rate 30 --native-language eng --title "a" --audio "b" --subtitle "c"scan --native-language eng --mixdown 6ch --aencoder ffaac"}' )"`
	`echo "${commands}"`

My hard-coded values include outputting to mkv, and x264 video encoding, and 30 bps, with English language. I also tell it to use the specific audio encoder ffaac which was the first one I tried when trying to get my 6-channel mixdown (that's 5.1 surround sound) option to work. I'm not a media bitrate snob; just trying to preserve some semblance of fancier file value than I can even consume, should I ever upgrade my viewing equipment in the next 40 years.

tv-mkv-helper.py

	`#!/usr/bin/env python3`
	`# Startdate: 2021-08-07`
	`# Purpose: given INCSV="/mnt/public/Video/TV/Star Trek The Next Generation 1987)/STTNG.csv"`
	`# with columns s, ep, sep, title, airdate, filename,`
	`# update files in provided directory, whose name matches the filename column, with the mkv properties`
	`# Usage:`
	`# time tv-mkv-helper.py --inputcsv "/mnt/public/Video/TV/Star Trek The Next Generation (1987)/STTNG.csv" -d /mnt/public/Video/temp/`
	`# References:`
	`# /mnt/public/Support/Programs/DVDs/handbrake-internal.sh`
	`# Dependencies:`
	`# STTNG.csv sorted ascending, with columns s, sep, title, airdate, filename`
	`# mkvpropedit`

	`import csv, os, subprocess`

	`###############################################################`
	`def load_file_to_array(inputcsv):`
	`episode_array = []`
	`with open(inputcsv,"r") as o:`
	`csv_reader = csv.reader(o)`
	`headers = next(csv_reader)`
	`error_string = ""`

	`# sanity check for the columns we want`
	`if "s" not in headers:`
	`error_string = "Inputcsv needs column named 's' for season number."`
	`#elif "ep" not in headers:`
	`# error_string = "Inputcsv needs column named 'ep' for episode number."`
	`elif "sep" not in headers:`
	`error_string = "Inputcsv needs column named 'sep' for season episode number."`
	`elif "airdate" not in headers:`
	`error_string = "Inputcsv needs column named 'airdate'."`
	`elif "filename" not in headers:`
	`error_string = "Inputcsv needs column named 'filename'."`
	`if error_string != "":`
	`print(error_string)`
	`return -1`

	`x = 0`
	`for row in csv_reader:`
	`x = x + 1`
	`ep = {key: value for key, value in zip(headers,row)}`
	`episode_array.append(ep)`
	`return episode_array`

	`############################################################`
	`def fix_directory_contents(directory, inputcsv):`
	`os.chdir(directory)`
	`episodes = load_file_to_array(inputcsv)`
	`if episodes == -1:`
	`print("Aborting.")`
	`return -1`
	`# simple one-level down method. This might be insufficient someday.`
	`for filename in os.listdir(directory):`
	`if filename.endswith(".mkv"):`
	`print("----------------------")`
	`print(f"Checking file {filename}")`
	`filename_sans_ext, _ = os.path.splitext(filename)`
	`# loop through episodes to find this file`
	`# need enumerate, per https://stackoverflow.com/questions/1011938/loop-that-also-accesses-previous-and-next-values/1011962#1011962`
	`l = len(episodes)`
	`for index, ep in enumerate(episodes):`
	`previous = next_ = None`
	`if ep['filename'] == filename_sans_ext:`
	`if index > 0:`
	`previous = episodes[index-1]['filename']`
	`if index < ( l - 1 ):`
	`next_ = episodes[index+1]['filename']`
	`fix_file(`
	`filename=filename,`
	`title=ep['filename'],`
	`season=ep['s'],`
	`seasonep=ep['sep'],`
	`next_name=next_,`
	`prev_name=previous,`
	`airdate=ep['airdate']`
	`)`

	`############################################`
	`def fix_file(filename,title,season,seasonep,airdate,next_name, prev_name):`
	`print(f"Please fix {filename} to have")`
	`print(f"title: {title}")`
	`print(f"season: {season}")`
	`print(f"seasonep: {seasonep}")`
	`print(f"airdate: {airdate}")`
	`print(f"next_name: {next_name}")`
	`print(f"prev_name: {prev_name}")`
	`if next_name is not None and not next_name.endswith(".mkv"):`
	`next_name = next_name + ".mkv"`
	`if prev_name is not None and not prev_name.endswith(".mkv"):`
	`prev_name = prev_name + ".mkv"`
	`date_string = str(airdate) + "T12:00:00Z" # just set it to noon UTC, so the EST/EDT time will still be the same day.`
	`#cmd_string = f"mkvpropedit --set 'title={title}' --set 'date={date_string}' --set 'segment-filename={filename}.mkv' --set 'prev-filename={prev_name}' --set 'next-filename={next_name}'"`
	`cmd_array = ["mkvpropedit","--set",f'title={title}',"--set",f'date={date_string}',"--set",f'segment-filename={filename}',"--set",f'prev-filename={prev_name}',"--set",f'next-filename={next_name}',filename]`
	`result = subprocess.run(cmd_array)`
	`print(result)`
	`aux_cmd_array=["mkvpropedit",filename,"--delete"]`
	`if next_name is None or next_name == "":`
	`aux_cmd_array.append("next-filename")`
	`if prev_name is None or prev_name == "":`
	`aux_cmd_array.append("prev-filename")`
	`# if we added anything to the auxiliary command array, then run it`
	`if aux_cmd_array[-1] != "--delete":`
	`result = subprocess.run(aux_cmd_array)`
	`print(result)`

	`# argparse stuff`
	`import argparse`
	`parser = argparse.ArgumentParser()`
	`parser.add_argument("-i","--inputcsv",required=True,help="Episode CSV, with columns s, sep, title, filename, airdate")`
	`parser.add_argument("-d","--directory",required=True,help="Path to directory where files should be given metadata")`
	`args = parser.parse_args()`

	`inputcsv = args.inputcsv`
	`directory = args.directory`

	`if __name__ == "__main__":`
	`print(f"running with inputcsv=\"{inputcsv}\", directory={directory}")`
	`fix_directory_contents(directory,inputcsv)`

In a departure from my normal style where I put all the functions in a library and call it, I wanted a self-contained script with the argument parsing. It was quick and dirty. And all I'm doing is adding the 3 or 4 mkv attributes to the mkv files whose filename matches an entry in the csv. I do all this using a custom csv, because I'm too lazy to learn how to use some fancy TheTVDB api or whatever. I'm obsessive enough to be fine with manually scraping metadata from Wikipedia tv show episode lists.

Convert vhs video tape to mkv file in Linux

bgstack15 — Wed, 17 Jul 2019 13:05:22 GMT

Last updated 2019-09-11

I still own video tapes (VHS) and I have finally gotten around to getting a nice setup for saving them down to hard disk so I can clear out the old video tape collection. This is how I did it. First of all, I knew I needed an RCA- to-something adapter. I found an "AV to USB converter" [amazon.com] that does the trick. When attached to a Ubuntu 16.04 system, it shows up as /dev/video0. No additional steps required! To quote one of my role models [thealaskalinuxuser.com] on the Internet: "Linux -- keep it simple." Now, I discovered over time that the audio input just didn't work. But the video comes in perfectly! I was using vlc [videolan.org] for the input capture. To get the audio to work, I had to find an RCA to mini-phono cable which I already owned. An example product is on monoprice.com [monoprice.com]. I also had to fiddle with the audio input settings to get the input to work right. I had to poke around with pulseaudio, alsa, and vlc to get the audio input to work the way I needed it. For my setup (pictured below), I needed to make sure my input source was mic (the front jack on my desktop computer) and not line, which is probably the input in the back. I chose to set my mic boost (akin to gain) really low, and capture volume really high. I needed to set pulseaudio to allow the stereo input. I have discovered that pulseaudio is fragile, and also never remembers the settings I choose for it, so for every reboot or login or pulseaudio --start command, I have to go readjust the "profile." I am starting to understand why people smarter (and more verbose) than me tend to dislike pulseaudio. With alsa and pulse set up correctly, it is now a matter of getting vlc to accept the audio input while accepting the video input. I had to discover how my system identifies the audio jack.

$ arecord -l
**** List of CAPTURE Hardware Devices ****
card 0: PCH [HDA Intel PCH], device 0: CX20641 Analog [CX20641 Analog]
  Subdevices: 0/1
  Subdevice #0: subdevice #0
card 0: PCH [HDA Intel PCH], device 2: CX20641 Alt Analog [CX20641 Alt Analog]
  Subdevices: 1/1
  Subdevice #0: subdevice #0
card 1: USB20 [AV TO USB2.0], device 0: USB Audio [USB Audio]
  Subdevices: 1/1
  Subdevice #0: subdevice #0

By trial and error, I learned the mic input is card 0, device 2. In alsa terms, that's alsa://0,2. So, to put it all together, I had to set VLC to open a "capture device" of /dev/video0, with audio device of hw:0,2. To get the audio and video to both be output by VLC, I had to go into advanced optiosn and se audio input = 0. VLC always defaults to audio input=-1, so no audio will come through. When I selected the Play button, it presents both audio and video from the VCR! So, with the video on the screen that I want, I pressed the record button (from the toolbar visible when you select View -> Advanced controls). VLC records by default to avi format, which is not my preferred method, even though it is a temporary format. So, I had to set all the settings again, and then select the drop-down arrow beside the Play button, and select "Convert." A new window appears, and I select the file format I want and the output file. With all the options set, I now return to the first options screen and select the "Convert" button. After running through the whole video, I come back and hit stop in VLC. I use HandBrake [handbrake.fr] to convert the file to the format I want. The details of that are beyond the scope of this post. For a bonus, I discovered that killing vlc safely closes the written file, so it is still viewable. So I just run a command in a terminal to kill vlc after the published length of the videotape:

$ sleep $(( 60 * 120 )) ; killall vlc

I could have done something fancier with xdotool to select the "stop" button, but why bother?

Addendum

For some reason, when I capture video (possibly because of the NTSC framerate conversation), the audio gets a little bit out of sync with the video. Thankfully, there is a tool that can change the scale of the audio to video: mkvmerge, which is a part of mkvtoolnix suite. After much experimentation, I am satisfied that a safe number to use to scale the audio perfectly from my VCR for all content is in this command:

mkvmerge -y '1:0,100.060552/100' -o new.mkv old.mkv

That is take stream 1 (zero-indexed, and usually the audio in a simple captured video file) and stretch it with an anchor point of zero to 100.060552% of the original speed. So it slows down the audio, and then the audio syncs perfectly with the video, for a 2-hour movie.