Skip to content

Instantly share code, notes, and snippets.

@jglim

jglim/Program.cs Secret

Created Oct 2, 2020
Embed
What would you like to do?
ChapterID
using SoundFingerprinting;
using SoundFingerprinting.Audio;
using SoundFingerprinting.Builder;
using SoundFingerprinting.Configuration;
using SoundFingerprinting.Data;
using SoundFingerprinting.InMemory;
using SoundFingerprinting.Query;
using System;
using System.Threading.Tasks;
using System.Diagnostics;
using System.IO;
using System.Collections.Generic;
using System.Text;
namespace ChapterID
{
class Program
{
// This whole project works because of https://github.com/AddictedCS/soundfingerprinting (add this nuget dependency first!)
// VLC tip: seek chapters using shift+P (previous) , shift+N (next)
// ffmpeg: https://ffmpeg.org/download.html
public const string FfmpegPath = @"C:\ffmpeg_path\ffmpeg\bin\ffmpeg.exe";
// MKV tooling : https://www.fosshub.com/MKVToolNix.html
public const string MkvToolPath = @"C:\mkvtoolnix_path\mkvtoolnix\mkvmerge.exe";
// Folder containing input AVI files to be "chapterized"
public const string VideoFolder = @"C:\input_files\Charmed\";
// Intro audio track to listen out for
public const string IntroAudioTrack = "intro.wav";
public const string TimestampCsvName = @"timestamps.csv";
public const string CsvCellDelimiter = ";";
public const string CsvRowDelimiter = "\n";
// The input filename must contain this string to be processed (for filtering by episodes).
// Change this string to the file extension to disable filtering
public const string FilenameFilter = "S01E";
// How long is the intro, so that we can skip past this amount of time in seconds
public const int IntroductionPeriodToSkipSeconds = 52;
public static Dictionary<string, double> FingerprintedIntroTimestamps = new Dictionary<string, double>();
private static readonly IModelService modelService = new InMemoryModelService(); // store fingerprints in RAM
private static readonly IAudioService audioService = new SoundFingerprintingAudioService(); // default audio library
enum RunMode
{
FingerprintIntroTimestamps,
AssembleMkvWithChapters,
RunAll
}
static async Task Main(string[] args)
{
Console.WriteLine("Starting ChapterID");
// The different stages are segmented for easier development, since it is undesirable to repeat earlier stages (e.g. fingerprinting) if a later stage (mkv generation) fails
RunMode runMode = RunMode.AssembleMkvWithChapters;
if (runMode == RunMode.FingerprintIntroTimestamps)
{
// Run fingerprinting and generate csv ONLY
await RunFingerprintForAllVideos();
}
else if (runMode == RunMode.AssembleMkvWithChapters)
{
// Assemble mkv files from csv snapshot ONLY
AddMkvChapters();
}
else if (runMode == RunMode.AssembleMkvWithChapters)
{
// Fingerprint AND build mkv files
await RunFingerprintForAllVideos();
AddMkvChapters();
}
else
{
Console.WriteLine("No action specified");
}
Console.WriteLine("Done");
Console.ReadLine();
}
// Loads a previously stored set of timestamps from csv
public static void LoadTimestampRecords()
{
string[] csv = File.ReadAllText(TimestampCsvName).Trim().Split(CsvRowDelimiter);
FingerprintedIntroTimestamps.Clear();
foreach (string row in csv)
{
string[] cells = row.Split(CsvCellDelimiter);
FingerprintedIntroTimestamps.Add(cells[0], double.Parse(cells[1]));
}
}
// Loads file:timestamp records from csv, then creates "chapterized" mkvs
public static void AddMkvChapters()
{
LoadTimestampRecords();
foreach (KeyValuePair<string, double> row in FingerprintedIntroTimestamps)
{
Console.WriteLine($"{row.Value} @ {row.Key}");
// Convert the mkv, create the chapter data, then splice them together
string mkvPath = RunFfmpegConvertMkv(VideoFolder + row.Key);
string chapterPath = CreateChapterFile(row.Value);
string newMkvPath = RunMkvSpliceChapter(mkvPath, chapterPath);
// Cleanup: delete temporary mkv and chapter data
File.Delete(chapterPath);
File.Delete(mkvPath);
Console.WriteLine($"Fixed {newMkvPath}");
}
}
// Generates a chapter file containing 3 segments describing the intro's period, to be added into a mkv file
public static string CreateChapterFile(double startTimestamp)
{
string chapterFilePath = $"{GetStartupPath()}{Path.DirectorySeparatorChar}{Guid.NewGuid()}.txt";
TimeSpan startTs = TimeSpan.FromSeconds(startTimestamp);
TimeSpan endTs = TimeSpan.FromSeconds(startTimestamp + IntroductionPeriodToSkipSeconds);
string chapterNewline = "\n";
string chapterTemplate =
$"CHAPTER01=00:00:00.000{chapterNewline}CHAPTER01NAME=Opening{chapterNewline}" +
$"CHAPTER02=00:{startTs.Minutes:D2}:{startTs.Seconds:D2}.000{chapterNewline}CHAPTER02NAME=Introduction{chapterNewline}" +
$"CHAPTER03=00:{endTs.Minutes:D2}:{endTs.Seconds:D2}.300{chapterNewline}CHAPTER03NAME=Content";
File.WriteAllText(chapterFilePath, chapterTemplate);
return chapterFilePath;
}
// Given a directory of avi files, fingerprint for the intro track and store its results in FingerprintedIntroTimestamps
public static async Task RunFingerprintForAllVideos()
{
Console.WriteLine("Loaded intro chunk");
await StoreForLaterRetrieval(IntroAudioTrack);
// string targetFile = Directory.GetFiles(VideoFolder)[0]; // single-shot for debug
foreach (string targetFile in Directory.GetFiles(VideoFolder))
{
// constrain by format AND episode (since the signature might change)
if (Path.GetExtension(targetFile).ToLower() == ".avi" && targetFile.Contains(FilenameFilter))
{
await RunFingerprint(targetFile);
}
else
{
Console.WriteLine($"Skipping invalid file : {Path.GetFileName(targetFile)}");
}
}
SaveFingerprintResults();
}
// Writes results from FingerprintedIntroTimestamps into a csv file, and also prints FingerprintedIntroTimestamps contents
public static void SaveFingerprintResults()
{
StringBuilder csv = new StringBuilder();
Console.WriteLine("=================================\nResults\n=================================\n");
foreach (KeyValuePair<string, double> row in FingerprintedIntroTimestamps)
{
double roundedSecond = Math.Round(row.Value, 0);
Console.WriteLine($"{roundedSecond} @ {row.Key}");
csv.Append($"{row.Key}{CsvCellDelimiter}{roundedSecond}{CsvRowDelimiter}");
}
File.WriteAllText(TimestampCsvName, csv.ToString());
}
// Given an AVI file, find the timestamp of the intro, and store the results in FingerprintedIntroTimestamps
public static async Task RunFingerprint(string targetFile)
{
// extract the audio from the avi file
string extractedAudioTrack = RunFfmpegExtractWav(targetFile);
// fingerprint for intro track, results stored in FingerprintedIntroTimestamps
await RunFingerprintAsync(extractedAudioTrack, targetFile);
// clean up the temporary wave file
File.Delete(extractedAudioTrack);
}
// Gets the folder where the binary is executed in
public static string GetStartupPath()
{
return Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar;
}
// Extracts a .wav file from an AVI container
public static string RunFfmpegExtractWav(string aviPath)
{
string temporaryId = Guid.NewGuid().ToString();
string wavPath = $"{GetStartupPath()}{Path.DirectorySeparatorChar}{temporaryId}.wav";
// this specific command extracts ONLY the first 15 minutes of wave audio from the input AVI file.
string ffmpegArgs = $"-i \"{aviPath}\" -ss 00:00:00 -t 00:15:00.0 -vn -acodec pcm_s16le -ar 44100 -ac 1 \"{wavPath}\"";
Console.WriteLine($"Running ffmpeg\r\n input {aviPath}\r\n output at {wavPath}");
// Run ffmpeg, and wait for it to complete
Process.Start(new ProcessStartInfo(FfmpegPath, ffmpegArgs)).WaitForExit();
Console.WriteLine($"Wave extraction complete");
return wavPath;
}
// Converts the video *container* from AVI to MKV, as AVI does not seem to readily accept chapter data
public static string RunFfmpegConvertMkv(string aviPath)
{
// this ffmpeg command does not re-encode the video, preventing quality degradation
string mkvPath = $"{GetStartupPath()}{Path.DirectorySeparatorChar}{Path.GetFileNameWithoutExtension(aviPath)}.mkv";
string ffmpegArgs = $"-fflags +genpts -i \"{aviPath}\" -c:v copy -c:a copy \"{mkvPath}\"";
// Run ffmpeg, and wait for it to complete
Process.Start(new ProcessStartInfo(FfmpegPath, ffmpegArgs)).WaitForExit();
return mkvPath;
}
// Runs mkvmerge to splice a mkv file with a chapter file, and output a new mkv file
public static string RunMkvSpliceChapter(string mkvPath, string chapterPath)
{
string outputMkvPath = $"{GetStartupPath()}{Path.DirectorySeparatorChar}{Path.GetFileNameWithoutExtension(mkvPath)}_processed.mkv";
string mkvArgs = $" --chapters \"{chapterPath}\" -o \"{outputMkvPath}\" \"{mkvPath}\"";
// Run mkvmerge, and wait for it to complete
Process.Start(new ProcessStartInfo(MkvToolPath, mkvArgs)).WaitForExit();
return outputMkvPath;
}
// Checks a audio track for the presence and location of an intro track, then add it to the global results dictionary
// Modified from the SoundFingerprinting example
public static async Task RunFingerprintAsync(string pathToAudioFile, string originalAviPath)
{
QueryResult queryResult = await QueryCommandBuilder.Instance
.BuildQueryCommand()
.From(pathToAudioFile)
.UsingServices(modelService, audioService)
.Query();
string identifier = Path.GetFileName(originalAviPath);
if (queryResult.BestMatch is null)
{
Console.WriteLine("No matches");
FingerprintedIntroTimestamps.Add(identifier, -1);
}
else
{
double matchedTime = queryResult.BestMatch.QueryMatchStartsAt;
double matchedConfidence = queryResult.BestMatch.Confidence;
if (matchedConfidence < 0.3)
{
Console.WriteLine("Rejected low-confidence result");
FingerprintedIntroTimestamps.Add(identifier, -1);
}
else
{
Console.WriteLine($"Fingerprint query: confidence {matchedConfidence}, at {matchedTime}");
FingerprintedIntroTimestamps.Add(identifier, matchedTime);
}
}
}
// Adds a audio track to be recognized, in this case, the video's introduction track
// Mostly copied from the SoundFingerprinting example
public static async Task StoreForLaterRetrieval(string pathToAudioFile)
{
// Anything here is fine since we only want to know *when* the track is playing
var track = new TrackInfo("INTRO_ID", "INTRO_TITLE", "INTRO_ARTIST");
// Create fingerprint from the wav file
var hashedFingerprints = await FingerprintCommandBuilder.Instance
.BuildFingerprintCommand()
.From(pathToAudioFile)
.UsingServices(audioService)
.Hash();
// Store hashes in the database for later retrieval
modelService.Insert(track, hashedFingerprints);
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.