random notes and stuff

How To Fix 'Unable to preview video' error when uploading YouTube Shorts created with Davinci Resolve

2024-03-09T21:34:00.005-05:00

This has been bothering me for ages, so annoying.. Sure you can upload directly from inside davinci resolve but in that case you're unable to set the thumbnail..

I made a video explaining how to fix this as well as published a batch file on github that does it for you

Why a batch file? Well to be fair, If you're uncomfortable using ffmpeg command line and need a program to do it for you in one click, you're probably using windows :)

https://youtu.be/jsveAP7kTpk

#HowTo #FFMPEG #VideoEditing #Shorts #diy #FOSS #OSS

https://github.com/igmrlm/TimecodeRemover

B.C. under state of emergency as fast-moving wildfire destroys homes near West Kelowna

2023-08-19T12:02:00.005-04:00

B.C. under state of emergency as fast-moving wildfire destroys homes near West Kelowna

Premier David Eby urged British Columbians to avoid non-essential travel to affected areas

Read the story here:

https://www.cbc.ca/news/canada/british-columbia/what-you-need-to-know-about-bc-wildfires-aug-18-2023-1.6940311

Today I found out "The hard way" that Google drive Enterprise has a limit to the number of files you can store..

2023-03-10T15:05:00.002-05:00

So I just got the following error while uploading files with rclone:

googleapi: Error 403: This account has exceeded the creation limit of 5 million items. To create more items, move items to the trash and delete them forever., activeItemCreationLimitExceeded

I was unaware there was a limit, I have "unlimited" storage with about 9.3 TB used, and I pay about $26 USD/month for this..

I've deleted a few million files and emptied the trash but as of yet I cannot create new files..

We shall see what happens.. how long it takes to 'update' and let me create files again..

I've added a comment on the following issue tracker..

https://issuetracker.google.com/issues/268606830

Video editor using ffmpeg that supports HDR and any other type of video, no GPU required

2023-03-09T23:23:00.005-05:00

I made a python script that lets you edit video without re-encoding and automatically cuts on the closest keyframe (iframe)

This means you can edit video without having a strong cpu, including HDR video!!!

This barely uses any CPU, and runs really really fast, as long as you're ok with jump cuts.

Check it out on github!

https://github.com/igmrlm/KeyframeCutandConcat

How-To make Trunking Recorder Play Audio Faster

2023-02-24T23:32:00.005-05:00

If you're running trunking recorder on a system that has lots of calls, you may have an issue where the calls are coming in faster than playback and a backlog of calls piles up and you have to either have to pick and choose what calls you want to hear or get far behind realtime.

I don't like either choice, so I spent a fair bit of time researching how the software works, reading through the javascript files and such and found that if you add a single line to trunkingrecorder.js you can change the default playback speed!

I'm not good enough at coding to modify it so that there's a dropdown menu to change the speed at will, but for my case, I changed the playback speed to 1.5x and find that's the perfect speed to keep up with the system I'm monitoring, Bell Fleetnet Zone 2 in Ottawa.

So how do you do this:

Open TrunkingRecorder.js in a text editor, it's located by default at:

C:\Program Files\Trunking Recorder\Website\js\TrunkingRecorder.js

Go to line 1375, where it says:

1372            audio.addEventListener('timeupdate', AudioTimeUpdated);

1372            audio.addEventListener('ended', PlayerEnded);

1373            audio.addEventListener('pause', PlayerPaused);

1374            audio.addEventListener('play', PlayerPlay);

1375            audio.addEventListener('error', PlayerError);

And add a new line:

1376            audio.defaultPlaybackRate = 1.5;

Where 1.5 is the playback rate you want to use, this could be 1.25, 1.75, 3.20 or whatever playback speed you want.

Save the file and refresh the page and VOILA!! It should now be playing faster!

Hope this helps, leave a comment if it did!

While you're at it, check out my scanner feed at https://www.youtube.com/nathanaelnewton

The Incredible Tomato Suspension Bridge Project

2023-01-11T00:47:00.005-05:00

This was shot during the summer of 2020 when I was staying at my friend's house on their small farm, we had over 85 tomato plants and due to the drip irrigation that I set up, they had grown so large that they were about to fall over with their cages, likely destroying the plants.

So, I decided to build a suspension bridge.

I had never built a suspension bridge before, I knew the basic physics behind how they worked and I figured I had enough raw materials so over the course of a few days I cut, doug, screwed, unscrewed, tore down what I had built, rebuilt it better, and eventually had what I'm calling the 'Incredible tomato suspension bridge'

I'm very proud of how it turned out, I didn't have a post hole digger so I ended up using a Shop-Vac and a small garden shovel, which was surprisingly super effective and produced an exceptional result!

Anyway, let me know what you think.. the video is a bit long I know I'm sorry, I cut out a lot and sped up most of the video 10x

Some spots I wanted to go faster than 10x but DaVinci Resolve kept glitching out so I trimmed out a few sections.

#YouTuber #SmallBusiness #Gardening #TimeLapse #Farming #tomatoes #engineering #redneckengineering #DIY #Canada #Ontario #SuspensionBridge

(Guide with code) The colorama names are too long so I made shorter ones

2023-01-07T14:25:00.000-05:00

So you're apparently supposed to use colorama like this:

import colorama

# Initialize the library
colorama.init()

# Foreground colors
print(colorama.Fore.BLACK + "Black text")
print(colorama.Fore.RED + "Red text")
print(colorama.Fore.GREEN + "Green text")
print(colorama.Fore.YELLOW + "Yellow text")
print(colorama.Fore.BLUE + "Blue text")
print(colorama.Fore.MAGENTA + "Magenta text")
print(colorama.Fore.CYAN + "Cyan text")
print(colorama.Fore.WHITE + "White text")

# Reset the foreground color
print(colorama.Fore.RESET + "Text with the foreground color reset to the default")

# Background colors
print(colorama.Back.BLACK + "Black background")
print(colorama.Back.RED + "Red background")
print(colorama.Back.GREEN + "Green background")
print(colorama.Back.YELLOW + "Yellow background")
print(colorama.Back.BLUE + "Blue background")
print(colorama.Back.MAGENTA + "Magenta background")
print(colorama.Back.CYAN + "Cyan background")
print(colorama.Back.WHITE + "White background")

# Reset the background color
print(colorama.Back.RESET + "Text with the background color reset to the default")

# Style options
print(colorama.Style.DIM + "Dim text")
print(colorama.Style.NORMAL + "Normal text")
print(colorama.Style.BRIGHT + "Bright text")
print(colorama.Style.RESET_ALL + "Text with all styles reset to the default")

print("\n**************************************************************")
print("Now, the same thing but using f-strings to print the statments")
print("**************************************************************")

# Foreground colors
print(f"{colorama.Fore.BLACK}Black text")
print(f"{colorama.Fore.RED}Red text")
print(f"{colorama.Fore.GREEN}Green text")
print(f"{colorama.Fore.YELLOW}Yellow text")
print(f"{colorama.Fore.BLUE}Blue text")
print(f"{colorama.Fore.MAGENTA}Magenta text")
print(f"{colorama.Fore.CYAN}Cyan text")
print(f"{colorama.Fore.WHITE}White text")

# Reset the foreground color
print(f"{colorama.Fore.RESET}Text with the foreground color reset to the default")

# Background colors
print(f"{colorama.Back.BLACK}Black background")
print(f"{colorama.Back.RED}Red background")
print(f"{colorama.Back.GREEN}Green background")
print(f"{colorama.Back.YELLOW}Yellow background")
print(f"{colorama.Back.BLUE}Blue background")
print(f"{colorama.Back.MAGENTA}Magenta background")
print(f"{colorama.Back.CYAN}Cyan background")
print(f"{colorama.Back.WHITE}White background")

# Reset the background color
print(f"{colorama.Back.RESET}Text with the background color reset to the default")

# Style options
print(f"{colorama.Style.DIM}Dim text")
print(f"{colorama.Style.NORMAL}Normal text")
print(f"{colorama.Style.BRIGHT}Bright text")
print(f"{colorama.Style.RESET_ALL}Text with all styles reset to the default")

I don't know what you think, but I think those names are too long and annoying, so I created shorter versions:

import colorama

# Initialize the library
colorama.init()

# Create a lookup table of shorter variable names for the Fore options
F = {
    "BLK": colorama.Fore.BLACK,
    "RED": colorama.Fore.RED,
    "GRN": colorama.Fore.GREEN,
    "YEL": colorama.Fore.YELLOW,
    "BLU": colorama.Fore.BLUE,
    "MAG": colorama.Fore.MAGENTA,
    "CYN": colorama.Fore.CYAN,
    "WHT": colorama.Fore.WHITE,
    "RST": colorama.Fore.RESET,
}

# Create a lookup table of shorter variable names for the Back options
B = {
    "BLK": colorama.Back.BLACK,
    "RED": colorama.Back.RED,
    "GRN": colorama.Back.GREEN,
    "YEL": colorama.Back.YELLOW,
    "BLU": colorama.Back.BLUE,
    "MAG": colorama.Back.MAGENTA,
    "CYN": colorama.Back.CYAN,
    "WHT": colorama.Back.WHITE,
    "RST": colorama.Back.RESET,
}

# Create a lookup table of shorter variable names for the Style options
S = {
    "DIM": colorama.Style.DIM,
    "NRM": colorama.Style.NORMAL,
    "BRT": colorama.Style.BRIGHT,
    "RST": colorama.Style.RESET_ALL,
}


# Print text with different colors and styles
print(f"{F['BLK']}{S['DIM']}Black text with dim style")
print(f"{F['RED']}{S['NRM']}Red text with normal style")
print(f"{F['GRN']}{S['BRT']}Green text with bright style")
print(f"{F['YEL']}{S['RST']}Yellow text with all styles reset")

# Print text with different backgrounds and styles
print(f"{B['BLK']}{S['DIM']}Text with black background and dim style")
print(f"{B['RED']}{S['NRM']}Text with red background and normal style")
print(f"{B['GRN']}{S['BRT']}Text with green background and bright style")
print(f"{B['YEL']}{S['RST']}Text with yellow background and all styles reset")

# Print text with different colors, backgrounds, and styles
print(f"{F['BLU']}{B['CYN']}{S['DIM']}Blue text on cyan background with dim style")
print(f"{F['MAG']}{B['WHT']}{S['NRM']}Magenta text on white background with normal style")
print(f"{F['CYN']}{B['BLK']}{S['BRT']}Cyan text on black background with bright style")
print(f"{F['WHT']}{B['RED']}{S['RST']}White text on red background with all styles reset")

# Print text with multiple styles on the same line
print(f"{S['DIM']}{F['BLK']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}text")
print(f"{S['DIM']}{F['RED']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}text")
print(f"{S['DIM']}{F['GRN']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}text")
print(f"{S['DIM']}{F['YEL']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}text")

# Print text with different colors, backgrounds, and styles
print(f"{F['BLU']}{B['CYN']}{S['DIM']}Blue text on cyan background with dim style")
print(f"{F['MAG']}{B['WHT']}{S['NRM']}Magenta text on white background with normal style")
print(f"{F['CYN']}{B['BLK']}{S['BRT']}Cyan text on black background with bright style")
print(f"{F['WHT']}{B['RED']}{S['RST']}White text on red background with all styles reset")

# Print text with different colors, backgrounds, and styles using multiple styles on the same line
print(f"{F['BLU']}{B['CYN']}{S['DIM']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}Blue text on cyan background")
print(f"{F['MAG']}{B['WHT']}{S['DIM']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}Magenta text on white background")
print(f"{F['CYN']}{B['BLK']}{S['DIM']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}Cyan text on black background")
print(f"{F['WHT']}{B['RED']}{S['DIM']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}White text on red background")

# Print all of the possible combinations of colors, backgrounds, and styles using multiple styles on the same line
for fg in F:
    for bg in B:
        print(f"{F[fg]}{B[bg]}{S['DIM']}Dim {S['BRT']}Bright {S['RST']}Normal {F['RST']}Text with {fg} foreground on {bg} background")

That's better right? Let me know what you think in the comments!

I've published my first (complicated) software!! https://github.com/igmrlm/SmartAutoTimelapse

2023-01-06T19:07:00.011-05:00

Check it out here:

https://github.com/igmrlm/SmartAutoTimelapse

This is the text script of a YouTube video I'll be uploading soon, I very rarely publish updates here so follow on YouTube to keep up-to-date: https://youtube.com/NathanaelNewton

For now, here's a video edited with this software:

Hello everyone I know this is a bit different than some of my usual videos, however, In today's video, I'll be showcasing and explaining a series of Python scripts that I’ve written recently with the help of OpenAI’s ChatGPT bot that completely automates the process of creating timelapse videos.

Before we get started, THE LEGAL STUFF!!

This code makes use of Python, FFmpeg, and OpenCV in this tutorial and is subject to their respective licenses.

Python is licensed under the Python Software Foundation License, which can be found at: https://docs.python.org/3/license.html.

FFmpeg is licensed under the GNU Lesser General Public License, which can be found at: https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

OpenCV is licensed under the BSD 3-Clause License, which can be found at: https://opencv.org/license/. By using these software tools in this tutorial, you agree to be bound by their respective licenses.

This code was originally generated with assistance from the OpenAI chatbot GPT-3, but has since been heavily modified by me to better fit the needs of my case use and significant troubleshooting and re-rewriting to make it actually work.

Please note that the use of OpenAI generated content is subject to the OpenAI API terms of use, which can be found at: https://beta.openai.com/docs/api-terms/terms. By using this script, you agree to these terms and the following:

Please be aware that this script is provided "as is" without warranty of any kind, express or implied. I make no representations or warranties of any kind with respect to this script or its use, and I shall not be liable for any damages of any kind arising from the use of this script.

By using this script, you agree to assume all responsibility for any damages or losses that may occur as a result of its use.

I hope you find this tutorial helpful. Please be sure to read and understand the legal notices outlined above before using the script. Let's get started!

Before we dive into the code, let's talk about what timelapse videos are and how they're created. A timelapse video is created from a series of photos taken at a slow interval and plays them back at a faster frame rate, creating the illusion of time passing faster. Timelapse videos can also be created by manually capturing a series of still frames from a video at a set interval and then using a video editing software to combine them into a single video. This is not as high quality as using individual raw frames but it's much simpler from a production perspective.

But what if you have a large number of videos that you want to turn into a timelapse video? Doing it manually can be time-consuming and tedious, especially if there’s a lot of parts with nothing happening, say you left the room or forgot to stop recording and these sections have to be cut out of the timelapse. That's where this Python script comes in. It completely automates this process!!

Overview and Command line Arguments

This setup uses three other scripts: one to detect motion in each frame and select only the frames with significant motion, one to concatenate the selected frames into a single video, and one to create a time-lapse of that video.

First, let's take a look at the arguments we can pass to the batch creation script.

-i or --inputfolder: the path to the input folder containing the video files that will be used to create the timelapse.
-t or --tvalue: the motion detection threshold for the timelapse, which should be a numeric value between 1 and 100.
-b or --box: the size of the box blur filter applied to the video files in the GPU. This should be an integer value.
-y or --yes: a flag that tells the script to execute the timelapse.bat file without prompting the user for confirmation.
-s or --speedup: a numerical multiplier for the speed at which the final timelapse video will play. For example, a value of 10 would result in a timelapse video that plays 10 times faster than normal.

Example Command Line Usage:

python.exe .\create_Batch.py -y -t 2 -s 5 -b 10 -i “C:\FolderWithVideos”

create_Batch.py:

import os
import subprocess
import argparse

# Parse the command-line arguments
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--inputfolder", help="path to the input folder")
parser.add_argument("-t", "--tvalue", help="Motion detection threshold, Numeric value 1-100")
parser.add_argument("-b", "--box", type=int, help="Size of box blur filter applied in GPU")
parser.add_argument("-y", "--yes", action="store_true", help="execute timelapse.bat without prompting")
parser.add_argument("-s", "--speedup", help="Numerical speedup multiplier for the final timelapse video, E.G. 1=1x, 10=10x")


args = parser.parse_args()

# Get the input folder from the command-line argument or ask the user for it
if args.inputfolder:
  input_folder = args.inputfolder
else:
  input_folder = input("Enter the path to the input folder: ")

# Get the -t value from the command-line argument or ask the user for it
if args.tvalue:
  t_value = args.tvalue
else:
  t_value = input("Enter a numeric value for the motion detection threshold from 1-100: ")
  
if args.speedup:
    speedx = args.speedup
else:
    speedx = float(input("Enter the speed at which to speed up the final timelapse (e.g. 2 for 2x speed) : "))
    
if args.box:
    box = args.box
else:
    box = int(input("Enter size of the desired box blur filterm E.g. 10 for 10x10: "))    

print("\nCreate Batch: speedx (Timelapse Speed Multiplier setting)")
print(speedx)

# Get a list of all the mp4 files in the input folder
mp4_files = [f for f in os.listdir(input_folder) if f.lower().endswith('.mp4')]

# Write the list of files  and the input folder to the console for debugging purposes
print("\n")
print(mp4_files)

print("\nCreate Batch: input_folder")
print(input_folder)

# Set the output path to the base directory of the input folder with spaces replaced with underscores

# Get the directory portion of the path
base_dir = os.path.basename(input_folder)

print("\nCreate Batch: base_dir:\n")
print(base_dir)

output_filename = base_dir.replace(" ", "_") + "_Timelapse_" + "Threshold_" + t_value + "_Speedup_" + speedx + "x.mp4"    

print("\nCreate Batch: Default output timelapse filename:\n")
print(output_filename)
  
# Open a text file for writing
with open('./timelapse.bat', 'w') as f:
  # Write the commands to the text file
  for file in mp4_files:
    f.write(f'python .\\ffac3_cuda.py -i "{input_folder}\\{file}" -o .\\work\\{file}_AutoTimeLapse_t{t_value}.MP4 -s .\\edit.txt -hh dxva2 -v "hevc_nvenc -rc vbr -cq 10 -qmin 6 -qmax 14" -f C:\\ffmpeg\\bin\\ffmpeg.exe -t {t_value} -k -b {box}\n')

  # Write the additional command to the text file
  f.write('python.exe .\\ffmpegAutoConcat.py -i .\work\ -f ' + output_filename + ' -s ' + speedx +'\n')

# Execute the file "timelapse.bat" if the user wants to
if args.yes or input("Execute timelapse.bat? [Y/n] ").lower() == "y":
  subprocess.run(['timelapse.bat'])
  print("Commands written to output.txt and timelapse.bat executed")
else:
  print("Commands written to output.txt")

Now let's take a closer look at the create_Batch.py script. The first thing the script does is import several libraries that will be used later in the script. The argparse library is used to parse command-line arguments, which allows the user to specify certain options when running the script.

Next, we have the line parser = argparse.ArgumentParser(), which creates an ArgumentParser object that will be used to define the command-line arguments that the script accepts. The script accepts several arguments, including --inputfolder, which specifies the path to the input folder containing the input videos; --tvalue, which specifies the motion detection threshold to be used when creating the time lapse videos; --box, which specifies the size of the box blur filter to be applied to the videos; --yes, which tells the script to run the batch file without prompting the user for confirmation; and --speedup, which specifies the speedup multiplier for the final timelapse video.

After the arguments have been defined, the script uses the parse_args method of the ArgumentParser object to parse the command-line arguments and store them in a variable called args.

The script then checks if the --inputfolder argument was specified, and if it was, it sets the input_folder variable to the value of the argument. If the argument was not specified, the script prompts the user to enter the path to the input folder. The script does the same thing for the --tvalue, --box, and --speedup arguments, prompting the user to enter a value if the argument was not specified.

Next, the script gets a list of all the MP4 files in the input folder using the os library, and stores the list in the mp4_files variable.

The script then sets the base_dir variable to the base directory of the input folder, with any spaces replaced with underscores. The script uses this value to create a default output filename for the final timelapse video.

Finally, the script opens a text file called timelapse.bat and writes a series of commands to the file. The first set of commands writes the command to run the ffac3_cuda.py script on each input video, creating an intermediate timelapse video for each input video. The second command writes the command to run the ffmpegAutoConcat.py script, which combines the intermediate time-lapse videos into the final timelapse video.

That's a high-level overview of the create_Batch.py script. In summary, this script is used to create a batch file that will process the input videos and create the final timelapse video. It does this by writing a series of commands to a text file, which will be run by the batch file

In the next part of the tutorial, we'll be taking a detailed look at the code in the ffac3_cuda.py script the batch file executes in sequence and explaining how it works. We'll start with a quick overview of the code, and then move on to a more detailed explanation of the motion detection section and the ffmpeg filter_complex file generation.

ffac3_cuda.py:

import os
os.environ['OPENCV_CUDA_BACKEND'] = 'cuda'
import cv2
import numpy as np
import argparse
import subprocess
import tqdm

# Ensure that the GPU is initialized
cv2.cuda.setDevice(0)

# Get the active CUDA device
device = cv2.cuda.getDevice()

# Get the device properties
device_info = cv2.cuda.DeviceInfo(device)

# Construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--input", required=True, help="path to input video file")
ap.add_argument("-k", "--show_thumbnail", action="store_true",
                help="show a thumbnail image of the frame currently being processed")
ap.add_argument("-vv", "--verbose", action="store_true", help="Print verbose output")
ap.add_argument("-o", "--output", required=True, help="path to output video file")
ap.add_argument("-s", "--edit", required=True, help="path to output edit script file")
ap.add_argument("-f", "--ffmpeg", type=str, default="c:\ffmpeg\bin\ffmpeg.exe", help="path to ffmpeg executable")
ap.add_argument("-hh", "--hwaccel", type=str, default="cuda", help="hardware encoder to use")
ap.add_argument("-v", "--vcodec", type=str, default="h264", help="video codec to use")
ap.add_argument("-t", "--threshold", type=float, default=15.0, help="relative motion threshold (0-100)")
ap.add_argument("-b", "--box", type=int, default=10, help="Size of box blur filter applied in GPU")


args = vars(ap.parse_args())

# Set the verbose flag
verbose = (args["verbose"])
filepath = (args["input"])
rawfilepath = (f"\"{filepath}\"")
filename = os.path.basename(filepath)
# Open the video file
video = cv2.VideoCapture(args["input"])

# Initialize the box filter size

if args["box"]:
    box_size = (args["box"])
else:
    box_size = 10

# Get the video properties

fps = video.get(cv2.CAP_PROP_FPS)
width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))

# Calculate the absolute threshold based on the relative threshold specified by the user
relative_threshold = args["threshold"]
threshold = args["threshold"] / 10.0 * 570 * 320

print("\n\n************************************************************\n")
print(f"Starting nate's automagical motion detection editor program! https://YouTube.com/NathanaelNewton")
print("\n************************************************************\n")
# Print the GPU device properties
print("Active CUDA device:", device)
print("Total memory:", device_info.totalMemory() / (1024**2), "MB")
print("\n************************************************************\n")


print(f"Now processing {filepath}")
print(f"If the code worked this path has quotes on it! {rawfilepath}")
print(f"The input video is {fps} frames per second")
print(f"The resolution is {width}x{height}")
print(f"The total number of frames in the video is: {num_frames}")
print("\n************************************************************\n")
print(f"The relative threshold of {relative_threshold} is calculated to have an absolute value of {threshold} \n"
      f"Remember! A higher threshold number = less sensitivity and less total frames in the output video") 
print("\n************************************************************\n\n")
print("Box filter Size:")
print(f"{box_size} x {box_size}")
print("\n************************************************************\n\n")

# Initialize the edit script
edit_script = ""

# Initialize the previous frame
prev_frame = None

# Initialize the start and end times for the current section
start_time = 0
end_time = 0

# Initialize the flag for detecting motion
detect_motion = False

# Initialize the counter for the number of frames
frame_count = 0

# create a frame on GPU for images
gpu_frame = cv2.cuda_GpuMat()

# Create the progress bar
pbar = tqdm.tqdm(total=num_frames)

# Initialize the counters for motion and no motion frames (These should be 0 that makes a divide by 0 error, This is why I say Approx haha)

motion_count = 1
no_motion_count = 1

# Initialize variables to keep track of the average, minimum, and maximum values of calc_thresh
average_calc_thresh = 0
min_calc_thresh = float('inf')
max_calc_thresh = float('-inf')


# Loop through the frames of the video
while True:
    # Read the next frame
    ret, frame = video.read()

    # Check if we have reached the end of the video
    if not ret:
        break

    gpu_frame.upload(frame)

    # Convert the frame to grayscale
    gpu_frame_small = cv2.cuda.resize(gpu_frame, (570, 320))
    gray = cv2.cuda.cvtColor(gpu_frame_small, cv2.COLOR_BGR2GRAY)
    filter = cv2.cuda.createBoxFilter(gray.type(), -1, (box_size, box_size))

    # Apply the filter to the GpuMat
    gpu_blurred = filter.apply(gray)
    
    # Calculate the absolute difference between the current frame and the previous frame
    gpu_diff = cv2.cuda.absdiff(gpu_blurred, prev_frame) if prev_frame is not None else gpu_blurred
    
    if args["show_thumbnail"]:
            gputhumbnail = gpu_diff
            gthumb = gputhumbnail.download()
            cv2.imshow('Difference Calculation 2', gthumb)
            cv2.waitKey(1)
    
    diff = gpu_diff.download()
     
    # Calculate the sum of the absolute differences
    sum_diff = np.sum(diff)

    overage = round(sum_diff / threshold, 3)
    overage = (f'{overage:.3f}')
    calc_thresh = round(sum_diff * 10.0 / 570 / 320,4)
    
    # Update the running average, minimum, and maximum values of calc_thresh
    average_calc_thresh = (average_calc_thresh * 49 + calc_thresh) / 50

    # Check if the sum is above the threshold
    if sum_diff > threshold:
        # Motion has been detected
        motion_count += 1

        # Check if we were previously detecting motion

        if detect_motion:
            # Update the end time
            end_time = frame_count / fps
        else:
            # Start a new section
            start_time = frame_count / fps
            end_time = start_time
            detect_motion = True

        # Display a thumbnail image of the frame being currently processed if the user specifies the -k flag
        if args["show_thumbnail"]:
            thumbnail = cv2.resize(frame, (570, 320))
            cv2.imshow('Frames being included 2', thumbnail)
            cv2.waitKey(1)

        # Calculate the ratio and percentile of frames with motion to frames with no motion
        motion_ratio = round(motion_count / (motion_count + no_motion_count), 4)
        motion_percent = round(100 * motion_count / (frame_count + 1), 1)

        # Updated the rounded versions of the averages
        
        ave_round = round(average_calc_thresh,4)

        # Print a message indicating that motion has been detected
 
        print(
            f"\033[F\033[0K\u001b[42;1m***** Motion\u001b[0m in frame: {frame_count} \tFrames in {filename} at threshold of {relative_threshold} with motion: {motion_count}  \t "
            f"Without: {no_motion_count} \t Approx. \u001b[40;1m{motion_percent} %\u001b[0m of the frames have motion \t Detected: {sum_diff}\t\tRelative multiplier {overage}\t\tCalculated threshold is {calc_thresh}\t\tAverage of last 50 frames: {ave_round}") 
    else:
        # No motion has been detected
        no_motion_count += 1

        # Check if we were previously detecting motion

        if detect_motion:
            # Motion has stopped, so add the current section to the edit script
            edit_script += f"between(t,{start_time},{end_time})+"
            detect_motion = False
        else:

            if args["show_thumbnail"]:
                thumbnail2 = cv2.resize(frame, (570, 320))
                cv2.imshow('Frames being disguarded 2', thumbnail2)
                cv2.waitKey(1)

        motion_ratio = round(motion_count / (motion_count + no_motion_count), 4)
        motion_percent = round(100 * motion_count / (frame_count), 1)
        # Updated the rounded versions of the averages
        
        ave_round = round(average_calc_thresh,4)
        
        print(
            f"\033[F\033[0K\u001b[41;1m** No motion\u001b[0m in frame: {frame_count} \tFrames in {filename} at threshold of {relative_threshold} with motion: {motion_count} \t "
            f"Without: {no_motion_count} \t Approx. \u001b[40;1m{motion_percent} %\u001b[0m of the frames have motion \t Detected: {sum_diff}\t\tRelative multiplier {overage}\t\tCalculated threshold is {calc_thresh}\t\tAverage of last 50 frames: {ave_round}") 

    # Update the previous frame
    prev_frame = gpu_blurred

    # Increment the frame counter
    frame_count += 1

    # Update the progress bar
    pbar.update(1)

# Close the progress bar
pbar.close()

# Print the total number of frames with motion and no motion
print(f"Total number of frames with motion: {motion_count}")
print(f"Total number of frames with no motion: {no_motion_count}")

# Calculate the ratio of frames with motion to frames with no motion

motion_ratio = motion_count / (motion_count + no_motion_count)

print(f"Ratio of frames with motion to frames with no motion: {motion_ratio:.2f}")

# Check if we were still detecting motion at the end of the video
if detect_motion:
    # Add the final section to the edit script
    edit_script += f"between(t,{start_time},{end_time})"

# Add the trailing code to the edit command

edit_video = f"[0:v]select=\'{edit_script}"
edit_audio = f"[0:a]aselect=\'{edit_script}"

# Remove the extra '+' sign at the end of the edit script, if any
edit_video = edit_video.rstrip("+")
edit_audio = edit_audio.rstrip("+")

edit_video += f"\',setpts=N/FRAME_RATE/TB[v];\n"
edit_audio += f"\',asetpts=N/SR/TB[a]"

filter_complex = edit_video + edit_audio
if verbose:
    print("Printing the complex filter\n************\n")
    print(filter_complex)

# Close the video file
video.release()

# Print the Edit scripts for debugging purposes

if verbose:
    print("\n\n************\nVideo script \n")
    print(edit_video)
    print("\n\n************\nAudio script \n")
    print(edit_audio)

# Check if the edit script is not empty
if edit_video:
    # Create a temporary file to store the edit script
    with open("filter_complex.txt", "w") as f:
        f.write(filter_complex)

    # Get the path of the temporary file
    edit_video = f.name

    # Create the command for ffmpeg

    command = f"{args['ffmpeg']} -hwaccel {args['hwaccel']} -i {rawfilepath} -filter_complex_script .\\{edit_video} -vcodec {args['vcodec']} -map [v] -map [a] {args['output']} "

    print("\n\n************\nNOW Executing the following ffmpeg command:\n")
    print(command)
    print("\n\n************\n")
    # Execute the command
    subprocess.run(command)

So let's get started with a quick overview of the code. The ffac3_cuda.py script is written in Python and uses the OpenCV library to process the input video. The script accepts a number of command-line arguments, including the path to the input video, the path to the output video, and the path to the output edit script file. The script also allows the user to specify the hardware encoder to use, the video codec to use, and the relative motion threshold to use when creating the timelapse video.

-i or --input: the path to the input video file that will be processed. This argument is required.
-k or --show_thumbnail: a flag that tells the script to show a thumbnail image of the frame currently being processed.
-vv or --verbose: a flag that tells the script to print verbose output to the console.
-o or --output: the path to the output video file. This argument is required.
-s or --edit: the path to the output edit script file. This argument is required.
-f or --ffmpeg: the path to the ffmpeg executable. The default value is "c:\ffmpeg\bin\ffmpeg.exe".
-hh or --hwaccel: the hardware encoder to use. The default value is "cuda".
-v or --vcodec: the video codec to use. The default value is "h264".
-t or --threshold: the relative motion threshold for the timelapse, which should be a numeric value between 0 and 100. The default value is 15.
-b or --box: the size of the box blur filter applied to the video file in the GPU. This should be an integer value. The default value is 10.

Example command line usage with custom parameters to use h.265:

python .\ffac3.py -i .\MVI_0248.MP4 -o .\MVI_0248_AutoTimeLapse_t12.MP4 -s .\edit.txt -hh dxva2 -v "hevc_nvenc -rc vbr -cq 10 -qmin 6 -qmax 14" -f C:\ffmpeg\bin\ffmpeg.exe -t 12

The script begins by importing several libraries and setting up the GPU for use with OpenCV. It then parses the command-line arguments and gets the properties of the input video, such as the frame rate, resolution, and number of frames.

The script then calculates the absolute motion threshold based on the relative motion threshold specified by the user, and opens the input video using the cv2.VideoCapture function.

Next, the script enters a loop that reads each frame of the input video, processes it to detect motion, and writes the resulting frame to the output video.

The motion detection section of the code is responsible for analyzing each frame of the input video and determining whether it should be included in the timelapse video. The script uses the OpenCV cv2.absdiff function to compare each frame to the previous frame and calculate the absolute difference between them. This difference is then compared to the absolute motion threshold that was calculated earlier in the script. If the difference is greater than the threshold, it means that there was enough motion in the frame to be included in the timelapse video. If the difference is less than the threshold, it means that there was not enough motion in the frame and it should be discarded.

The script also uses the OpenCV cv2.cuda.GpuMat function to create a GPU memory buffer that is used to store the intermediate frames as they are processed. This allows the script to take advantage of the GPU's parallel processing capabilities and significantly speed up the motion detection process, although this feature is barebones and has significant room for improvement. Personally I run two copies of the program at once from different working directories to maximize the CPU and GPU usage on my pc. Your PC may be more powerful and able to run even more instances.

While this version uses cuda, it’s quite simple to convert the function calls to cpu versions, in fact, the first version of this software i created used the cpu to process everything. Leave a comment if you would like me to release that version as well in a followup video.

Once the motion detection process is complete, the script writes the resulting frames to the output video using the OpenCV cv2.VideoWriter function. It also writes the start and end times of each frame to the output edit script file, which will be used later to create the final timelapse video using ffmpeg.

[In the video: Show the section of the code that performs the motion detection, the code in action and explain all the console output]

That's a detailed explanation of the motion detection section of the ffac3_cuda.py script. As you can see, this script uses a combination of OpenCV functions and GPU acceleration to efficiently and accurately detect motion in the input video and create a timelapse video from the resulting frames.

In the next part of this tutorial, we'll be taking a closer look at the ffmpeg filter_complex file generation section of the code and explaining how it works.

[In the video: Some kind of time lapse intermission]

In this part of the tutorial, we'll be taking a detailed look at the ffmpeg filter_complex file generation section of the ffac3_cuda.py script.

The ffmpeg filter_complex file generation section of the code is responsible for creating a file that specifies the filters that will be applied to the intermediate timelapse videos to create the final timelapse video. This file is written in the ffmpeg filtergraph syntax and is used by the ffmpeg command-line tool to apply the filters to the videos.

The script generates this file by first creating an empty list called filters that will be used to store the filters that will be applied to the videos. It then enters a loop that reads each line of the output edit script file, which contains the start and end times of each frame in the intermediate time lapse videos. For each line in the edit script file, the script creates a filter string in the ffmpeg filter_complex syntax and adds it to the filters list.

Once all of the filters have been added to the filters list, the script writes the list to the ffmpeg filter_complex file using the Python write function. The filter file is then closed and the script continues with the next step in the process.

[Show the section of the code that generates the ffmpeg filter_complex file]

ffmpegAutoConcat.py:

import os
import subprocess
import argparse

# Parse the command-line arguments
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--inputfolder", help="path to the input folder")
parser.add_argument("-f", "--filename", help="Output file name")
parser.add_argument("-s", "--speedup", help="amount to speed up the video")

# parser.add_argument("-y", "--yes", action="store_true", help="execute timelapse.bat without prompting")
args = parser.parse_args()

def concatenate_files(folder_path):
    # Create a list of all the file paths in the specified folder
    file_paths = [os.path.join(folder_path, file) for file in os.listdir(folder_path)]

    # Write the list of file paths to the file mylist.txt, with each line prepended with "file " and the path wrapped in single quotes
    with open("mylist.txt", "w") as file:
        file.write("\n".join(['file \'' + path + '\'' for path in file_paths]))
  
    # Use ffmpeg to concatenate the files
    concat_command = (["c:\\ffmpeg\\bin\\ffmpeg.exe", "-y", "-f", "concat", "-safe", "0", "-i", "mylist.txt", "-c:v", "copy", "-an", "temp_output_delete_me.mp4"])
    print("\n\n************\n")
    print("Starting nate's automagical automatica timelapse generator! https://YouTube.com/NathanaelNewton")
    print("NOW Executing the following ffmpeg command:\n")
    print(concat_command)
    if args.inputfolder:
       print(f"Input folder: {args.inputfolder}")
    if args.speedup:
       print(f"Speedup multiplier: {args.speedup}")
    
    print("\n\n************\n")
    
    subprocess.run(concat_command)


def create_time_lapse(input_path, output_path, speed):
    # Use ffmpeg to create a time lapse of the input video
    time_lapse_command = (["c:\\ffmpeg\\bin\\ffmpeg.exe", "-y", "-hwaccel", "dxva2", "-i", input_path, "-vf", f"setpts={1 / speed}*PTS", "-vcodec", "hevc_nvenc", "-rc", "vbr", "-cq", "10", "-qmin", "6", "-qmax", "14", "-r", "60", output_path])
    
    print("\n\n************\nNOW Executing the following ffmpeg command:\n")
    print(time_lapse_command)
    print("\n\n************\n")
    subprocess.run(time_lapse_command)

if __name__ == "__main__":
    if args.inputfolder:
      folder_path_response = args.inputfolder
    else:
      folder_path_response = input("Enter the path to the input folder: ")

    # Concatenate the files
    folder_path = folder_path_response
    concatenate_files(folder_path)
    
    # Set the default input and output paths to the current directory
    input_path = "temp_output_delete_me.mp4"
    
    # Ask the user the speedup value if not in the commandline execution options
    
    if args.speedup:
      speed = float(args.speedup)
    else:
      speed = float(input("Enter the speed at which to speed up the final timelapse (e.g. 2 for 2x speed) : "))

    if args.filename:
        print("Default Name:\n")
        print(args.filename)
        output_path = args.filename
    
    output_path_response = input("\n\n************\nEnter the path for the output video (press Enter for default): ")
    if output_path_response:
        output_path = output_path_response

    # Create the time lapse
    create_time_lapse(input_path, output_path, speed)

Overall, the script is a powerful tool that allows you to create timelapse videos from a series of input videos with ease. It uses a combination of Python, OpenCV, and GPU acceleration to efficiently and accurately detect motion in the input videos and create the intermediate time lapse videos.

One of the benefits of using open source software like this script is that it is freely available for anyone to use and modify. This means that you can use the script to create timelapse videos for your own personal use, or you can modify the script to fit your specific needs (Provided you follow the respective license agreements.)

Another benefit of using open source software is that it is typically developed and maintained by a community of volunteers who are passionate about the software and are dedicated to making it better. This means that open source software is often of high quality and is regularly updated to fix bugs and add new features.

One thing to note is that figuring out the section with the filter complex was very difficult and it seems to be insufficiently documented. However, with a little perseverance and some online research, it is possible to understand how it works and modify it to fit your specific needs.

Have you ever used ffmpeg or a similar tool to create timelapse videos? Do you have any ideas for how the scripts could be improved or modified? I know I can think of a few.. feel free to share your suggestions!

Are you interested in learning more about Python, OpenCV, or other programming languages and technologies? Let me know what you think of my presentation style and what subjects you'd like to learn more about.

FFMPEG command Cheat Sheet

2022-12-21T11:06:00.010-05:00

I've made many FFMPEG command lines over the years and keep losing track of them.

I've decided to post them here in a list and edit them as I find / make more.

Create a time lapse video from an input file, one frame every 15 frames, maximum VBR quality, rotate 90 degrees counterclockwise and vertical flip, delete audio and encode with h.265 using cuda and nvenc on a nvidia graphics card.

ffmpeg.exe -hwaccel cuda -i input.MP4 -vf framestep=15,setpts=N/60/TB,fps=60,transpose=0 -c:v hevc_nvenc -rc vbr -cq 0 -qmin 0 -qmax 1 -profile:v main10 -pix_fmt p010le -b:v 0K -an -max_interleave_delta 0 output.mkv

Combine an input video and two separate mono audio tracks into a single video file, encoding with dxva using nvenc on a nvidia graphics card. Example input would be video exported from Davinci Resolve

ffmpeg -y -hwaccel_output_format d3d11 -hwaccel d3d11va -i "video.mxf" -i "A01.mxf" -i "A02.mxf" -filter_complex "[1:a][2:a]join=inputs=2:channel_layout=stereo[a]" -map "[a]" -map 0:v -c:v hevc_nvenc -rc vbr -cq 10 -qmin 6 -qmax 14 -profile:v main10 -pix_fmt p010le -b:v 0K out.mp4

Same as above but on an AMD/ATI card and with bitrate set to 100 megabit

ffmpeg -y -hwaccel_output_format d3d11 -hwaccel d3d11va -i '.\video.mxf' -i '.\A01.mxf' -i '.\A02.mxf' -filter_complex "[1:a][2:a]join=inputs=2:channel_layout=stereo[a]" -map "[a]" -c:a pcm_s16le -map 0:v -c:v hevc_amf -b:v 100M "out.mkv"

Trapezoid transform a video with perspective example, trim a bit off the left top and left bottom of a 4k vertical video

Top left corner 29:490

Top right corner 2160:0

Bottom left corner 76:3241

Bottom right corner 2160:3840

-lavfi "perspective=29:490:2160:0:76:3241:2160:3840:interpolation=linear"

How to fix broken MP4 Videos for free

2022-09-27T15:59:00.002-04:00

if you have any broken mp4s, such as mov atom missing from your phone/camera/card dying during recording..

This gnu v2 app works Awesome!

https://github.com/ponchio/untrunc

I used it a few days ago to repair a video from a drone that was corrupted

I have a paid app on my android that I was using but it couldn't figure out the drone video so I had to find an alternative, this one worked much better

I used an Ubuntu virtual machine and followed the instructions on that page and fixed my video.

2022-08-19T19:36:00.002-04:00

If you get

./mp4grep/bin/mp4grep: error while loading shared libraries: libvosk.so: cannot open shared object file: No such file or directory

You probably need to run ldconfig on the folder containing libvosk

in my case it was

sudo ldconfig /home/nate/.local/lib/

2022-02-21T23:35:00.004-05:00

I wrote a python program to put a taskbar icon with the CPU IDLE Percentage over time.

Lots of this is copied from stackoverflow of course..

This is what it looks like:

from infi.systray import SysTrayIcon
from PIL import Image, ImageDraw,ImageFont
import time
import psutil
import threading
import wx
import wx.adv
import datetime
from wx.lib.embeddedimage import PyEmbeddedImage

def background():
    while True:
        uptime = time.time() - psutil.boot_time()
        global idle_ratio
        idle_ratio = psutil.cpu_times().idle / psutil.cpu_count() / uptime * 100
        d = uptime // (24 * 3600)
        uptime = uptime % (24 * 3600)
        h = uptime // 3600
        uptime %= 3600
        m = uptime // 60
        uptime %= 60
        s = uptime
        print(idle_ratio)
        time.sleep(10)
        if stop_threads:
            break
global stop_threads
stop_threads = False
# print(f"Uptime: {d:n}d {h:02n}:{m:02n}:{s:02n} - Idle Ratio: {idle_ratio:02.2f}%")


b = threading.Thread(name='background', target=background)
print("starting thread")
b.start()
print("\nIdle ratio:")
print(idle_ratio)
#
# A white box 28x28 pixels
#
toggletest = PyEmbeddedImage(
    b'iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAAACXBIWXMAAAsTAAALEwEAmpwY'
    b'AAAAB3RJTUUH4wMfCgElTFaeRQAAAB1pVFh0Q29tbWVudAAAAAAAQ3JlYXRlZCB3aXRoIEdJ'
    b'TVBkLmUHAAAAKElEQVRIx2P8//8/A7UBEwMNwKiho4aOGjpq6Kiho4aOGjpq6OAzFADRYgM1'
    b'8cIRtgAAAABJRU5ErkJggg==')

class TaskBarIcon(wx.adv.TaskBarIcon):
    def __init__(self, frame):
        self.frame = frame
        self.toggle = 0
        wx.adv.TaskBarIcon.__init__(self)
        self.Bind(wx.adv.EVT_TASKBAR_LEFT_DOWN, self.OnToggle)
        self.font = wx.SystemSettings.GetFont(wx.SYS_SYSTEM_FONT)
        self.font.SetPointSize(4)
        self.OnSetIcon(self.NewIcon())

    def CreatePopupMenu(self):
        menu = wx.Menu()
        togglem = wx.MenuItem(menu, wx.NewId(), 'Toggle Icon')
        menu.Bind(wx.EVT_MENU, self.OnToggle, id=togglem.GetId())
        menu.Append(togglem)
        menu.AppendSeparator()
        flashm = wx.MenuItem(menu, wx.NewId(), 'Flashing Icon')
        menu.Bind(wx.EVT_MENU, self.OnTimer, id=flashm.GetId())
        menu.Append(flashm)
        menu.AppendSeparator()
        quitm = wx.MenuItem(menu, wx.NewId(), 'Quit')
        menu.Bind(wx.EVT_MENU, self.OnQuit, id=quitm.GetId())
        menu.Append(quitm)
        return menu

    def NewIcon(self):
        bitmap = wx.Bitmap(toggletest.Bitmap)
        dc = wx.MemoryDC(bitmap)
        # Use current time as text, for want of something useful
        dc.SetFont(self.font)
        ratio = str(idle_ratio)
        dc.DrawText(ratio, 0, 7)
        del dc
        return bitmap

    def OnSetIcon(self, bitmap):
        icon = wx.Icon()
        icon.CopyFromBitmap(bitmap)
        self.SetIcon(icon)

    def OnToggle(self, event):
        bitmap = self.NewIcon()
        self.OnSetIcon(bitmap)

    def OnTimer(self,event):
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.OnUseTimer)
        self.timer.Start(10000)

    def OnUseTimer(self,event):
        self.OnToggle(None)

    def OnQuit(self, event):
        self.RemoveIcon()
        wx.CallAfter(self.Destroy)
        self.frame.Close()
        global stop_threads
        stop_threads = True


if __name__ == '__main__':
    app = wx.App()
    frame=wx.Frame(None)
    TaskBarIcon(frame)
    app.MainLoop()

2022-02-02T01:13:00.002-05:00

Python script I found on stack exchange that was hard to understand so I modified it to make it better.

This script adds the glob feature from ffmpeg *.jpg or *.png etc image sequences to windows.

import subprocess
import glob
import os

filenames = glob.glob("path/to/folder*.jpg")
duration = 0.05

with open("ffmpeg_input.txt", "wb") as outfile:
    for filename in filenames:
        outfile.write(f"file '{filename}'\n".encode())
        outfile.write(f"duration {duration}\n".encode())

command_line = f"ffmpeg -y -r 60 -f concat -safe 0 -i ffmpeg_input.txt out.mp4"
print(command_line)

pipe = subprocess.Popen(command_line, shell=True, stdout=subprocess.PIPE).stdout
output = pipe.read().decode()
pipe.close()

2022-01-15T18:26:00.003-05:00

For years I've been complaining about how terrible Windows search is. Today I posted on a chatroom "why is it that it's 2022 and C:\>dir /b /s |findstr *str* is still the fastest way to search for files"

Someone replied, 'everything is pretty nice'

This is going to change my life... D:

Everything is the best search program for windows i've ever used.. I love it!!!

You're welcome:

https://www.voidtools.com/

How-To make FFMPEG concatenate all files in a folder into one video without re-encoding (LINUX)

2019-08-09T15:47:00.001-04:00

Replace *.mp4 with whatever your filenames are, such as *.mkv *.mp4 etc

find *.mp4 | sed 's:\ :\\\ :g'| sed 's/^/file /' > filelist.txt; ffmpeg -f concat -i filelist.txt -vcodec copy -an output.mp4

2018-11-28T23:36:00.000-05:00

Testing out the new 'Auto Ads'
I wonder how well this will work, here's a cute puppy video to go with it:

A warning to all SMART / RG users

2017-03-19T18:16:00.000-04:00

So I was at my friend's house working on the youtube show that we do every week (Pottawa) and, since my phone had broken a few days before, I had my tablet with me and needed to connect it to the wifi.

He told me that the wifi password is the same as what's written on the back of the modem, and I, expecting to find some type of sticker with the WPA key, looked at the modem but only found the mac address listed. I thought surely that they wouldn't be doing something as stupid as using the MAC address (BSSID Public broadcast) as the pre-shared encryption key, but I thought, whatever I will try it anyway.

I wrote it in all caps and it, of course, didn't work because they couldn't be that stupid right? Well, I had my laptop with me and decided to try to log into the modem and see if it had the key listed in the modem setup page.

After 2 tries, I was able to log in with admin/admin and went to the page to find to my horror that indeed, the default password was the base MAC address. I then compared the key to the broadcasted BSSID and found that the BSSID and the WPA-PSK differed by only the last digit, e.g. "XXXXXXXXXXX9" was the BSSID and XXXXXXXXXXX7 was the key.

I thought ok, this isn't quite as bad as I first thought until I suddenly realized. The default ESSID. The last 4 characters... it matched the key, not the mac.

So!! this means, the default password for Primus ADSL Wifi Modems is the first 8 characters of the Public BSSID broadcast (Visible with apps like wigle) + the last 4 characters of the ESSID (The publicly visible name of the Wifi)

Review -- Is the Bible Reliable By John Piper

2015-08-26T06:20:00.000-04:00

Leave a comment if this is "TL;DR" and you'd prefer to hear me read this aloud.

Background information:

This booklet is 24 pages long, first published in 1986 and reprinted in 1996 and 2003. Reviewing through referenced materials in this booklet I find the most recently published referenced source material to be on the first page, cited as published in 1983. I find it likely that this is the most recent source for the information in this pamphlet, but I don’t assert that assumption. The booklet is not long enough to be separated into chapters, however is instead separated three main sections covering a dozen or so paragraphs at a time.

Section 1: Does God exist?

The very first sentence acknowledges that this subject typically cannot be adequately addressed in such a short space and takes the opportunity to provide the longest list of references in the whole pamphlet, suggesting that the reader examine these additional books as well. The author plans to try to address this anyway and then proceeds to claim that he will try not to go too much in-depth on either side of dogmatism or apologetics. The next paragraph is a disclaimer stating the author's bias and that he believes (in the existence of the traditional Christian God) and admits that there may be sociological causes for his belief but asserts that his personal testing of this faith has proved it to be inescapably conclusive.

As we come to the first logical fallacy, a straw man argument (1), he starts off by asking the reader to imagine a time back a “million billion trillion years” and what the universe was like at that time. Firstly, no serious person claims the cosmos is anywhere near that old and secondly, a hypothetical imagined scenario with no evidence is not how one starts to look for information about anything. Observation should be key here, not imagination, and this leads me to wonder if he is aware of discoveries in this subject, such as the mountains of data corroborated by the Hubble Space Telescope in the span 10-25 years after this pamphlet was originally written. The next logical fallacy, a false dichotomy (2), follows then in the same paragraph, where he asserts to be a “stunning fact,” his idea that the universe at this time was a 50/50 chance to be either full of gas or a person. He then again claims as fact, without reference, that the first thing or person that existed, always existed and that it makes more sense that an eternal existence be a person rather than a gas. He obviously is unaware of the observed actions of the quantum, or extremely small, world, in where it has been experimentally shown that something can come from nothing. (A) On a side note, this reminds me of the Luminiferous aether proposed in the 17th century that turned out to be completely imaginary. The author continues from here assuming you agree with both of these “possibilities” and goes on to assume that this was enough to make the reader more receptive to whatever evidence he has further to provide. He then expresses his own belief that due to the perceived order of the universe (the Teleological argument) and the moral nature of humans (the argument from morality) that he finds it impossible to “believe” that all of human endeavor throughout time was caused by naturalistic means. This is not an argument, just a statement of belief.

To conclude section one, he writes about his search for enduring happiness and references the beliefs that he has asserted to this point as proof that the aforementioned “person” must be the creator of all things and naturally is the only source of true happiness. Finally he chides causal thiests for their lack of attention to this person and warns them of his believed reckoning coming at the end of time.

Section 2. Who is Jesus Christ?

The author begins this section continuing from the previous paragraph by stating that his confident reason for trusting the Christian Bible is what he calls the “authenticity, love, and power” of Jesus. He then references the gospel stories of Jesus’s life and alleged resurrection as his primary source of information. He then goes on to write that the reader does not need to believe in the inspiration of the Bible for honest analysis to reveal the authenticity of his (the author’s) position and proceeds to provide examples from the gospels to create a picture of who he believes Jesus was and who the gospels claim Jesus believed himself to be. This continues for about 4 pages and is not intended to address the factualness of any of the stories or to compare accounts, but is intended only to portrait a general idea of what the gospels contain. After this, the author claims that a critical study of the gospels throughout history will not reveal any other significantly different versions of the story, but fails to define significant difference or any references and does not mention such things as the gospel of Thomas, the apparently added ending to the gospel of Mark etc.

The next argument he puts forward is the idea that the story of Jesus, presented in the Bible, is so outlandish and unnatural that it is unreasonable to think that someone invented such a fantastic story and that it’s more likely that it’s true, especially due to the huge number of believers. He claims that no one would write such a thing unless it was based on “some real event” This same “argument” can be applied to the Book of Mormon, the story of Muhammad in the Koron, Zeus, even Twilight and Star Wars, so it is not in any way helpful to his attempts to prove the reliability of the Bible. This is also another false dichotomy because the only options he provides are that either the accounts are completely accurate or were fabricated entirely in their current form, leaving no room for gradual mythology.

In the next 5 pages of the booklet the author outlines his reasons for believing that Jesus raised from the dead, once again referring to numerous passages from the New Testament forgetting that he has yet to prove their authenticity. He cites many criticisms of the New Testament account such as the stolen body theory, and also brings up the passage that claims over 500 witnesses saw Jesus personally after his resurrection -- but he fails to mention the fact that not only is a 3 hour eclipse impossible astronomically, but that there is not a single extra-biblical record of any of these events. No one wrote about these apparently world shaking events until nearly 80 years after they were to have taken place and the only references are found in the New Testament, written by at least third party sources who never physically met Jesus and who already revered him as a god.

At the end of this section he has a warning for believers and tells them that whenever they are debating the ideas presented so far, to be wary of people demanding proof and advises them to evade the question by reversing it on their opponent. He sets up another straw man by generalizing the idea of secular skepticism and defining it narrowly as the fundamentalist belief that absolute knowledge is impossible when the context of the paragraph implies that he is referring to scientific skepticism, also called rational skepticism (3.)

Section 3. How this relates to the Bible:

The author now assumes that the reader has accepted his circular “proof” and continues to discuss what the gospels claim Jesus said concerning the Old Testament, or Hebrew scriptures. The next 3 pages in a nutshell: The New Testament account claims that Jesus revered the “Law and the Prophets” as the authoritative word of god, so the reader should give it the same respect.

The last section of the pamphlet at page 18 finally mentions the idea of historical extra-biblical verification but then claims that subject is far too detailed to be covered in a booklet of this length and refers to another book “Christ and the Bible by John W Wenham 1972.” After that statement the author he gives 6 “reasons” why he has confidence in its authenticity, which, as before are either directly sourced from the New Testament or are based on appeal to emotion such as “it makes sense,” “it has a ring of truth.” The last reason he gives deserves mention because it’s the Baptist Catechism -- as if that was a source for corroborating the New Testament.

Appendix. Formation of the Canon of Scripture:

The last 3 pages of the booklet have a few notes about the construction of the 66 books into a single set as we know them today. They outline his continued circular use of different sections of of the Bible to support the authenticity of the whole Bible without any corroborating evidence, mentioning Ezra and the “lost” book of the law in the reign of Josiah. (B)

The final section of the book discusses how the church leaders in the centuries following the events portrayed in the the New testament chose which books were inspired but glosses over the fact that they were decided by committee and popular vote.

Conclusion:

This pamphlet did not attempt at all to research the history of the formation of the books now combined into the Bible, such as who wrote Genesis (C) or why their are so many discrepancies between the teachings of different books (D) instead it appears to be targeting under informed individuals willing to take what it says at face value without doing any research.

Definitions -- Wikipedia (W) Merriam-Webster, when available (MW):

Straw Man argument:

(W) A straw man is a common form of argument and is an informal fallacy based on giving the impression of refuting an opponent's argument, while actually refuting an argument which was not advanced by that opponent.

(MW) A weak or imaginary argument or opponent that is set up to be easily defeated

False dichotomy:

(W) A false dilemma (also called false dichotomy, false binary, black-and-white thinking, bifurcation, denying a conjunct, the either–or fallacy, fallacy of exhaustive hypotheses, the fallacy of false choice, the fallacy of the false alternative, or the fallacy of the excluded middle) is a type of informal fallacy that involves a situation in which only limited alternatives are considered, when in fact there is at least one additional option.

Scientific skepticism:

(W) The practice of questioning whether claims are supported by empirical research and have reproducibility, as part of a methodological norm pursuing "the extension of certified knowledge”

References

Lawrence M. Krauss (2014) "Universe from NOTHING!"

https://www.youtube.com/watch?v=sbsGYRArH_w

3.3.3 Atheism: A History of God (Part 1)

https://www.youtube.com/watch?v=MlnnWbkMlbg

3.3.3 Atheism_ A History of God (Part 2)

https://www.youtube.com/watch?v=yPfFx9JTQl8

The Evolution of Genesis

https://www.youtube.com/watch?v=FLviKiEuj30

Quiz Show (Bible Contradictions) -- Comedy styled, less serious than the rest

https://www.youtube.com/watch?v=RB3g6mXLEKk

Additional related content:

Why I am no longer a christian

https://www.youtube.com/watch?v=mSy1-Q_BEtQ&list=PLA0C3C1D163BE880A

Foundational Falsehoods of Creationism

https://www.youtube.com/playlist?list=PL126AFB53A6F002CC

Bible Slavery

https://www.youtube.com/watch?v=2MFmC6BD1B4

2015-01-26T17:00:00.000-05:00

In order to get uptime from Pfsense via SNMP you have to enable all the snmp checks, including "host resources"

Then query oid 1.3.6.1.2.1.25.1.1.0 and you will get the uptime value in centisecond increments (10 milliseconds)

This also seems to work with engenius access points and WiFi distribution systems.

Your're welcome :)

New weather videos!

2014-10-08T18:30:00.000-04:00

So.. my weather playlist has some new videos

I need a new camera badly, but there's still some good shots :D

2014-10-08T18:28:00.001-04:00

So.. my weather playlist has some new videos

I need a new camera badly, but there's still some good shots :D

Mysql and gentoo

2014-07-14T13:53:00.000-04:00

I couldn't find this in Google..

Mysql package version: dev-db/mysql-5.1.70

13:45 < igmrlm> i'm having a dificulty with "emerge --config mysql"

13:46 <+grknight> igmrlm: ok. i maintain it. what's the issue?

13:46 < igmrlm> it dies saying it * Failed to load zoneinfo!

13:47 <+grknight> igmrlm: known bug in the stable version that is due to be fixed in 5.5.38 (which is a stable candidate)

13:47 <+grknight> stable cannot handle the recursion with posix pointing to itself in zoneinfo

13:47 < igmrlm> ok, cool, noob question then, how do i tell it to emerge that specific version?

13:48 <+grknight> igmrlm: 'emerge -a1 =dev-db/mysql-5.5.38 =virtual/mysql-5.5' or use mariadb instead of mysql which will be the new default very soon

Massive engineering menu -- Ontop Nugget D5 -- Android 4.1.2

2014-05-15T16:25:00.000-04:00

UPDATE 2014-07-16

I was going to to write a tirade about staples, but to my surprise they were more understanding than I ever would have expected.

This cellphone turned out to be the single worst piece of electronics I ever purchased, that combined with the company made for a terrible experience.

This phone worked ok for a few months, then the antenna cable must have disintegrated or something because it would no longer get cellphone or gps reception. When i tried to contact the company that made it, ontop, they did not respond at all to email queries, they have no phone contact and then about a week later they deleted the website for the phone.. Very shady...

**End of update**

I needed a new cell phone this year after smashing my old phone while sledding. I'm very cheap so I thought I'd try a Chinese brand, one Staples.ca exclusive model, the OnTop Nugget D5.

http://www.ontopglobal.com/products/nugget-d5

It has dual sim cards, microsd card, dual cameras, wifi, gps etc.. The usual stuff in an android, dual core cpu, more than adequate performance compared to the Samsung arm6 cpu I had before.

It's buggy, snapchat video crashes the phone, the antenna cable from the 3g/wcdma/etc modem came loose from the motherboard and I had to reattach it, and the BIGGEST ANNOYANCE OF ALL, the headphone jack is wired wrong and the only way to get stereo music from them is to hold the headset button forever.

That being said, last night I went into the engineering menu to see if i could manually update the Extended Prediction Orbit GPS satellite data, and I have to say, this engineering menu has more options than all the phones I've had put together.

(You can get the menu by "calling" number *#*#3646633#*#*)

Click any photo for a slideshow and larger versions

Main menu

Autoanswer

Preferred band mode

Preferred network type

Video Telephony.. this would be cool to actually try

I suspect this could cause so major interference and may be highly illegal to do outside of a shielded test center.. unsure perhaps only if done maliciously.. It looks like you could cause some significant problems to the Bluetooth band.. It might jam all nearby devices.

More dangerous looking settings...

I definitely need to experiment going out of band on FM reception, see how far it goes.

Oh my.. What is this D:

As I said with the Bluetooth section:

Read/write access to the WIFI_NVRAM ???!

Oh I most certainly must find out what

"MCR Read and read and write WiFi control register. warning The operation of non-professionals is forbidden"

I detect some.. chinglish or something :P

Well then..

Built in network utilities..

Idk what shell does, ping and ping ipv6 are obvious, DNS gives an error and.. HTTP RESPONSE is like curl ing a website to your local tty

Manually configure MTU on every one of your network devices

This was amaaaaazing.. Of course, the volumes were not as high as they could go, this I modified to be able to increase my headphones and open-air ringer volumes :D

This is where it got creepy..

Full hardware level, silent raw voip speech data logging

Full hardware level audio stream dumping to sd card D:

CPU Stress Test doesn't work.

I decided not to see what would happen if I pushed the button to disable the LCD control module..

WAAAAIT WHAT? GIPO???

Really now.. that's interesting, I wonder if it can be used.

Ohh gps stress testing, full NMEA logging to SD...

Here you can edit where the AGPS data comes from

I'm curious what the "hot cold warm full" buttons do..

Interesting that they're in a location settings page "you're getting colder, you have no idea what this is for lmao ;)"

JAM scan. What is this!?!

Ohh boy more logging....

Changing this didn't seem to do much right away, however I wonder if the engineer debug mode has something more to explore.

At least this log (the only one) shows a notification that the logging system is enabled.

Tcpdump to sdcard... is this ever a security issue xD

You know what, I bet this could be used to turn the cellphone into a wifi scanner, one that actually logs all the data over the air instead of just the bssid/essids, combine it with that wifi rx test mode and turn on the tdpdump, definitely going to have to try this out more.

Thermal is only enabled on the engineering OS build apparently..

This is one of the logs that the system logger can make.

Well then.. 154 pages of engineering menu, that's insane, awesome... fun hehehehe :)

This is what happens to the Internet when a fibre transit cable gets cut.

2014-04-01T00:30:00.004-04:00

I came home from work today and sat down to check my Facebook messages and immediately noticed something strange. The shapes and formatting of the page would load but none of the images or text were loading.

Grrrrr... Facebook's refusing to load..
— igmrlm (@igmrlm) March 31, 2014

At first I thought my WiFi card might be having issues with the access point since it's an old Dlink so I opened a ping to Google to see what was going going on. I then thought perhaps someone was running a torrent because the pings were in the hundreds peaking over 300-400, but then it would drop down to 59 again for a few seconds then loose a few packets and jump to 200 again. This is not what happens when someone's saturating the connection with a torrent or two, in that case the ping would have stayed more consistently high.

My next thought was to check the ping times between all the tier one ISPs on
http://www.internethealthreport.com/ This site shows a breakdown of the ping times between the largest fibre optic cable providers, these being tens or hundreds of gigabits. At this point the majority of evening traffic in North America was just starting as I live in EST and work a normal 9-5 schedule. What I saw showed that definitely something was wrong and it wasn’t my computer or my ISP.

@Level3 seems to be having issues.. I wonder if that's what's wrong with my #ping to #google and #facebook pic.twitter.com/mAY5t7pJ6c
— igmrlm (@igmrlm) March 31, 2014

Packet loss... @Level3 pic.twitter.com/QdSHM0HKB5
— igmrlm (@igmrlm) March 31, 2014

Then Netflix went down and there wasn’t much else to do than to figure out what was going wrong. I also decided to pick my own hashtag so I could group all my tweets in the future more easily.

Now #netflix is down too.. yay xd #northamericanfiberopticproblems pic.twitter.com/CsPIye6sBk
— igmrlm (@igmrlm) March 31, 2014

Right away you can see that the latency is starting to yellow-line and the packet loss has significantly red-lined. This usually means something has crashed or broken, or a cable has been cut, or it even could be a symptom of a DDOS attack, but how do you figure this out for sure when you don’t work for any of those companies?

Before long, to my surprise, Netfix customer service tweeted back with a troubleshooting guide. (Yea I’m a bit new to twitter.. leave me alone.) Now I felt obligated to tell Netflix that it wasn’t their fault since they were so nice to try to help and that it was just an IP transit issue or something.

@Netflixhelps its not your fault, level 3 in Toronto is loosing a lot of packets and timing out partially #northamericanfiberopticproblems
— igmrlm (@igmrlm) March 31, 2014

I went back to check the ping times and saw that another network had started dropping packets from Level 3.

@Level3 Wow it actually got worse #savvis #level3 #cogent #sprint #sbc #verizon #xo pic.twitter.com/idOgjpR7j3
— igmrlm (@igmrlm) March 31, 2014

I started searching for tools that had error reports for Canada to see if it was localized and found one, http://canadianoutages.com/ that showed a spike across every big Internet name I knew of and more such as Facebook, YouTube, PSN, Google, XBox Live, and more. At the time of this writing one can still see the spike in outages and issues across the board on that site.

@Netflixhelps @TekSavvyCSR @RingCentral pic.twitter.com/uJ1G3M5xI0
— igmrlm (@igmrlm) April 1, 2014

I wanted to make a call to tell my boss we might be having issues tomorrow, but when I tried to load my app on my phone it was unable to sync with the network. I tried calling myself with a landline and it rang through but might not have been working, I decided to use the landline instead.

I thought perhaps Bell Canada's Internet Tech department might be able to tell me if they had been notified of any fibre cuts or lines going down or something but I got the usual "if you can't give me an account or anything I'm not allowed to tell you anything" which in this case I guess is good business practice but annoying nonetheless. I tried calling Teksavvy after not finding much on their website (had not been posted yet) but then hung up on hold when I realized they must be swamped with calls from actual customers and probably were too busy and I shouldn't bother them. I decided decided I'd try more twittering..

It looks like @RingCentral might be down too #northamericanfiberopticproblems
— igmrlm (@igmrlm) March 31, 2014

I washed a few dishes then went back with my twitter i noticed Ringcentral had replied and I let them know also that it was something wrong with a main peering hub.

@igmrlm if the problem happens again please let us know and we'll be sure to look into it
— RingCentral (@RingCentral) March 31, 2014

@RingCentral heads up if you get any support calls, level 3 is loosing packets to nearly all their peering hubs
— igmrlm (@igmrlm) March 31, 2014

This includes #netflix #bell #rogers #teksavvy #cogeco #yahoo #psn #shaw #xboxlivedown and many others #northamericanfiberopticproblems
— igmrlm (@igmrlm) March 31, 2014

See http://t.co/YWWK3w7sb6 http://t.co/mg1ao4PqFK who knows how long it will last, probably only a few hrs #northamericanfiberopticproblems
— igmrlm (@igmrlm) March 31, 2014

Techsavvy must have noticed the hashtag usage somehow and replied.

@igmrlm I'd be glad to look in to that for you! Please follow and DM with your account info so I can better assist. JD
— TekSavvy Assistance (@TekSavvyCSR) March 31, 2014

I sent them a message and they referred to me to a forum thread they had just started as a staging ground for information as it developed. At this point it looked more like a fibre cut than anything else

http://www.dslreports.com/forum/r29144871-Slow-Service
At the time of the message there was one reply, at the time of writing there were 13 pages.

It wasn't much longer after this that the CEO of Teksavvy posted on the thread and confirmed that it indeed was a fiber cable cut, from Hurricane Electric effecting 100 gigabits of fibre, effectively half their upstream network and that of every other ISP in Ontario and Quebec and beyond to congest the whole north american grid.

Marc, the CEO, then posted a link to the details of exactly what happened:

Task Type	Incident
Category	Beauharnois
Status	In progress
Percent Complete

DetailsWe have a fiber cut between Newark < > Beauharnois.

We contacted LEVEL3.

http://status.ovh.net/?do=details&id=6629
http://status.ovh.net/?do=details&id=6632
And that's one of my favourite ways to spend the evening. I talked to a dozen different people in half a dozen different countries and have some new tools to use in the future. Was great fun :D

**update

Tuesday, 01 April 2014, 09:43AM

The cut in the fibre is at the New York exit towards Albanie
and it's affecting multiple providers and services
- Level3 NWK / BHS (10x10G)
- Level3 NWK / MTL (2x10G)
- Hibernia NWK / MTL (2x10G)
- Telia NWK / CHI (6x10G)
- Telia NWK / PAL (2x10G)
- Level3 Paris / New York / BHS (4x10G)

Tuesday, 01 April 2014, 09:51AM

The provider has reported that the fault has been located, and was determined to have been caused by road construction. It appears that the 120-count fiber was damaged by a new post being installed during the repairs to a highway guardrail. Splice crews remain en route to the area; an estimated arrival time has not yet been provided.

*note
I am a self taught enthusiast in this subject, I know only as much about oc-192 and 40gige as I have read on my own. I do hold Comptia A+ and work in the IT industry but I'm not a professional expert on fibre transit lines by any means. Please feel free to submit positive criticism, I'm always searching to learn more.

Blog visitor analysis and new Universal analytics from Google.

2014-02-03T07:39:00.000-05:00

I was going through my analytic stats from this blog and thought it might be interesting and fun to make some pie charts of the 30,735 visitors I've had since signing up for analytics. Yea, I know I'm a bit weird, deal with it ;)

First I graphed the Operating system visitors used:

Next was web browser:

Then resolution:

Colour depth:

And finally flash player version:

After this I planned to check out demographics but then I discovered the new Universal Analytics system and Google Tag Manager (still not really sure what that one's for) and spent the next few hours setting them up. Everything seems to work OK so far except for the fact that I cannot upgrade my classic analytics (yet?) so I have not been able to import old data.

At least this gives a good demo of Google docs/drive pie chart generation.