KevinPicone.com

☰ Articles

Remastering the Messin Around Drum Solos..

June 08, 2022

Remastering the Messing Around Drum Solos...

This footage was actually shot ten years ago today (9th June 2012), the original upload is low resolution / low frame rate and way too dark. So the remaster is 1080p & 30fps - reverb audio with tweaked the visuals.

The original copies of these videos are stored on my PLayBASIC channel on youtube. once these go live I can delete the old files.. I'm trying to clean this mess up !

This was recorded on a hybrid TAMA Drum set (Artstar -RockStar). The kit was 20 plus year old at the time of this drum recording, with old heads, no tuning.. just sat down and playing whatever came out that day.

Drum Solo 1 - Messing Around - Snares Off - Remaster

Here's the first of three short drum solos taken to test my sisters lumix camera (720p), which seems to do a pretty good job; considering how dark my drum room is without any extra lighting. As for the drumming, it's just whatever was on my mind at that moment. Anyway, thanks for the watching.

Drum Solo 2 - Always Messing Around - Snares On - Remaster

This footage was actually shot ten years ago today (9th June 2012), the original upload is low resolution / low frame rate and way too dark. So the remaster is 1080p & 30fps - reverb audio with tweaked the visuals.

This is the second of two short drum solos taken test my sisters lumix camera, which seems to do a pretty good job considering how dark my drum room is without extra lighting. As for the drumming, probably the most interesting part is the double stroke section at around the 35 second mark, that drops in from the triplet (with kick shuffle) section, although kick drum doesn't really cut through in the recording. Anyway, thanks for the watching.

Drum Solo 3 - A Trip To The Let - Remaster

This is the third drum solo snippet taken while testing my sisters lumix camera. The camera does a pretty job considering how dark the drum room with live audio. The drumming in this section is1/8 note triplet based mainly. The first section has simple hand over foot independence, moving into more of an obvious shuffle feel half way through.

Note: These are schedules for a 9th of June 2012 release.. So TEN YEARS TO THE DAY

Was VHS Video Really That Bad?

May 30, 2022

Logo

Was VHS Video Really That Bad?

VHS video was terrible, right? Awful snowy, washed-out picture quality, distorted rolling images. Yeah... sadly, a lot of TV VHS recordings do look awful. But then, every once in a while, you come across a tape that was recorded from a solid source—or captured on one of those rare clear days of analog TV reception—and wow... it can look almost as good as a first-generation DVD. I said almost!

In this video, I take a trip down memory lane, reliving the VHS collection of my youth. Our collection includes a mix of tapes dating back to the mid-to-late 1980s, most of which were recorded from local television broadcasts. And let me tell you, the real time capsule isn’t just the shows—it’s the commercials! Some are hilariously bad, while others bring back a wave of nostalgia.

If you’re like me, you probably think that old VHS videos look pretty bad. Well… check this out! I recently revisited a 20-year-old PAL VHS tape, and if it weren’t for a slight horizontal wave in the image, I wouldn’t have guessed it was that old. There’s a bit of tracking misalignment, causing scan lines to start and finish slightly unevenly. Whether that’s from the recording or the playback, I’m not sure—but it’s incredible how well it has held up.

Now, I should point out that this is the exception and not the rule. I’ve been looking at a bunch of VHS tapes, and this was by far the best one. Some movies, especially those that weren’t played often, still look surprisingly good. However, tapes that were played repeatedly tend to degrade in quality.

I’ve got some other examples, including pay-TV recordings that look similar to the good-quality tape. However, free-to-air TV recordings from back in the day are a different story—many of them are extremely snowy, with lots of lateral and vertical movement. Not all, but a significant number of them. It’s easy to see why VHS has such a poor reputation. Looking back, my memories of VHS were mostly bad, but now that I’ve rewatched some of these tapes, I’m honestly stunned. When blown up on a larger monitor and viewed from a typical seating distance, a well-preserved VHS tape can look just like any other 4:3 image.

Here’s another example: one of the original Star Wars films. The tape has been sitting around for decades without much use, and yet it still plays remarkably well. It’s incredible to think that these tapes—over 20 years old—have survived this well. In fact, when comparing them to some early DVD transfers from the mid-to-late 90s, the VHS quality is sometimes better! Those early DVDs often had low bit rates, 4:3 aspect ratio cropping, and poor compression, making them look worse than expected.

Of course, not all VHS tapes aged gracefully. Some are filled with snow and distortion, making them nearly unwatchable—like trying to watch TV in a blizzard. The decline of VHS coincided with the rise of digital recording in the early 2000s, making analog formats obsolete almost overnight. However, the transition to digital wasn’t smooth for everyone. Early digital TV had low bit rates, terrible reception, and frequent signal dropouts, leading to blocky, corrupted video streams. In contrast, while analog VHS recordings had their flaws, they were at least watchable from start to finish without major disruptions.

So, was VHS really that bad? Well, it depends. The worst VHS recordings look horrendous, but the best ones can still be surprisingly watchable.

What are your memories of VHS? Did you have any tapes that looked shockingly good? Or was it all just static and tracking lines? Let me know in the comments!

CREDITS

Buy VHS Video Player

Convert VHS to Digital / DVD

Camera: Motorola Motog9 Plus

Music:

The Sleeping Prophet - Jesse Gallagher

Movie Clips

Back To The Future (VHS vs DVD)

Starwars (VHS)

National Rodeo Championships (VHS recorded from Satellite TV) & Many more.

🔗

Improving the Performance of the Classic Bubble Sort Algorithm

May 16, 2022

Sorting algorithms are a crucial part of programming, and choosing the right one for your data is essential for optimal performance. However, even simple algorithms like Bubble Sort can be improved to handle larger datasets more efficiently. In this post, we’ll explore a few ways to optimize the classic Bubble Sort algorithm, using a PlayBASIC example to demonstrate the improvements.

Understanding Bubble Sort

Bubble Sort is one of the most commonly taught sorting algorithms in programming. It’s simple to understand but can be slow for large datasets. The concept is straightforward: you iterate through the data, comparing adjacent elements, and swap them if they are in the wrong order. The process repeats until no swaps are necessary, meaning the array is sorted.

The key flaw of Bubble Sort is that it’s an "n-squared" algorithm, meaning its performance degrades rapidly as the number of elements in the array increases. Despite this, there are still a few optimizations we can apply to make it faster in certain situations.

Optimizing Bubble Sort

While Bubble Sort will never be the fastest sorting algorithm, there are ways to make it more efficient for specific datasets. Below are a couple of key improvements that can help speed up the process.

1. Reduce the Set Size After Each Pass

One improvement involves reducing the size of the array that’s being processed after each pass. As each pass moves the largest remaining element to the end of the array, you don’t need to check it again in subsequent passes. By decreasing the range of elements to check after each pass, you can reduce unnecessary comparisons and speed up the sorting process.

2. Bi-directional Bubble Sort

Instead of only iterating left to right, the Bi-directional Bubble Sort (also known as Cocktail Shaker Sort) goes through the array in both directions. The first pass moves the largest element to the end of the array (just like the classic version), but the next pass moves the smallest element to the beginning of the array. By alternating directions, this approach can reduce the number of passes needed to sort the data.

Example Code in PlayBASIC

Here’s an example implementation of these optimizations in PlayBASIC, which demonstrates the classic Bubble Sort alongside the faster variants:

PB PlayBASIC Code:

loadfont "Courier New", 1, 24

MaxItems = 500
DIM Table(MaxItems)
DIM Stats#(10, 5)

DO
    Cls

    inc frames
    Seed = Timer()

    Test = 1

    SeedTable(Seed, MaxItems)
    StartInterval(0)
    ClassicBubbleSort(MaxItems)
    tt1 +  = EndInterval(0)
    test = Results("Classic Bubble Sort:", Test, MaxItems, Tt1, Frames)



    SeedTable(Seed, MaxItems)
    StartInterval(0)
    ClassicBubbleSortFaster(MaxItems)
    tt2 +  = EndInterval(0)
    test = Results("Classic Bubble Sort Faster:", Test, MaxItems, TT2, Frames)


    SeedTable(Seed, MaxItems)
    StartInterval(0)
    BiDirectionalBubbleSort(MaxItems)
    tt3 +  = EndInterval(0)
    test = Results("BiDirectional Bubble Sort:", Test, MaxItems, Tt3, Frames)


    Sync

    REPEAT
    UNTIL enterkey() = 0

LOOP


FUNCTION ShowTable(items)

    t$ = ""
    n = 0
    FOR lp = 0 to items
        T$ = t$ + str$(table(lp)) + ", "
        inc n
        IF n > 10
            t$ = Left$(t$, Len(t$) - 1)
            print t$
            t$ = ""
            n = 0
        ENDIF

    NEXT lp

    IF t$ <  > "" THEN print Left$(t$, Len(t$) - 1)

ENDFUNCTION


FUNCTION SeedTable(Seed, Items)
    Randomize seed
    FOR lp = 0 to Items
        Table(lp) = Rnd(32000)
    NEXT lp
ENDFUNCTION


FUNCTION ValidateTable(Items)
    result = 0
    FOR lp = 0 to items - 1
        IF Table(lp) > Table(lp + 1)
            result = 1
            exit
        ENDIF
    NEXT lp
ENDFUNCTION Result



FUNCTION Results(Name$, index, Items, Time, Frames)
    ` Total Time
    Time = Time / 1000
    Stats#(index, 1) = Stats#(index, 1) + time

    print "Sort Type:" + name$
    print "Total Time:" + str$(Stats#(index, 1))
    print "Average Time:" + str$(Stats#(index, 1) / frames)

    IF ValidateTable(Items) = 0
        Print "Array Sorted"
        ELSE
        print "NOT SORTED - ERROR"
    ENDIF
    print ""

    inc index

ENDFUNCTION index




FUNCTION ClassicBubbleSort(Items)
    Flag = 0
    REPEAT
        Done = 0
        FOR lp = 0 to items - 1
            IF Table(lp) > Table(lp + 1)
                done = 1
                t = Table(lp)
                Table(lp) = Table(lp + 1)
                Table(lp + 1) = t
            ENDIF
        NEXT lp
    UNTIL done = 0
ENDFUNCTION



FUNCTION ClassicBubbleSortFaster(Items)
    Flag = 0
    REPEAT
        Done = 0
        dec items
        FOR lp = 0 to items
            IF Table(lp) > Table(lp + 1)
                done = 1
                t = Table(lp)
                Table(lp) = Table(lp + 1)
                Table(lp + 1) = t
            ENDIF
        NEXT lp
    UNTIL done = 0
ENDFUNCTION


FUNCTION BiDirectionalBubbleSort(Items)
    First = 0
    Last = Items

    REPEAT
        Done = 0
        dec Last
        FOR lp = First to Last
            V = Table(lp + 1)
            IF Table(lp) > V
                done = 1
                Table(lp + 1) = Table(lp)
                Table(lp) = v
            ENDIF
        NEXT lp

        IF Done = 1
            Done = 0
            inc First
            FOR lp = Last to First step - 1
                V = Table(lp - 1)
                IF V > Table(lp)
                    Done = 1
                    Table(lp - 1) = Table(lp)
                    Table(lp) = v
                ENDIF
            NEXT lp
        ENDIF
    UNTIL Done = 0
ENDFUNCTION

Explanation of the Code

Table Initialization: We start by defining an array (`Table`) and filling it with random numbers using the `SeedTable` function.

Sorting Functions: Three sorting functions are defined:

- `ClassicBubbleSort`: The traditional Bubble Sort that compares adjacent elements and swaps them.

- `ClassicBubbleSortFaster`: This is an optimized version of the classic algorithm where we reduce the set size after each pass.

- `BiDirectionalBubbleSort`: This method sorts the array by alternating the direction of passes, improving performance.

Performance Tracking: The sorting times are tracked using `StartInterval` and `EndInterval`, allowing us to compare the performance of each sorting method.

Results and Performance

After running the sorting methods, we display the results, including the total time taken and the average time per frame. We also validate that the array is correctly sorted at the end of each method.

The results can vary depending on the size of the dataset, but in most cases, the optimized versions of Bubble Sort will show significant performance improvements compared to the classic method.

Final Thoughts

While Bubble Sort is not the most efficient sorting algorithm, these optimizations provide a good demonstration of how you can improve its performance in certain scenarios. Reducing the size of the set and implementing bi-directional sorting can make the classic Bubble Sort more practical for moderate-sized datasets.

However, if you’re dealing with larger datasets, it’s often better to use more advanced sorting algorithms like Merge Sort or Quick Sort, which offer much better performance.

As always, the key takeaway is that sorting is situational, and selecting the right algorithm for your data is essential. These optimizations are not a silver bullet but can provide useful improvements in the right circumstances.

Have Fun with Sorting!

Sorting is a fundamental concept in computer science, and experimenting with different algorithms and optimizations can help you understand how they work. Feel free to try out these optimizations in your own projects and see how they perform with your data!