This post is going to be about my dislike of the YouTube experience out of the box and how I was able to solve it with a solution that doesn’t require any third party apps, dodgyness or developer options.
Shortcuts is a native built-in macro/scripting tool for iOS (and macOS) and it can be utilised completely on device. It has been written about a lot I’m sure, but when tinkering with my new phone I remember being taken aback by a few small but clearly incredibly powerful functions it has in it’s library:
“Shoot, a fella could have a pretty good weekend in Vegas with all that stuff”
While I have a YouTube Premium subscription and get on just fine with using it on desktop in a browser I really disliked the native app experience on iOS. So I migrated to using it within Safari, better experience but still with it’s issues for me. I’m very much a vanilla native experience enjoyer, that means I want a no-frills HTML5 video player experience.
When you go full-screen it does transition to the native player (which supports picture in picture). Funnily if you’re not logged into a premium account YouTube disables this functionality with a declaration user side. Shortcuts to flip this flag are common and widespread, neat to see. Anyway I was happy enough with just using YouTube in Safari for now.
Now if I thought I disliked my experience on iOS it was nothing compared to the awfulness of YouTube on Apple TV. Not to worry, I can simply use Safari on my phone and use AirPlay to get what I want on the big screen.
That’s when you discover YouTube gimps the quality of playback using AirPlay to 720p. What gives, this is clearly a synthetic restriction enforced with user-side JavaScript.
Very frustrating, but there was an off the shelf solution available, a neat Safari extension named Vinegar. It does everything I wanted and it was cheap at €2. Problem solved!…
Anyone who knows me knows I loathe a black box. I had to know how it worked, it’s my machine and this is client side stuff. The next problem is how do we get developer debugging tools going on Safari on an iPhone, turns out it’s amazingly simple; plug the phone in over USB and click the develop menu on desktop Safari!
The meat of it is a single API request to a sparsely documented endpoint:
https://www.youtube.com/youtubei/v1/player.
Researching this a bit further it’s the endpoint leveraged by the likes of yt-dlp. You can spend hours playing with this endpoint and I’d recommend it, it’s fun. But in the end for our purposes it can all be boiled down to this:
$ curl 'https://www.youtube.com/youtubei/v1/player' \
-X 'POST' \
-H 'Content-Type: application/json' \
--data-binary '{"context":{"client":{"clientName":"IOS","clientVersion":"20.03.02"}},"videoId":"T4Upf_B9RLQ"}' 2>/dev/null |jq '.streamingData.hlsManifestUrl'
"https://manifest.googlevideo.com/api/manifest/hls_variant/expire/.../file/index.m3u8"
That’s it, that’s all we need. The returned URL can be opened in Safari and the video will play without ads, without PiP restrictions, without AirPlay restrictions. Enabling the media stats on my Apple TV I can see we’re getting up to 4k video playing directly in the native player and being a HLS stream it’s playing from the Apple TV without proxying through the phone!
Note on the clientVersion: When I first built this over a year ago a
different version was used, then of course one day it stopped working, luckily
all that was required was bumping this to what I found currently being used by
yt-dlp
Normally I’d probably be done here I know how it works, I can sleep well. But knowing what’s available in Shortcuts toolbox and how simple this really is there was an opportunity for some more fun, we can rebuild all of this ourselves directly on the iPhone.
Unfortunately there’s no nice way of sharing the “source” of a shortcut.
You can download the Shortcut directly here.
And here’s an ASCII view of what you get in the Shortcuts UI:
┌─────────────────────────────────────────────────┐
│ Receive URLs from Share Sheet │
│ If there's no input: │
│ Stop and Respond Gobshite │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get Query from Shortcut Input │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get dictionary from Component of URL │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get Value for v in Dictionary │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get contents of │
│ https://www.youtube.com/youtubei/v1/player │
│ │
│ Method: POST │
│ Request Body: JSON │
│ │
│ ┌───────────────────────────────────────────┐ │
│ │ Key Type Value │ │
│ ├───────────────────────────────────────────┤ │
│ │ context Dictionary (1 item) │ │
│ │ client Dictionary (2 items) │ │
│ │ clientVersion Text 20.03.02 │ │
│ │ clientName Text IOS │ │
│ │ videoId Text [vid_id] │ │
│ └───────────────────────────────────────────┘ │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get dictionary from Contents of URL │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get Value for streamingData in Dictionary │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get dictionary from Dictionary Value │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get Value for hlsManifestUrl in Dictionary │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Get URLs from Dictionary Value │
└───────────────────────┬─────────────────────────┘
│
┌───────────────────────▼─────────────────────────┐
│ Open URLs │
└─────────────────────────────────────────────────┘
Et voilà!
This is a long post about what’s essentially a single POST request at the end of the day. Also amusing in the face of the ad-blocking arms race, though that was never the intention here. I still have and will keep my YouTube Premium account. Also I feel like Vinegar should have made this post about what it does rather than charge €2 for a black box to bypass ads, it leaving a sour taste in your mouth writes itself.
]]>I’ve been using these types of services for a while (LastPass originally then migrating to Bitwarden a few years ago, Bitwarden is great), they really do make life easier and solve the password re-use problem. But I got curious recently as to how these services are supposedly secure, after researching how my current provider (Bitwarden) works I thought it useful to document here in simple language what’s going on.
I’ll assume these providers all use a similar scheme, they tend to use flashy marketing saying it’s all awesome, listing accreditations and then direct you to white-papers for the details. I read through the paper for Bitwarden and I can see why it’s probably not shouted far and wide because it appears not particularly secure at a glance, but it is pretty good, though it does have pitfalls that should be made clearer.
$MASTER_PW)This is your (changeable) password to login to the cloud service and decrypt the vault to retrieve your passwords. This theoretically never leaves your local machine.
$VAULT_KEY)When your account is created a symmetric key is generated locally, generally in your browser. This key will then be used to encrypt and decrypt all the data stored in your vault.
$VAULT_KEY -> $ENC_VAULTKEYThe symmetric vault key is encrypted and stored using symmetric encryption
keyed with $MASTER_PW.
The vault is stored in the “cloud” encrypted with $VAULT_KEY.
When you log in to a service you send a hash of $LOGIN+$MASTER_PW to the
remote service, if you have enabled 2FA the service may require this to
authenticate you (note: this 2FA has nothing to do with your vault), if you
have successfully authenticated you will receive back a copy of the encrypted
vault and $ENC_VAULTKEY.
The local client will then decrypt $ENC_VAULTKEY to further decrypt the vault
itself.
When you change your master password $MASTER_PW and $ENC_VAULTKEY will
change, however $VAULT_KEY will not.
In general there is one original key, the $VAULT_KEY that if compromised is
not good. If the $VAULT_KEY is compromised the vault can be decrypted, even
after a $MASTER_PW change. So in summary the service stores your vault and
$ENC_VAULTKEY, theoretically locking access to both of those behind potential
2FA and $MASTER_PW.
It still is a pretty good system but pitfalls should be obvious after reading this, be careful where you unlock the vault.
]]>Now somewhat of a standard, they call it a “flavour” - whatever that is supposed to mean, it’s a fork with some extra features added for writing nice README plain-ish text files that render on GitHub projects. It’s nice, it’s fine. Use it for your GitHub README documents and other GitHub stuff.
It adds mainly <table> support to Markdown, also “tasklist” which is just a
unordered list with checkboxes instead of bullets, whoop-de-do.
It wont take long before you want to do something super crazy and so out there you’re a lunatic: like aligning text in a single row or cell (YOU ROGUE!).
So OK right, what do you do once you want to do some extremely basic formatting of your document not supported in markdown but is in HTML? Parsers are pretty flexible, GitHub and most others render raw HTML tags.
Once you’ve used HTML tags or any other extended crap you’ve broken any reason for using markdown in the first place, go open that document in a plaintext editor like vim or even better just cat it, yeah it’s not human readable as documentation in plaintext anymore is it?
Probably absolutely no one, but you’ve just wasted your time trying to hack markdown and breakout HTML into looking how you wanted. The point of writing docs in markdown should be so they’re easily readable as plaintext too. Otherwise just use a real markup language.
Write your doc straight in HTML, or better yet brush up on or learn LaTeX, or
markup for troff. Don’t use HTML in the middle of markdown documents, if you do
though that’s OK, you should check out shell_exec too I think you’d like it.
Markdown is still really great for that quick blog post, reddit post, or any other simple text article, but stop trying to extend it and beat it into places it never belonged.
]]>This is my daily driver, it’s not without it’s issues but it generally does it’s job well and has a really nice keyboard. Integer features severely let this calculator down, working with or juggling outside of base 10 is too clunky and unusable in practice. You should be able to pick one of these up new for €60-90.
If you search for a RPN calculator this is probably what will show up. It’s part of the Voyager series of calculators, there was a 10C, 11C, 12C, 15C, and 16C. This 12C is the only one that has stayed in production and provides financial functions (this was the shit pre-excel). If you get one today it’s an ARM machine emulating the old hardware running far faster.
I’ve had a few of these modern 12C’s and the keyboards are decent, but they are hard on batteries (like seriously), and also far more delicate than they seem. They don’t do well being thrown in a front pocket of a work bag. So I’d put these in the retro toy category. Also about €60-90.
These are small-batch high end replica’s of old HP’s (they do some new spins on old hardware too). They’re not cheap, but in my experience they are not overpriced either. You’ll want something from these guys eventually but not your first RPN. With taxes in your hand about €140 for a DM16L, but a good condition used HP 16C would be at least €250.
The build quality of the case, buttons and everything in general is premium. They’ve also done a great job porting to modern low power MCUs.
I wont beat around the bush, I don’t own one but also I really don’t like these and they rub me up the wrong way. It’s a very nice story of a guy making his own clone of a HP Voyager. But it’s built on dogshit old power hungry 8-bit AVR chips (it’s an Arduino groan). If this was open source I’d be more enthusiastic, but as it is it’s basically a shit imitation of what SwissMicros have been doing for years (with an ATMEGA, again seriously?). Not cheap either, $55 before shipping and taxes for a circuit board with a LCD some tact switches and an AVR. Adding EU shipping and taxes you’re at over half the cost of a SwissMicros for a janky and chonk DIY device that’s not open.
I really wanted to like these and get one (or a few) but the cost is too high for what it is. $55 (kit) + $25 (shipping) + $18.40 (import tax), guts of $100. It should have been entirely open source with PCB gerbers available and a “buy me a coffee” link.
A HP 20b or 30b with with firmware reflashed. This open source firmware is extremely capable but is pretty complicated and vast. The underlying hardware of the 20b and 30b is supposedly the same apart from colour and the keyboard quality. However I did buy a 30b and converted to 34S and the keyboard is so so awful I wont use the calculator at all, so god knows how bad the 20b is. The features on the WP 34S are great though. Needs a set of keyboard overlay stickers, and making your own programming cable is very easy. I think my total cost was around €85-90 for new old stock 30b plus 2x vinyl labels, already having the programming parts lying around.
]]>Can be some of or all of the following. In simplest form a single 2D array is indexed by “load” and RPM, values represent the duration injectors are switched on for. What is generally referred to as closed-loop means the value of the Lambda sensor is taken into consideration when calculating the injector pulse length. In open-loop the value of the Lambda sensor is ignored.
In a “standard basic” ECU we can assume it has two maps, a closed-loop map for when the slope of the rate of change with regard to “load” and RPM is close to zero, and open loop as it wavers. This largely because the response time of the Lambda sensor is long. “Smarter” ECUs will use sampled recent Lambda values as a factor in the open-loop calculation.
When modifications are made to the stock internal combustion system it may be necessary to change the behaviour of the fuel injection system. The factory closed-loop system will usually attempt to run the engine on the lean side of the stoichiometric ratio for both fuel efficiency and emissions. The majority of user modifications made will be within the margins the ECU will compensate for. Noticeable problems will start to occur however under open-loop operation if the ECU is not of the “learning” type that uses recent Lambda values for open-loop.
A very simple solution here is to make some adjustments to the reported value of the current air temperature.
The actual end effect of this input adjustment will of course vary across ECUs and their underlying calculations. If it is constantly adjusting a factor where Lambda takes priority, the effect may even be nil.
This is what a DynoJet Power Commander and similar devices are. These are man-in-the-middle devices. In their absolute most basic form they will “trim” the fuel injectors by running them for a longer/shorter period. To work consistently they should also modify the ECUs reading of the Lambda sensor. How these devices will usually work is not by modulating the output of the Lambda but by providing values to keep it in a constant sate. So in effect these devices keep an ECU in an open-loop type state with a modified map.
If we are building our own MITM device anything here goes of course with what inputs & outputs we decide to modulate.
Also referred to as “chip-tuning”, “remapping”, and so on. This process overwrites the original program on the ECU supplied by the manufacturer. This could be merely a modification to the lookup tables or it could be an entire system change. This type of modification service is far too often a snake-oil product sold to unsuspecting customers. Any idiot can get their hands on the right hardware & software along with enough information to be dangerous here.
DO NOT engage in this kind of nonsense unless you have a full known good (tested that you can restore it) backup of your original ECU.
“Ah but I know a guy” - Shit, you’re right. Psst here’s a another secret, free RAM.
Adjusting the ignition advance for your combustion is a genuine way to more power and efficiency. It needs to be tuned to the specific type of fuel you’re using. This is what usually makes the large power gains you get from a ECU re-flash. But guess what there might be a reason it wasn’t shipped from the factory like that. If you now run an incompatible fuel you run the risk of detonation. Unless you’re screening your fuel somehow this is going to end in a blown up engine.
]]>The really easy and naive way to do this is to repeatedly multiply, the way we
all know and understand as a basic principle. This is actually a pretty easy
program to write and understand, for a to the power of b we store b-1 in
I then use DSZ (Decrement I skip next instruction if I is zero) to
multiply a by itself the required amount of times.
This is clearly – slow as shit, becoming even more obvious running it on an 80’s pocket calculator (even if a fancy one).
LBL E // y^x x>=2
1
-
STO I
Rv
ENT
LBL 0
*
LST X
DSZ
GTO 0
x<>y
RTN
There is a O(log n) solution to exponent calculation, which I will not go into as wikipedia explains it well. From here on it will be expected you’re familiar with the tail-recursive implementation of the algorithm.
This program will only work while the calculator is in integer mode, it will not work in floating point mode.
We can boil the algorithm down to something like this:
LBL E // Main Exponent Program y^x integer only x>=1
F? 0 // {
GTO 0 // If flag 0 is set jump to loop otherwise set flag for later entry
SF 0 // }
1 // {
STO I // Store 1 in `I` (y)
Rv // }
LBL 0 // Start of Label 0 (Main loop)
1 // { If n = 1 go to the end section (2)
x=y? //
GTO 2 //
Rv // }
SR // { n/2 by shifting right, run odd subroutine if carry flag set
F? 4 //
GSB 1 // }
x<>y // { x = x * x; then loop
ENTER //
* //
x<>y //
GTO E // }
LBL 1 // { n is odd subroutine
x<>I // Get the y value from register `I`
x<>y // y = x * y; store it, restore stack and return
* //
LSTx //
x<>y //
x<>I //
RTN // }
LBL 2 // { Subroutine for ending
CF 0 // Clear flag 0
Rv // x = x * y; then return
x<>I //
* //
RTN // }