I have added a new class to my poker formation checker (now on .NET 6.0, not 5.0). The library still mainly works with string representations of decks, hands and cards, and the Hand class can be initialized from a string.

// Create a hand from a string:
using Winsoft.Gaming.GenericPokerFormationChecker;
const string handString = "FORMATION=3-OF-A-KIND,SCORE=0333,HAND=CLB04-DMN06-HRTKN*-DMNKN*-SPDKN*";
var hand = new Hand();
hand.Parse(handString);
Console.WriteLine(hand.Formation); // Output: ThreeOfAKind

But the Hand class can also be initialized using regular function calls.

// Create a hand using the API:
using Winsoft.Gaming.GenericPokerFormationChecker;
var hand = new Hand();
hand.Add(Suit.Spades, Value.Ace);
hand.Add(Suit.Clubs, Value.Ace);
hand.Add(Suit.Diamonds, Value.Ace);
hand.Add(Suit.Hearts, Value.Ace);
hand.Add(Suit.Spades, Value.Value06);
Console.WriteLine(hand.Formation); // FourOfAKind

Also, the Hand class is self contained. You can any time prompt what formation and score it represents, and what cards are included in the formation. If the hand doesn’t have a formation, the InFormation property will point out the highest card.

// Create a hand using the API:
using Winsoft.Gaming.GenericPokerFormationChecker;
var hand = new Hand();
hand.Add(Suit.Hearts, Value.Value10);
hand.Add(Suit.Clubs, Value.Queen);
hand.Add(Suit.Spades, Value.Ace);
hand.Add(Suit.Diamonds, Value.Value03);
hand.Add(Suit.Spades, Value.Value06);
Console.WriteLine(hand[0]!.InFormation); // false
Console.WriteLine(hand[1]!.InFormation); // false
Console.WriteLine(hand[2]!.InFormation); // true
Console.WriteLine(hand[3]!.InFormation); // false
Console.WriteLine(hand[4]!.InFormation); // false

The old API has not changed. Install:

Install-Package PokerFormationChecker

Source code is here, NuGet package is here.

Jag har skapat ett bibliotek för .NET 6.0 (endast Windows) som innehåller en enda klass: PathInfo. Den kan korta ner en sökväg för presentation på skärmen och den kan hämta innehållet i en katalog, rekursivt. Exempel finns att titta på här:

NuGet: https://www.nuget.org/packages/WinSoftFileUtility/

GitHub: https://github.com/Anders-H/FileUtility

Podcastproduktion sker i flera steg. Man ska rigga utrustning, göra en soundcheck, spela in podcasten, klippa den, montera och mastra den och publicera den. Jag har redigerat ljud i vågformseditorer sedan tidigt 1990-tal och poddat sedan 00-talet. Jag har bl.a. varit inblandad i produktionen av Skeptikerpodden, Radio Bulletin, Stulet gods, Radio Houdi, Generation YX och Samtal. I och med att jag sysslat en del med montering och mastring, och får ibland frågan om jag kan bistå. På grund av arbetsbelastning så tackar jag alltid nej, men det är inte speciellt svårt att göra en mastring på egen hand.

För att resultatet ska bli riktigt bra, måste inspelningen ha gjorts korrekt. Inspelningsvolymen får inte vara för låg, för då kan man få problem med brus. Inspelningsvolymen får absolut inte vara för hög (“clipping” – ej att förväxla med klippning), för då blir vågformen helt enkelt förstörd. Mikrofonerna bör vara någorlunda bra, och helst vill man inte ha mikrofonen för nära munnen eller andas direkt in i mikrofonen. Har man ingen bra inspelningsstudio så finns det risk att mikrofonen plockar upp rumseko och att ljudet därför blir lite burkigt. Många brukar lösa detta genom att sänka inspelningsvolymen och prata närmre mikrofonen. Det fungerar, men det introducerar ett annat problem, nämligen att ljudet låter onaturligt, som om någon pratar rätt in i ditt öra. Utan tillgång till professionell utrustning får man göra vad man kan.

Tänk också på att använda puffskydd (vissa säger “pop-filer” numera) för att minska risken att man skapa oljud genom att andas på mikrofonens membran.

Om fler än en person pratar i podcasten, så är det bra om dessa ligger i var sin fil under mastringen. Särskilt ljudnivåerna är bra att kunna styra individuellt.

Mastringsarbetet görs i speciella program för vågformseditering. Man arbetar alltså med redan renderade ljudfiler, direkt mot vågformen. Dessa program kan benämnas på lite olika sätt, men wave editor är ganska vedertaget. I programmet öppnar du upp det klippta råmaterialet du fått från klipparen, där varje kanal är en fil, och ditt ansvar är att:

1. Harmoniera bitdjup och samplingsfrekvens
2. Korrigera nivåer
3. Eventuell brusreducering och eventuell frekvensutjämning (equalization)
4. Montering av röstkanaler
5. Komprimering
6. Eventuell extra klippning
7. Montering av signaturmelodier
8. Slutrendering

Harmoniera bitdjup och samplingsfrekvens

Eftersom vi jobbar direkt i vågformen så får vi ingen hjälp av mjukvaran att hantera om ljudfilerna har olika bitdjup. Bitdjupet anger hur många möjliga impulsnivåer varje samplingspunkt har, och ett högre tal är bättre. 8-bit, 16-bit eller 24-bit är ganska vanligt. Professionella ljudproducenter brukar arbeta med 24-bit och leverera en slutprodukt som är 16-bit, men arbetar man med podcasts så räcker det ofta att kontrollera att ingen inblandad ljudfil är sämre än 16-bit.

När det gäller samplingsfrekvens, som anger samplingspunkternas täthet, är 44,1 KHz lämplig, men vissa inspelningsprogram kan leverera filer på 22,05 eller 48 KHz. Högre är bättre även här. Då behöver du göra en resample till 44,1 KHz, som är fullt tillräckligt för att mastra en podcast. När alla filer har samma bitdjup och samplingsfrekvens är detta steg färdigt.

Korrigera nivåer

Det är bra om samtliga medverkande har samma impulsstyrka, till den grad man kan styra det. I exemplet på bilden har vi två filer. Den ena filen innehåller en person som pratar i en mikrofon, och den andra filen innehåller två personer som delar på en mikrofon. Båda är lite för låga för att det ska vara passande, men det är lättare att göra ett bra jobb om ursprungsimpulsen är lite för låg än lite för hög.

Den ena kanalen (överst) är lite svagare än den andra, så båda behöver förstärkas, men den övre lite mer än den undre. Notera att något sticker ut mot slutet av filen. Om den biten ska vara med, bör inte volymen höjas mer än att den biten fortfarande har god marginal till impulsens maxvärde. Det kan i värsta fall vara ljud i båda kanalerna samtidigt där, och då finns det risk att clipping uppstår när filerna slås samman.

Innan jag höjt volymen tillräckligt på första kanalen, inser jag att detta kommer att slå i taket. Efter att ha zoomat in, kan jag konstatera detta är ett skratt som ska vara med i slutprodukten. För att få upp volymen till önskad nivå, måste jag manuellt först sänka volymen på det skrattet. Jag gör samma sak i båda filerna, om än lite mindre i den andra. Detta är jag nöjd med:

Eventuell brusreducering och eventuell frekvensutjämning

Det ser ut att hända en del saker, särskilt i den undre filen, mellan pratet. Är det störande ljud som måste tas bort (funktionen “mute”)? Skiljer de två filerna varandra åt i frekvensomfång? Det behöver rättas till med en equalizer. Innehåller någon fil mer toppar och dalar än den andra, eller är någon fil mer fyrkantig (kanjonisk) än någon annan? Den med många toppar och dalar kanske behöver ha lite kompressor redan i detta steg. Det är bra om filerna liknar varandra.

Montering av röstkanaler

När filerna är tillräckligt lika varandra, ska de slås samman till en fil. Den funktionen brukar heta “mix” i denna form av program. Nu ser vi första versionen av den fil som är resultatet av vårt arbete.

Komprimering

Nu vill vi att volymen ska vara jämn och stark, så att alla detaljer hörs, även när det pratas tyst, och så att inte lyssnaren får hörselskador av något häftigt skratt. Vi vill lägga kompressor på ljudet. I en vågformseditor brukar denna hantering kallas compression. Jag brukar gå fram ganska försiktigt, till en början. Är man för snål, kan det bli svårt att höra alla detaljer, och det kan komma höga överraskningar för lyssnaren. Tar man i för mycket, låter ljudet onaturligt, som om någon står mycket nära dig och pratar.

Det där höga skrattet på slutet sticker inte längre ut i ljudstyrka, utan i att den som skrattar tillfälligt låter lite “närmre” lyssnaren. Dessutom är fraser som yttrats lite försiktigt i bakgrunden, nu fullt hörbara.

Eventuell extra klippning

Det är bra att zooma in och titta igenom vågformen efter omotiverat långa pauser, eller onödigt många ticks, som t.ex. “ööhhh…” eller liknande. Ta inte bort allt, bara några stycken. Korta inte gärna ner pauser utan att säkerställa att du inte klipper i andetag, ta hellre bort någon omotiverad paus då och då.

Montering av signaturmelodier

Kontrollera att signaturmelodierna ligger strax under pratet i volymstyrka, och mixa in musiken först, sist eller var det ska ligga. Tänk på att om musik och prat ska gå in i varandra, så blir den totala ljudstyrkan högre där detta sker.

Slutrendering

För en podcast brukar man välja att rendera slutresultatet som en MP3-fil, med en bithastighet på 128 kilobit per sekund (Kbps), i 16-bitars mono. Det ger en bra kompromiss mellan filstorlek och ljudkvalitet.

När man har fått rutin på denna process brukar det inte vara mer än en halvtimmas arbete per podcastavsnitt, innan du kan lämna resultatet vidare till den som ansvarar för publicering. Lycka till!

Min första kontakt med mandelbrotmängden var ett BASIC-program av Bo E. Carlsson runt 1990. Sedan dess har Andrej Bauer skrivit ett C++-program som skriver mandelbrotmängden till en bildfil. Programmet gick att kompilera med en C#-kompilator med endast små justeringar, vilket syns här:

var rawData = new ImageRawData(width, height);


var xmin = 0.27085;
var xmax = 0.27100;
var ymin = 0.004640;
var ymax = 0.004810;
var maxiter = 1000;

var dx = (xmax - xmin) / width;
var dy = (ymax - ymin) / height;

for (var j = 0; j < height; j++)
{
    var y = ymax - j * dy;
    for (var i = 0; i < width; i++)
    {
        var u = 0.0;
        var v = 0.0;
        var u2 = u * u;
        var v2 = v * v;
        var x = xmin + i * dx;
        
        int k;
        for (k = 1; k < maxiter && u2 + v2 < 4.0; k++)
        {
            v = 2 * u * v + y;
            u = u2 - v2 + x;
            u2 = u * u;
            v2 = v * v;
        }

        rawData.SetValue(i, j, k >= maxiter ? null : k);
    }
}

Den anpassade koden varken ritar bilden eller skriver den fill någon fil, utan samlar resultatet i en 2-dimensionell array som heter rawData (av typen ImageRawData). Anledningen till det är att jag vill kunna lägga på renderingsfilter efter att fraktalen är beräknad. I implementation har jag hittills endast lagt in en linjär interpolering till en gråskala mellan 0 och 255, men möjligheten att hitta på något roligt finns där.

public class ImageRawData
{
    private readonly int _width;
    private readonly int _height;
    private readonly int?[,] _data;

    public ImageRawData(int width, int height)
    {
        _width = width;
        _height = height;
        _data = new int?[width, height];
    }

    public void SetValue(int x, int y, int? value) =>
        _data[x, y] = value;

    public int GetValue(int x, int y) =>
        _data[x, y] ?? 0;

    private int GetLargest()
    {
        var largest = int.MinValue;

        for (var y = 0; y < _height; y++)
            for (var x = 0; x < _width; x++)
                if (_data[x, y].HasValue && _data[x, y] > largest)
                    largest = _data[x, y]!.Value;

        return largest;
    }

    private int GetSmallest()
    {
        var smallest = int.MaxValue;

        for (var y = 0; y < _height; y++)
            for (var x = 0; x < _width; x++)
                if (_data[x, y].HasValue && _data[x, y] < smallest)
                    smallest = _data[x, y]!.Value;

        return smallest;
    }

    public void Interpolate(int min, int max)
    {
        var smallest = GetSmallest();
        var largest = GetLargest();

        for (var y = 0; y < _height; y++)
        {
            for (var x = 0; x < _width; x++)
            {
                if (_data[x, y].HasValue)
                {
                    var v1 = _data[x, y]!.Value;
                    var v2 = LinearInterpolate(v1, smallest, largest, min, max);
                    _data[x, y] = v2;
                    continue;
                }

                _data[x, y] = max;
            }
        }
    }

    private static int LinearInterpolate(int value, int smallest, int largest, int min, int max)
    {
        var result = min + (value - smallest) * (max - min) / (largest - smallest);
        
        if (result < min)
            result = min;

        if (result > max)
            result = max;

        return result;
    }
}

Själva renderingen har jag lagt i en iteration, där jag påverkar zoom-faktorn en aning, för att kunna skapa en animation. Jag gör det lite asymmetriskt för effektens skull. Iteratorn heter frameCount.

var xmin = 0.27085 + frameCount * 0.0000001;
var xmax = 0.27100 - frameCount * 0.0000002;
var ymin = 0.004640 + frameCount * 0.0000003;
var ymax = 0.004810 - frameCount * 0.0000004;
var maxiter = 1000;

Sen är det bara att kapsla in kalaset i ett ramverk. Jag använder Windows Forms så att jag kan titta på varje renderad bild medan animationen renderas. Eftersom själva resultatet är animationen som skrivs till disk, inte själva programmet, så har jag kostat på mig att göra allt arbete i GUI-tråden. Sedvanliga ursäkter.

using System.Drawing.Imaging;

namespace WinFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            Refresh();
            using var g = CreateGraphics();
            const int width = 1024;
            const int height = 1024;

            for (var frameCount = 0; frameCount < 1000; frameCount++)
            {
                var rawData = new ImageRawData(width, height);

                var xmin = 0.27085 + frameCount * 0.0000001;
                var xmax = 0.27100 - frameCount * 0.0000002;
                var ymin = 0.004640 + frameCount * 0.0000003;
                var ymax = 0.004810 - frameCount * 0.0000004;
                var maxiter = 1000;

                var dx = (xmax - xmin) / width;
                var dy = (ymax - ymin) / height;

                for (var j = 0; j < height; j++)
                {
                    var y = ymax - j * dy;
                    for (var i = 0; i < width; i++)
                    {
                        var u = 0.0;
                        var v = 0.0;
                        var u2 = u * u;
                        var v2 = v * v;
                        var x = xmin + i * dx;
                        
                        int k;
                        for (k = 1; k < maxiter && u2 + v2 < 4.0; k++)
                        {
                            v = 2 * u * v + y;
                            u = u2 - v2 + x;
                            u2 = u * u;
                            v2 = v * v;
                        }

                        rawData.SetValue(i, j, k >= maxiter ? null : k);
                    }
                }

                Application.DoEvents();
                rawData.Interpolate(0, 255);
                using var image = new Bitmap(width, height);

                for (var yy = 0; yy < height; yy++)
                    for (var xx = 0; xx < width; xx++)
                        image.SetPixel(xx, yy, Color.FromArgb(
                            rawData.GetValue(xx, yy),
                            rawData.GetValue(xx, yy),
                            rawData.GetValue(xx, yy)
                        ));

                g.DrawImage(image, 0, 0);
                Application.DoEvents();
                image.Save($@"C:\Temp\Frame{frameCount:00000}.png", ImageFormat.Png);
                Application.DoEvents();
            }
        }
    }
}

Resultatet för just dessa värden är följande video:

Häromdagen sände TV4-nyheterna ett inslag om religiöst neutrala begravningsplatser. I egenskap av ordförande i Humanisterna Örebro stöttade jag initiativet. TV4 Play: https://www.tv4play.se/program/nyheterna/religi%C3%B6sa-symboler-plockas-ned-i-kapellet-%C3%B6ppnar-f%C3%B6r-neutrala-begravningar/13732416

 

 

 

 

 

 

Visa detta inlägg på Instagram

 

 

 

 

 

 

 

 

 

 

 

 

Ett inlägg delat av Anders Hesselbom (@andershbom)

Nästan ett år har passerat sedan vi släppte avsnitt 42 av podcasten Stulet gods, men nu är vi tillbaka med en handfull av låtstölder att avhandla. I avsnitt 43 lyssnar vi på stulen musik som bl.a. innefattar Queen, Justin Bieber och Ozzy Ozbourne. Finns här eller där poddar finns – mycket nöje!

Nu finns hela min bok om Commodore BASIC 2.0 second release för Commodore 64 och VIC-20 att läsa som PDF här. Kontakta mig gärna för rättningar eller tillägg!

Uppdatering 2021-07-25: Även en epub-version finns att ladda hem.

I got a mail from an unknown programmer who asked me to port my poker formation checker from .NET Framework to .NET 5.0. Here is the repository and here is the NuGet package. Happy coding!

En inte helt obetydlig del av min musiksmak kommer från Commodore 64, vars analoga musikkapacitet saknade motstycke. Vissa demos som släpptes var innehöll korta samplingar från kontemporär populärmusik, som t.ex. Slow down. När det handlar om digital musik var C64:an ytterst undermålig – minnet var för litet, antalet bitar per samplingspunkt var får lågt. Men digitala musikdemos släpptes, för att det gick. Ett av dessa var Slow down (länkad ovan) som jag inte hade den blekaste aning om varifrån den kom förrän YouTube dök upp. Nu vet jag att det handlade om ett snävt urval från maxiversionen av gruppen Loose ends singel med samma namn.

I afton vill jag tipsa två fenomenala podcasts. I veckans avsnitt av Stulet gods pratar Henrik Andersson och jag om Poison, John Carpenter, Ankie Bagger och Joe Walsh. Avsnittet finns här eller där podcasts finns. Dessutom vill jag verkligen slå ett slag för Generation YX där vi diskuterar allt från den finska tullen till svensk skogsporr. Ingen mindre än Aron Flam närvarar.

Generation YX är en ny poddcast med journalisten Jannik Svensson och mig, där vi diskuterar samhällsaktuella frågor ur ett generationsperspektiv.

All information finns på hemsidan https://genyx.se/ men den finns där poddar finns.

Om du vill hålla dig à jour med vad som är stulet och vad som inte är det, är podcasten Stulet gods något för dig. Här avhandlar jag och Henrik Andersson (påstådda) låtstölder genom tiderna.

I det första avsnittet avhandlas Edison Lighthouse och Eiffel 64.

Hemsida: http://stuletgods.80tal.se/
Prenumerera (RSS): http://stuletgods.80tal.se/rss.xml
iTunes: https://podcasts.apple.com/se/podcast/stulet-gods/id1507649534
Spotify: https://open.spotify.com/show/0KcEPjKKZcO8KHh2T8F4eL
Direktlänk, Spotify: https://open.spotify.com/episode/77WKIjpr41E9GYVBVQFd6r