BBritten.com - softwares:niente

logicalcorruption

Anonymous (anonymous@undisclosed.example.com) — 2025-11-05T20:30:13+00:00

Logical Inconsistencies

1.0 Introduction

Niente's check of logical inconsistencies within your FLAC music collection is a very subjective affair (as opposed to its detecting physical corruption, which is entirely objective). By this, I mean that in order to declare that something is inconsistent with something else, you have to have agreement about what “consistency” would look like: and for that, you need a set of agreed 'rules' about what makes for consistent data.

On this website, the 'agreed rules' are my Axioms of Classical Tagging, which I would urge you to read carefully if you haven't done so before now. Those axioms state that we should tag our FLACs with certain sorts of data in certain places; and that we should therefore expect to be able to compare what we find in place A with what is stored in place B, and so on. Niente uses this understanding of what to expect in order to detect when specific FLACs are tagged in unexpected ways.

It is quite possible that you do not agree with everything asserted in that article about tagging axioms. That's fine, but if you tag your FLAC files differently from what that article says should be done, then Niente isn't going to be of much use to you as a tool for detecting logical inconsistencies!

Let us, therefore, state here what Niente's 'rules' or expectations actually are. I will only summarise the key tenets of the Axioms article: as I say, you're encouraged to go read the entire thing to put everything in proper and complete context.

2.0 Niente's Expectations

Perhaps inevitably, we begin at Axiom 1, which states that the following tags are quasi-compulsory: COMPOSER, ARTIST, PERFORMER, ALBUM, GENRE, COMMENT, TRACKNUMBER, TITLE. Niente's simplest test for logical inconsistencies in your tagging strategy is therefore to check that all of these tags are, in fact, present in every single FLAC file it knows about. If it finds any missing, the Reporting → General Reports Menu Option 4 Missing tags will detail in which files the problems arise.

Next, Axiom 2 says that the contents of the ARTIST tag should match the contents of the COMPOSER tag, precisely. Niente will detect whenever this is not true. A classic case from my own music library: I tagged “Arrthur Honegger” as the ARTIST and “Arthur Honnegger” as the COMPOSER. The one extra 'n' in the COMPOSER tag's surname is sufficient to break Axiom 2 and Niente's Reporting → Logical Issues Reports Menu Option 5 Inconsistent ARTIST/COMPOSER tags will (and did!) tell me this.

Meanwhile, Axiom 3 says that the complete set of performing artist details go into the COMMENTS tag. That is, if the album is called “Symphony No. 5 (Karajan - 1970)”, we'd expect the COMMENTS tag to read something like 'Herbert von Karajan, Berlin Philharmonic Orchestra'. This, somewhat unfortunately, means that there's now a relationship between the COMMENTS and PERFORMER tags, arising from the operation of Axiom 6: if COMMENTS mentions 'Herbert von Karajan' somewhere in its long-form contents, the PERFORMER tag should do so too. Niente's Reporting → Logical Issues Reports Menu Option 3 Inconsistent PERFORMER/COMMENT tags will details any files for which this isn't true.

We'll skip over Axiom 4, which states that the GENRE tag should be short, sweet and highly functional. That's a qualitative judgement which Niente is not able to make! As mentioned above for Axiom 1, Niente can report on files that are entirely missing a GENRE tag, but if the tag is full of complete horse radish, Niente will not see that as a problem!

Moving on, therefore, to Axiom 5: this states that the ALBUM tag should be filled with an 'extended composition name', in the form of “actual composition name (distinguishing artist surname - recording year)”. That is, you'd end up with something like “Symphony No. 5 (Karajan - 1970)”. This is fine from the logical standpoint (see my article on The Primary Keys to Music for an explanation of why the extended composition name is logically required if we are to distinguish any recording fully from any other), but it sets up two new relationships which can go wrong if you are not ruthlessly consistent in your tagging: clearly the ALBUM tag now mentions the word 'Karajan', which we already know will appear somewhere in the COMMENTS and PERFORMER tags; additionally, the YEAR (or DATE) tag is also now mentioned in both the ALBUM and YEAR (or DATE) tags -so those need to be consistent, too. Accordingly, the Reporting → Logical Issues Reports Menu Option 1 Inconsistent PERFORMER/COMMENT tags option will check the YEAR/DATE tag and the ALBUM tag and make sure they mention a four-digit year correctly in both places. Similarly, the Reporting → Logical Issues Reports Menu Option 4 Inconsistent PERFORMER/ALBUM tags option will compare the ALBUM and PERFORMER tags: if ALBUM mentions “Karajan”, it will be regarded as an inconsistency if the PERFORMER tag doesn't also mention the word “Karajan” somewhere. It's OK if PERFORMER is set to “Herbert von Karajan” and ALBUM mentions “Karajan”. That's OK: Niente doesn't expect the distinguishing artist's complete name to appear in the ALBUM tag, after all. So long as the abbreviated ALBUM distinguishing artist name appears anywhere in the PERFORMER tag, that's OK.

Note that Niente will not perform the logical third step: if ALBUM is related to PERFORMER, and PERFORMER is related to COMMENTS, then technically the distinguishing artist name in ALBUM should relate to something in the COMMENTS tag as well as in the PERFORMER tag. This is true, but Niente won't check it directly. As far as it's concerned, it's warned you about ALBUM/PERFORMER issues (see above for Axiom 3) and PERFORMER/COMMENTS ones (see above for Axiom 5), and thus feels sufficient checks have been performed. Eliminate those two categories of logical inconsistency and the ALBUM → COMMENTS issue resolves itself, basically.

Axiom 8 doesn't really require anything specific of any particular tag, so we can skip on over that one and move on to Axiom 9, which states that every unique recording should start with a track number 1 (or '01': it makes no difference). The Reporting → Logical Issues Reports Menu Option 2 Inconsistent TRACK NUMBER tags report will list any recordings for which this isn't true. If you rip the second symphony off that 2-symphony Beethoven CD, for example, and thus acquire tracks numbered 5, 6, 7 and 8… Niente will list that as a problem on this report.

Axioms 10 to 15 are, again, qualitative in nature, so Niente cannot check for how grammatically you tag, or whether you use all the names a composer was given at birth, for example! We can, however, jump to Axiom 16, which states that album artwork should (a) be of good quality and size and (b) be embedded within the FLAC file, not merely left as an 'associated file' on disk (such as folder.jpg, which is commonly done on Windows PCs). Niente's Reporting → Other Reports Menu Option 1 Recordings with album art issues report will list all FLACs for which these two rules don't apply. If there's no embedded artwork at all, or if it's ridiculously too small or too large, Niente will report the fact here. Additionally, though it's not mentioned anywhere in the Axioms article, Niente rather prefers square album art to non-square: so it will regard any embedded artwork that doesn't have matching width and height dimensions as a bit of a problem, too.

Moving away from the specific Axioms mentioned in my earlier article, : you can ask Niente to check the peak volume levels of all your recordings. If you then run Reporting → Other Reports Menu Option 2 Recordings with possible volume boosts, Niente will use the persistent configuration file setting for 'Volume threshold' and review which recordings are quieter at their maximum than that.

Next, and also not related to the Axioms: if you use my Semplice program to tag your FLAC files, you may choose to take advantage of its configuration option to 'force filenames to display bitdepth/sample rate'. That means that if a file starts off being called '01-Allegro.flac', Semplice will adjust its physical file name to be something like '01-Allegro-16-44100.flac': the sample bit depth (16 bits) and the sample rate (44.1kHz) are thus 'baked into' the physical file name. Doing this makes for a handy way of distinguishing between ordinary CD and higher resolution SACD rips when using nothing more than your operating system's file manager to browse your music collection. Niente accordingly provides Reporting → Other Reports Menu Option 3 Files missing sample rates in names to identify any files which do not include these bit-rate and sample-depth indicators in their physical file names.

Lastly, Semplice also allows you to 'concatenate' files making up a single recording into a single physical FLAC file, which is thereafter referred to as a 'SuperFLAC'. See the Semplice User Manual on the subject for details. Niente's Reporting → Other Reports Menu Option 4 Albums with multiple physical files will report on any recording which is still comprised of per-track FLACs, rather than a single SuperFLAC. Thus, if your 'Symphony No. 5' folder contains 4 separate tracks, one per movement, then that counts as 'multiple physical tracks per recording'; whereas if there's a single SuperFLAC that contains within itself the four separate movements, that would not be reported as an issue. Use of SuperFLACs is entirely optional, so unless you commit to doing it, you don't have to worry about the existence of the Option 12 report.

Summing all this up, therefore, we can say that Niente detects and reports on:

Missing COMPOSER, ARTIST, PERFORMER, ALBUM, GENRE, COMMENT, TRACKNUMBER and TITLE tags
DATE tags which don't match the date included in the ALBUM tag
TRACKNUMBER tags which don't start with '1' (or '01') for each new recording
PERFORMER tags which don't match the contents of the COMMENTS tag
PERFORMER tags which don't match the 'distinguishing artist' name included in the ALBUM tag
COMPOSER tags which don't match the ARTIST tag
Embedded ALBUM ART which is (a) non-square; (b) too small; © too large; or (d) non-existent
Recordings whose absolute peak loudness level permits of a volume boost of at least +1dB
Files whose names do not include sample rate and bit-depth identifiers
Recordings comprised of more than a single FLAC (i.e., per-track recordings, rather than SuperFLACs)

In this way, Niente applies most of the Axioms of Classical Tagging in a highly practical way. Naturally, if you don't tag your music precisely the way the Axioms suggest you should do, then some -or even many- of the Niente reports I've mentioned will be of no use to you. If you don't think the composer's name should go into the ARTIST tag, for example, then Niente's insistence on reporting on files where ARTIST doesn't equal COMPOSER is going to be of no use to you. Well: Niente can't change the way it was written, but you can of course ignore that particular report whilst continuing to make productive use of the other ones it can produce for you. Your tagging choices thus remain yours, though Niente's usefulness will vary depending on what choices you make.

3.0 When does Niente check for Logical Inconsistencies?

Niente only actually reports on all the various forms of logical inconsistency described above when you run the various reports to detail them, using the many options found in the Reporting menu.

Every one of those reporting options, however, depend on using the contents of the Niente database, and those are only created or updated as follows:

New recordings are only ever added to the database by taking the Database Menu Options 2 or 3 (“Wipe & re-load a database from scratch” or “Add/Remove music files incrementally”). The difference between the two options is that Option 2 wipes the database and re-populates from scratch it by having a fresh scan of your hard disk. Meanwhile, Option 3 leaves existing recordings where they are and only adds new< or modified files into the database.

In either case, the Database menu options only end up saying 'These files exist': it does not trigger <em>any</em> analysis of the nature or metadata tags associated with those files.

Those files known to exist are inspected and analysed by taking the Integrity Checks Menu, Options 1, 2 or 3 (“Perform a full integrity check”, “Perform a differential integrity check” or “Perform a fast integrity check”).

The difference between these three options is simply this:

Full Check = Wipe all existing records of physical and logical data about the FLACs listed in the database and re-compute them from scratch by re-reading every single FLAC (could be slow on a large collection of music files)

Differential Check = Re-visit every music file which is known from previous checks to contain physical or logical inconsistencies or which has never previously been checked and re-compute its physical and logical characteristics from scratch (relatively fast as only 'files known to be in error' are re-visited)

Fast Check = Re-visit every music file which is known from previous checks to contain only logical inconsistencies or which has never previously been checked and re-compute its logical characteristics from scratch (much faster, as not only are a sub-set of 'files known to be in error' are re-visited, but time is not spent re-computing and re-comparing their physical characteristics: i.e., no hash-computation of the audio signal from within the files are performed)

In all cases, an integrity check only ever inspects music files which are listed in the database. If you've added a new recording to your collection, for example, you'll first need to do an 'Add/Remove files in a database' operation to get the new recording into the database at all; and then you'd do a Differential or Fast integrity check.

Be aware that the full, differential or fast integrity checks do not check volume or album art matters. If you want to report on those as potential problems you'll first need to take one of the Integrity Checks menu, Options 4, 5 or 6 or 7(“Check album art for all files”, “Check album art for new files”, “Check all files for volume boosts” and “Check new files for volume boosts”) as a separate option. Album art checks always re-scan the entire collection of music files known to exist because it is relatively fast. Volume boost scans, however, can take a long time to complete if every file is re-visited (Option 5), so Option 6 is provided to allow for volume scans to take place for files that have not previously had their volume levels checked. In every case, the art or volume checks can only analyse files that are mentioned in the database, so if you add a new recording to your collection, you'll have to (1) Add/remove files in a database first; and then (2) run the art or volume checks. Only then can the reports on possible art or volume problems pick up on the new data.

| Back to Software Home | Back to Niente Documentation Home |

nenchange

Anonymous (anonymous@undisclosed.example.com) — 2026-03-28T20:36:54+00:00

Changelog

This page describes the changes made in each point release of Niente since its first release as version 4.00 on September 10th, 2024.

Versions with dates attached have been released into the wild and made generally available: if an entry says 'proposed for release', it's a best-guess as to when a release will happen, but it's not guaranteed to actually happen on that date. It could slip a few weeks, or even happen earlier than scheduled, depending on circumstances.

Niente Version 4.05 - March 28th, 2026

Bug Fix: Integrity checks were mis-handling the storing of ReplayGain information. The version invoked with command-line switches (e.g., niente --check-differential) were simply unaware of the need to collect ReplayGain data at all; the version invoked with interactive menu options only collected ReplayGain data under certain circumstances. The code now collects ReplayGain data correctly in all appropriate circumstances, regardless of the method by which the code is invoked.

Enhancement: Menus have had spaces removed from them, since they suggested meaning or significant grouping of options that was not really intended. The program logo is now used to display on the right-hand side, in a similar manner to both Semplice and Giocoso. Where once you had this:

…now you'll have this:

The lettered options are still distinct from the others (as they perform one-off type program alterations, rather than data processing functions), but otherwise all menu options appear now undifferentiated. The right-hand panel is now entirely given over to displaying the program logo, rather pointlessly: that entire half of the display may disappear in a future release but has been left there for now, in case it might become useful in future.

Enhancement: Niente is now “colour aware”: a new menu item in the Administration menu allows you to alter the colours assigned to each display element of the Niente program interface (such as the box- or line-drawing characters, the logo text, the menu option text and so on). In this respect, the program acquires the same colour management facilities that Semplice and Giocoso possess. The new menu option is on the Administration menu, Option 6: Change the program colour scheme:

The various program 'drawing elements' are listed with a colour number assigned to each. The defaults can be restored by tabbing round to highlight the [Reset to Defaults] button. Any of the 16 colours can be assigned to any option, allowing this sort of thing:

Exactly the same colour number assignment can also produce this result, however:

…which is significantly less usable! The specific colours assigned, in other words, will render differently depending on your terminal's choice of colour profile, so some experimentation will be needed to avoid usability horrors!

Niente Version 4.04 - February 28th, 2026

This is a significant release for Niente. The key areas to focus on are:

Running on macOS (now a Tier 1 supported platform)
Running on Almalinux 9 and 10 (similarly, both are now Tier 1 supported platforms)
Visually more appealing screens when performing long-running operations
All reporting now done by output to HTML documents, viewable in a separate browser
Making it ReplayGain aware

Some specifics:

Major Enhancement: Niente has been significantly re-written and re-factored to ensure it runs on macOS (tested on Tahoe on Apple Silicon and Monterey on Intel) and on both Almalinux 9 and 10.

Visual Appearance: When performing long-running operations, such as performing an integrity check, a volume boost scan or a check of album art, Niente will now display progress with screens such as this:

Compare that to how it looked in the previous version:

Many such screens now have a graphical progress bar and an “ETA”: an estimate (in Microsoft fashion, typically wildly wrong at the start of whatever process is being performed!) of when the operation is likely to take to complete.

Significant Enhancement: All Niente's reports are now produced as (hopefully!) professional-looking, responsive HTML documents in a web browser (from where they can be printed or exported to text files):

Every report has been overhauled to make the SQL more robust logically and additional items in the Other Reports menu mean that items on the Aggregate Statistics report have been renumbered correspondingly.

Removed Feature: Since all Niente's reports are now produced via a web browser, there is no need to configure a “Default terminal font (for reports)” in the Administration menu, Option 1 : Edit Configuration File. That configuration item has therefore been removed and, if the parameter is supplied by manually editing the configuration file, it is simply ignored. The same is true of the 'Default font size (for reports)' parameter.

New Feature: A new configuration option to specify a Preferred browser has been created. This can be set to be the name of any web browser executable installed on your system (for example, 'firefox' or 'chromium'). This will then be the browser Niente tries to open its reports with. If you name something which doesn't exist, your system's default browser will be used as a fallback option. The same is true if you don't add a value to the new parameter at all. Leaving it blank is actually the default value, too: it's probably safer and more reliable to open reports with the system's default browser than to attempt to name a browser executable that might be wrong or may not behave well in conjunction with Niente.

Enhancement/New Feature: When performing an incremental search for new music files (Database menu, Option 3), a new check is performed to ensure that the folder being scanned for new files isn't, in fact, substantially empty. If the selected music folder contains less than 80% of the records already in the database, that suggests something odd might be happening with the music folder. Rather than just go ahead and scan (and thus bulk-delete apparently now non-existent music files from the database), a warning message will be displayed. If you select 'yes' to continue, fine: the scan will proceed. Any other response will abort the proposed incremental scan. For example, if your NAS mount failed to mount following a reboot and you hadn't noticed this before attempting an incremental scan, this might help prevent the accidental wiping of all your database records.

Enhancement: Niente is now “ReplayGain aware”. Whenever a new integrity check is performed, the program will search for the presence of the REPLAYGAIN_ALBUM_GAIN tag inside each FLAC being analysed. If found, it is written into Niente's TRACKS table. Collecting such data would be a bit pointless by itself, so to complement this new data, there's a new report: under Other Reports, a new option to produce a report on “Files missing ReplayGain data” has been created. Anything listed on that report might be a candidate for opening in Semplice and performing a metadata-only volume boost!

Bug Fix: Niente hasn't been updated since April 2025: it was thus unaware of the existence of bbritten.com and kept trying to phone home to absolutelybaching.com: updates wouldn't work as a consequence. This release itself actually suffers from that: a fresh installation is potentially the only way to obtain it in an automated fashion, as the menu option to update will look to the wrong server to work out if an update is available. Various other bits and pieces would fail for similar reasons: these have all now been fixed and the software points to this website's servers correctly once more.

Niente Version 4.03 - Released April 10th, 2025

Enhancement: whenever the program displays the database name, it truncates the name to just 10 characters. That's now been increased to 25. It's a purely cosmetic issue. On certain occasions, the name is still truncated to 10 characters for space constraint reasons. Whenever Niente needs to constrain the database name, it will now add an ellipsis to the name to indicate that display truncation has occurred (i.e., you'd see something like “My_long_da…” when it's working with a database called “My_long_database_name”).
Enhancement: a new column called TRACKTITLE is now populated in the TRACKS table whenever any sort of integrity check is performed, thereby storing each track's TITLE tag. This will allow advanced users to run SQL queries against the Niente database and discover logical integrity issues such as tempo markings being spelled incorrectly (Adajio, for example; or Vivahce). No provision for making such checks in-program is planned, however (though see new Option 4 on the Reporting menu, below). Note that the upgrade process merely creates the new column: it doesn't populate it. The new column will only get populated if you go on to do a new integrity check.
Bug fix: In previous Niente versions, if you try to create a database that already exists and, when warned about this, you press the option to 'Cancel', you end up with Niente running without being 'attached' to any database at all. You could always fix this by manually opting to 'Change Working Database' back to what you started with, but you shouldn't really lose the database you were working with just because you cancelled an operation! This is now fixed: you don'tnow lose contact with your original database when cancelling out from the creation of a new one. If you are working with database X, attempt to create database Y and then cancel that operation, you will return to the main menu 'attached to' and working with database X as before.
Enhancement: In line with the way Giocoso has worked for some time, if you press [Enter] on any of Niente's main menu options, the first listed menu option will be executed. In other words, sit on the Database menu and press [Enter] and it will be as if you pressed '1' to create a new database; sit on the Reports menu and press [Enter] and the General Reports sub-menu will be displayed (and another [Enter] after that will trigger the running of the 'Aggregate Statistics' report); and so on.
Enhancement: A new Option 4 on the Reporting menu allows you to type in complete SQL statements and thereby query any combination of columns in any of the tables contained within the currently-selected Niente database. It doesn't replace the functionality inherent in programs such as Sqlitebrowser, but it does mean a basic dynamic query functionality is now built-in to the main Niente program itself. Deletes and updates via this mechanism are not permitted, however. Report contents are displayed in a separate xterm window, in the same way that existing 'non-advanced' reports are.
Bug Fix: In previous Niente versions, the statistic for files capable of being volume-boosted would disappear off the aggregate statistics report, regardless of whether you'd configured the 'Report on volume boosts' to yes or no, every time you performed a new 'check for volume boosts' integrity check. Now fixed: the statistic is either there or not, correctly, as specified in the configuration file. Performing new integrity checks does not make the statistic disappear.
Minor Enhancement: The Administration menu, Option 2 was used to download a copy of the GPLv2 licence from this site. If this site was down for maintenance, that would lock up Niente for the duration! The new version now only downloads the licence once, if it's not already present on the system. It also now displays it within a quasi-graphical text viewer, rather than with the command line 'less' program.
Bug Fix: In rare circumstances, the file that tells Niente to use grep, sed and similar utilities was not populated correctly before attempting to use those utilities to parse text information extracted from FLAC file tags: garbled data resulted. Now fixed.
Bug Fix: A feature introduced in Version 4.01 could result in a blank database file being created on merely launching Niente. The existence of this non-database file would then prevent you from creating an actual database file of the same name. Now fixed.
Bug Fix: For unaccountable reasons, Niente forgot to install sqlite3 on Fedora; other distros were not affected. This meant that fresh installs on Fedora would “work” to let you create a database …and then promptly lose all trace of the database after it had been 'created' (because it hadn't actually been created at all, given the necessary software to do so was missing!), preventing all further use of it. Now fixed.

Niente Version 4.02 - Released October 12th 2024

This release implements a bunch of small bug fixes, mostly to do with how the 'non-interactive' Niente operations are performed. For example, if you run the command niente4.sh –check-differential, you'll trigger a non-interactive differential integrity check: non-interactive because the main program window is not displayed as the check is performed. It (and its cousins) are intended for scheduling program functions via crontab. Unfortunately, the necessary environment variables were not being set correctly when these options were invoked and thus not-so-minor things such as extracting the correct bitdepth and sample rates from FLACs were not being performed correctly. I also took the opportunity to add some 'progress dots' to the program output when in non-interactive mode: though you're not likely to see them when the program is run via cron at 3AM, the total lack of progress indication or output hitherto can be a bit unnerving when you're testing things! Now you'll see this sort of thing:

Niente Version 4.01 - Released October 8th 2024

For this first update since it's release, an enhancement has been made to the Niente database, such that it will now contain a column called SAMPLE_RATE in the TRACKS table. Existing databases will have the new column appended to the end of all the existing columns; freshly-created new databases will have the extra column embedded within the other columns. The adjustment to the table structure happens automatically the first time Niente is run after the software upgrade has been applied. Actual population of the new column with data only takes place once a new full, differential or fast integrity scan has been performed. (Note: a Niente database is not particularly significant, since it can be completely re-constructed by doing a fresh database creation, music scan and integrity check. This may take time, but it means the data in a Niente database is essentially fungible. Should you prefer, for example, you can simply delete your existing Niente database, create a fresh one and trigger fresh music scans and integrity checks to get the new column installed and populated 'properly'. It's a fundamental tenet of database normalisation theory, however, that the physical location of a column in a table is irrelevant for working with that table, so Niente won't care whether the new column is integrated within the table structure or appended to it).

SAMPLE_RATE is the counterpart to the BITDEPTH column, which has been there since Version 2 or thereabouts: for any given digital music file, Niente will record it as being '16' or '24' bit-depth as before, but will now also record whether the music has been sampled at 44,100Hz (standard CD Audio), 48,000Hz (enhanced standard CD), 88,200Hz (high resolution digital audio) or even 192,000Hz (bonkers resolution for those with more money than hearing discrimination). Of course, if any other sample rate is detected apart from these 'standard' ones, that will be stored too. This enhancement was suggested by a reader, Scott, to whom I'm grateful for the idea, though it now escapes me why I never considered capturing this data before: its utility is rather obvious, after all! For example, the first thing I was able to do (in sqlitebrowser) was to filter my rows like so:

Here, I'm filtering for recordings which have a 16-bit bitdepth (which you'd normally expect to be standard CD audio) but also have a 96KHz sampling rate (which you'd expect from SACD rips or online high-res sources). That particular combination is so bizarre that I can only conclude that some CD ripping and/or post-processing has 'gone awry' in some way. Not that this is easily fixed, but knowing about this at least means I now know that a re-rip of the relevant CDs is required. Thanks Scott …</joke>

The new data is displayed whenever a Niente database is undergoing an integrity check:

The new line 'Audio Data' displays both the bit-depth and sample rate determined by physical analysis of the digital music file's contents.

To complement this new data collection, a new 'Logical Problems' Report item has been created, displaying digital files for which the sample rates and bit depths don't appear to be sensible combinations.By “sensible”, Niente means: if bitdepth is 16, sample rate shouldn't be higher than 48KHz (48,000 Hz); from the opposite way of looking at things, too, if the bitdepth is 24, the sample rate shouldn't be lower than 48KHz.

The new report is accessed from the Logical Issues Reports, Option 6 “Inconsistent Bit Depth/Sample Rates”:

The resulting detailed report contains content such as this:

The Aggregate Statistics Report (General Reports, Option 1) has been adjusted to report on the row-count of this report:

The new line on the report is the 'L6' one. Bear in mind that it is at least conceivable that a 24-bit, 44.1KHz recording exists, so that a number on this line of the aggregate statistics report doesn't necessarily represent a real problem (though, personally, I would definitely re-rip to more standard bitdepth/sample rate combos). Niente is just hard-coded to apply the rule that “either 16 bits and sample rate greater than 48KHz; or 24 bits and sample rate less than 48KHz equals 'odd'”. I'm open to further enhancement requests if a finer-grained selection of bit depth/sample rate 'problems' is felt necessary :)

Finally, a cascading and corresponding change has been made to the 'O3' line on that aggregate statistics report and its equivalent Other Reports, Option 3 Files missing bitdepths in names detailed report. In the original Niente release, the program looked for the bitdepth number in the file name, and if it found it, said 'fine, you've included the bitdepth in the name correctly'. It never actually checked for the presence of the sample rate in the file name at all, though!

In other words, it assumed that if “24” or “16” was in the file name, you must have named things correctly and the sample rate was probably in there, too… but it never verified this. Of course, this meant that a 'Symphony No. 16.flac' would pass the test: if the file was a 16-bit FLAC, the presence of '16' in the file name anywhere would count as a pass (and yes, I knew this was a bit of a hack-job when I wrote it: I was in a hurry, I think!)

In light of the new collection of sample rate data for music files, therefore, the rules for this report have been tightened up. The new version of the report knows both the bitdepth and sample rate from the Niente database: it expects them to be concatenated with a hyphen when constructing physical file names (as Semplice, for example, would do for you automatically), so the report now looks for things that don't have text such as '16-44100' or a '24-88200' in their file names. A 'symphony no. 16.flac' would thus now fail the 'do you have bitdepth and sample rates in your filename' test, as it absolutely should, where previously it would have passed it. Even a file called 'Symphony No. 16. - 44100.flac' would fail, as the program expects 'xxxxx-16-44100.flac' as an absolute pattern, though other bitdepths and sample rates are acceptable, depending on circumstances!)

| Back to Software Home | Back to Niente Documentation Home |

nenconfig

Anonymous (anonymous@undisclosed.example.com) — 2026-03-24T13:48:25+00:00

The Persistent Configuration File

1.0 Introduction

Niente's behaviour is controlled by the various settings found in its persistent configuration file, which is a text file called $HOME/.local/share/niente4/txt/niente.conf. Since it is merely a text file, it can be edited directly in any text editor you happen to favour. However, it consists of a set of keyword=value parameters whose meaning and legal or default values may not be obvious to you, so whenever you want to alter its contents, it's much better and safer to use Niente's own specific menu option to do so: the Administration menu, Option 1 : Edit Configuration File. Taking that option will bring up a screen like this one:

…in which textual prompts are paired with data entry fields. The text prompts use natural language wherever possible and the values you assign to them are also in natural language (for example, the screen uses yes or no answers, rather than binary 1 or 0 values). All possible configuration parameters are displayed and are editable on this one screen. The specific consequence of setting or unsetting any of these parameters should be determined by reading the relevant section of the User Manual: for the meaning of 'Threshold (pixels) for small art', for example, you'd want to consult this page of the manual and, specifically, Section 4.1 since the parameter governs when Niente thinks a piece of embedded album art is too small for its own good!

Generally, the default values for most parameters should be acceptable and safe out-of-the-box (though the 'Default music folder' is liable to need customisation before you first run Niente). If you attempt to set a parameter to an illegal value (for example, setting the 'default default degree of paralellism' to the literal text 'as big as you can make it'), the default value (of 2) will be applied instead: degrees of parallelism require numeric values, not textual essays!

2.0 Parameters, Default Values and Effects

The following table lists all persistent configuration parameter names in both their 'plain English' forms and the form in which they are stored within the configuration file. It shows the default value where one applies and briefly describes the effect the parameter has on the way Semplice works.

Parameter Friendly Name	Parameter	Default Value	Legal Values	Program Effect
Default music folder	MUSICDIR	blank or null	Any valid full path to a folder that contains somewhere within itself a set of FLACs you wish to check for integrity	The default path that is used when scanning for FLACs to add to the database or to read during integrity checks
Default music database name	DBNAME	blank or null	Any textual value, preferably without spaces	The default database to open when launching Niente
Stop accented characters conversion	UTFCHARS	no	yes or no	If you type é or ü (or other accented characters), sometimes those may be converted to plain, unaccented equivalents such as e or u. Set this to 'yes' to stop that happening. It shouldn't happen anyway in most properly-configured Linux environments.
Default degree of parallelism	PARALLELISM	2	Any numeric value, less than or equal to the number of logical CPUs on your system	High parallelism speeds up some file scanning operations, but increases CPU load on your PC.
Threshold (pixels) for small art	SMALLART	300	Any numeric value	Sets the minimum size embedded album artwork can be before Niente reports it as being too small
Threshold (pixels) for large art	LARGEART	1600	Any numeric value	Sets the maximum size embedded album artwork can be before Niente reports it as being too big
Should album art be square	SQUAREART	yes	yes or no	If a piece of embedded album art is detected to has a different height and width, is that to be considered a reportable problem or not?
Theshold (dB) for volume boosts	VOLUMETHRESHOLD	2 (i.e., 2dB)	Any positive numeric value	Sets the minimum possible volume boost that should count as indicating a 'problem' on the Potential Volume Boosts report
Report on volume boosts	MAXV	yes	yes or no	Include or exclude the count of possible volume boosts from the Quick Aggregate Statistics report
Report filenames without bitdepth data	NAMEBITS	yes	yes or no	Include or exclude the count of filenames that don't appear to contain bitdepth data from the Quick Aggregate Statistics report
Preferred browser	BROWSER	blank or null	The name of any installed browser program	Specifies which browser to use to view Niente's various reports. Blank or null means “use the system's default browser”. If supplied, browser name values are not validated.
Use Kitty Graphics?	USEKITTY	no	yes or no	Specifies whether to display the program logo graphic using Kitty graphics ('yes') or sixel graphics ('no'), depending on the graphics capabilities of your terminal
Size of the Program Logo	LOGOSIZE	220	Any positive numeric value	Determines how big the program logo (the little picture of Beethoven) appears on the right-hand of the screen. The supplied value is used to determine both height and width, so a value of 180 would turn into a square image of 180 x 180 pixels.
Program Logo position (- or +)	LOGOPOS	0	Any numeric value, positive or negative	Shifts the program logo to the left (with negative numbers) or right (with positive ones), by as many characters as the number supplied. A value of -5 means 'move it five characters to the left'; a value of 8 means 'move it eight characters to the right'. Positive numbers should not use the '+' sign, but negative numbers will need to specify the '-' one.

Most of the parameters are, I think, self-explanatory and generally only ever change what is considered a 'problem' when running reports: what is considered a too-quiet recording, for example; what is considered too-large a piece of embedded album art and so on.

There are a couple of constraints on what is allowed to be entered for some of these parameters: if you set the small art threshold higher than the large art one, for example, then Niente will silently reverse the two numbers so that they make logical sense. It would not be sensible to regard a piece of artwork as too small if it's more than 3000 pixels big, but too large if it's more than 500 pixels, for example! But “too small at 500, too big at 3000” makes much more sense.

Probably the two most crucial parameters are the default database name and music folder: these determine what database Niente opens by default as it is launched, and where it will go to scan for new music files. If you leave these two values blank, you'll be prompted to supply suitable values every time you launch Niente, which becomes quite tedious really fast! What you type here, however, has to exist for the parameters to be meaningful: if you say your default database is called “NienteDB” when you've really created a database called “nientedb”, then the mismatch in the use of capital letters in the name will mean that you've told Niente to use a database by default which doesn't actually exist: that will trigger the incessant launch-time prompt to select a database properly. Similarly, if you specific a default music folder which doesn't physically exist on disk (or to which you have read permissions), then Niente will automatically wipe out your supplied value and leave the parameter set to blank: that again will trigger the launch-time prompt for a workable music folder.

Note that the 'Preferred browser' parameter does not need to be set and, indeed, it is recommended that you don't set it. A blank value simply means “open reports in whatever my system's default happens to be”, which is pretty much guaranteed to work. If you start typing names in, Niente doesn't check that you've typed a valid executable name in: supply 'fyrefox' by accident, for example, and Niente won't be able to open any such browser… and will, accordingly, fall back to opening in your system's default browser anyway.

Specifying a non-default browser on macOS can be somewhat challenging, as the name by which a browser can be invoked might not be what you expect. Install the Brave web browser, for example and you will not get reports to open in it by typing the name 'brave' into Niente's preferred browser field. That's because, as you'd see if you checked your Applications folder in Finder, the application is called “Brave Browser.app”: that means you need to type in “Brave Browser” in the Niente field, including the space and the capital letters. Similar misadventure will attend many attempts to specify a non-default browser and the recommendation is, accordingly, that especially on macOS, you should leave this parameter blank and let the system default browser kick in.

| Back to Software Home | Back to Niente Documentation Home |

nendbcreate

Anonymous (anonymous@undisclosed.example.com) — 2025-11-12T14:43:54+00:00

Database Creation And Population

1.0 Introduction

Niente is a database-driven program. It requires that a database exists which records the existence of all the FLACs in your music collection. Apart from the initial discovery of these FLACs, Niente does not do file system visits or scans: when it's producing a report, for example, it's obtaining all the data in the report from its database, not by taking a fresh look at the FLACs directly. Similarly, when Niente performs a new integrity check, it's reading the FLACs it knows about because they're listed in its database: it's not doing an on-the-fly scan for FLACs, but simply reading the contents of the ones the database tells it to visit. Without a database populated with details of which FLACs exist where, therefore, Niente can do nothing useful!

It's therefore important that, when you first run Niente, you immediately 1) create a fresh database and 2) populate that database with details of which FLACs exist in your music collection. That's why the Database menu is the one you always open Niente at when it is first launched.

2.0 Database Structure

I'll just pause at this point to explain the structure of the database that Niente uses. The main table is called TRACKS: it lists each FLAC filename, along with 13 attributes or characteristics concerning each file, such as its PERFORMER tag, or what bit-depth the music in a FLAC was recorded at, or what the COMPOSER tag is set to, and so on. If you have 1000 individual FLAC files in your music collection, the Niente database will contain 1000 rows in the TRACKS table, one row per file. If you've got a single Beethoven symphony, comprised of 4 individual files, there'll be four rows in the TRACKS table to describe each of them individually.

In addition to TRACKS, there is a MAXVOLUMES table. This will list each folder of FLACs, rather than each FLAC file individually, and for each folder, the peak loudness of all the FLACs contained therein is recorded. So, say you have those 4 FLACs representing a Beethoven symphony: one is at -0.3dB from maximum loudness, the second is at -2.3db, the third is at -0.8dB and the fourth is at -1.2dB. This means that the maximum volume boost you could apply to all the files in that folder without introducing distortion is +0.3dB: that would boost file 1 to be at 0dB, the theoretical, non-distorting maximum possible volume. In the MAXVOLUMES table, therefore, there will be just one row for the whole of (say) 'Symphony No. 5', and the peak loudness will be stored as -0.3dB, which is the largest possible volume boost that could be applied.

Finally, the Niente database contains another table called ALBUMART. This contains one row per FLAC file once more, and against each row is stored the horizontal and vertical dimensions (in pixels) for the album artwork that has been embedded within a FLAC, if any. This data then allows Niente to report on non-square, over-large or under-sized album art.

The TRACKS table is populated by performing a Wipe/Load or an Add/Remove operation, using options 2 or 3 from the Database menu, respectively. Doing so is extremely quick, even on large music collections, since the only data being collected is the full path and filename of each FLAC file in your collection. Collecting the detailed data that completes the 13 characteristics or attributes of each FLAC is what an integrity check will do -and those take a long time to complete for large music collections.

The ALBUMART and MAXVOLUMES tables are only populated by performing an album art or volume boost integrity check, using options 4, 5 or 6 from the Integrity Checks menu. These checks again take a long time to complete for large music collections. They each derive the information about what FLACs to interrogate from the contents of the TRACKS table, so if that table is empty, no album art or volume level checks can take place.

From all of that, I hope you can see that TRACKS is the 'driving table': its contents are what tell all integrity checks are the files to scan and what, therefore, can subsequently be reported upon.

3.0 Creating the Database

Creating a Niente database is a matter of just a second or two: it takes no time to create a file in which a bunch of empty tables exist, waiting for subsequent data entry. It's done by taking the Database menu, Option 1: Create a music database:

You are asked to provide a name for the database. I'd suggest keeping it short and sweet and without spaces inside the name (use underscores, as I've done in the above screenshot ,where you'd otherwise be tempted to type a space), though you can in practice use spaces and have as long a database name as you'd like. Long names will get variously truncated on subsequent screen displays, though the full name still gets used correctly internally.

You cannot leave the database name blank: you'll be told off if you try and be given another chance to type something sensible. If you type in a name of a database that already exists, that will also trigger the display of an error message, after which you'll again be given another chance to type something meaningful: Niente simply won't over-write an already-existing database.

If you provide a never-before encountered, not-null database name then, in a matter of a second or two, a physical file of that name plus a “.db” extension is created for you in the $HOME/.local/share/niente4/db folder, where all Niente databases live and a confirmation message is displayed:

Note the advice that the new database needs populating, which requires a scan of your music folders. We'll get to that in a moment! For now, clicking OK (or pressing [Enter]) at this point returns you to the main menu.

You can create as many databases this way as you like. You might, for example, want separate databases for your jazz collection, distinct from your classical one; or maybe you want to keep your 19th Century music in a different database from your 20th Century stuff… I wouldn't particularly advise that approach, but you're certainly allowed to do it. Only one of your databases can be the 'default' database that Niente opens automatically every time it's launched, but you can tap the letter 'C' when viewing the database menu to change what the working or current database is at any time.

4.0 Setting a Default Database

Creating a Niente database results in this sort of thing happening on your file system:

Each new database is represented by a separate file -and all databases start off at about 40KB small, so they're trivial in size. Here, I have created three distinct databases: whenever you launch Niente in the future, you'll be asked to pick one to work with:

Each file stored in the $HOME/.local/share/niente4/db folder is listed on this form: your job is to up- and down-arrow until the one you want to open is highlighted and then hit the <strong>space bar</strong> to select it. An asterisk appears next to the name and you can then click OK or press [Enter] to confirm the choice.

At any time after launching Niente, too, you can tap the letter 'C' whilst in the Database menu and the same form will appear, allowing you to change which database is in-use for the remainder of your Niente session.

If you don't mind being prompted in this way every time you launch Niente, then fine: you don't need to do anything else. If you only have one database, though, or if there's one database that you use much more than any other, you may want to declare it the default database. You do that in the Administration menu, Option 1: Edit Configuration File:

You just arrow down to the 'Default music database name' entry and type in the name of the database you want to use by default: just type the database name, not the name of the physical file (in my example, the database name is 'main', the physical file is 'main.db' and I therefore am typing in the 'main' version, without the .db extension).

Once the modified configuration parameters have been submitted (click OK or press [Enter]), subsequent launches of Niente will open the named database automatically, without prompting. You can still tap 'C' on the Database menu to switch away from the default to another database, but program startup will, at least, have been streamlined.

The database in use at any given time is listed on the main program display, on the third line of text at the top, in yellow:

…in this case, the 'main' database has been opened and is in use.

Which files get integrity checked, or reported on, depends entirely on the contents of the database that is in use whenever those options are taken.

5.0 Populating a Database

Creating a database was, as you saw, a matter of mere seconds, because hardly any work is required to create something that's just 40KB on disk! It is an entirely separate matter to populate the database with records of what FLAC files exist in your music collection. That's something which is done by taking the Database menu, Option 2: Wipe & re-load a daatabase from scratch or Option 3: Add/Remove files incrementally.

The difference between the two options is merely that Option 2 wipes and then populates, whereas Option 3 simply populates. In other words, if you've got a database you've been using for some time and it contains details on 15,701 recordings, taking Option 2 deletes all existing rows, scans the file system, finds 15,701 “new” files and adds them back to the database from scratch. Option 3, on the other hand, will scan the file system for files which are not already in the database and adds them to the existing 15,701 rows.

Option 3 will also delete from the database any rows which reference recordings which appear to no longer exist in the expected music folder. If you stored a FLAC in a folder called 'Syymmphiny No. 5' for example, then that would be in the database under that folder name; you spot the error and change the folder name to 'Symphony No. 5'… not only do you want the correct 'Symphony No. 5' added to the database, but you also want the now non-existent 'Syymmphiny No. 5' folder removed from the database: Option 3 will do both of these things for you.

Be warned that this 'tidy up apparently defunct entries' behaviour by Option 3 means that if you inadvertently ask for an incremental scan when your source folder is actually empty, the database will be wiped of all its records (which can always be re-constructed, of course, by a fresh scan after sorting out your source folder). I find this happens a lot for me, because after a reboot of my Niente PC, it's NFS mount (back to a NAS storing all my music) tends not to get successfully mounted (so the mountpoint ends up being just an empty folder. If I take Option 3 at this point, I thereby wipe my database, because the music files the database thinks ought to exist now don't exist: Niente's not smart enough to realise that this non-existence is a temporary state of affairs, rectifiable with a manual 'mount' command! To avoid accidentally wiping your database because of this sort of thing, Version 4.04 of Niente adds an extra check as Option 3 is taken: if the number of FLACs detected in the proposed folder to scan is less than 80% of the records known to exist in the database, that's at least 20% of your data that is about to be wiped. You'll see a prompt warning you about this and giving you the option to back out gracefully without altering anything in the database -or to proceed if you really know what you're doing:

A response of anything other than an explicit 'yes' at this point terminates the proposed scan:

Of course, when you've just created a database, it starts out with no rows in it at all and therefore everything found on disk will 'look new' to Niente -meaning that, just after database creation, there's no actual, practical difference between the two options: Option 3 is going to find 15,701 'new' files, just as Option 2 would do. Once you've populated a database, however, Option 2 is not something you'd want to take very often, if ever: you've gone through the pain of collecting data on 15,701 recordings and don't really want to have to re-collect that data from scratch. If you simply want Niente to take note of the 5 new CDs you ripped and added to your collection yesterday, therefore, you'd take Option 3 to add the 5 new recordings to the existing database.

If it helps to think of this way: Option 2 is a 'start all over again' option whilst Option 3 is a 'let's modify what we already have ' option.

Whichever option you choose, you'll have to tell Niente what folder structure to scan to discover new FLACs. This needs to be a folder that contains directly within itself FLACs, or sub-folders (or sub-sub-sub-folders!) that then contain FLACs. There need to be some FLACs somewhere inside the folder you mention at this point, though: you'll be warned if no FLACs are detected at all.

Be warned that you can't point a single database at two different folder structures.

That's because the scan for files in the second folder structure will always 'see' that the files in the first folder structure appear to no longer exist …and so records of them will be removed from the database. For example, suppose my folder structure is as follows:

I have a 'parent' folder called Music, within which are three distinct 'child' folders as shown. If I point Niente at /Music/classical, I cannot subsequently add FLACs found in the /Music/overflow folder to the same database. Doing so will certainly populate the database with recordings found in the /overflow folder but it will simultaneously delete from its database anything that was previously found in the /classical folder.

If I wanted both /classical and /overflow FLACs to be recorded in the same database, I'd have to point Niente at the 'parent' folder /Music: then it will read both child folders at the same time and FLACs in both 'branches' will be logged in the one database simultaneously. Of course, this would mean that my Niente database would also pick up on any FLACs stored in the /non-classical folder, which would probably cause grief down the road (Niente doesn't understand non-classical music very well!)

So, your music's physical organisation needs to be logical and well thought out. In my case, I actually only want Niente to scan for classical music in my main collection, so pointing it at /Music/classical will do just fine… but I can only do that and get away with it because I planned my folder structure sensibly!

Anyway, with all those warnings out of the way, I now take Database menu, Option 2:

The dialog that now appears allows you to navigate around your file system until the 'root' of your music's folder structure is reached. The form always starts off in your home folder, which is why /home/hjr is the starting point in my case. You can use the top panel (the one where I've got the folder 'hjr' highlighted in red) to navigate in a point-and-click sort of way: pressing the Space Bar whilst a folder name is highlighted there takes you 'into' that folder. To go back up a folder, you can tab round to the second panel (the one showing /home/hjr in the above screenshot) and just start deleting the last part of the path displayed there: the top panel will change to reflect what's typed in the second panel. In fact, you may find it easiest to tab to the second panel and simply type out the required path by hand: the top panel will merely give visual confirmation that you've typed it correctly!

Be careful to actually 'enter' the folder you want to be the root of your scan (by pressing the Space Bar when it's highlighted. For example, here it looks as if I've selected the /classical sub-folder:

The word 'classical' is highlighted in red at the top, after all. But look closely at the path typed in the lower panel: the word is 'classic' which isn't correct at all. If I clicked OK (or pressed Enter) at this point, the scan would fail completely, because an invalid path had been submitted. What I need to do instead is to tab round to the top panel and press the space bar with the 'classical' item selected:

Now I know I'm 'in' the /classical sub-folder, because I can see all the sub-sub-folders that exist within it. I can therefore press [Enter] at this point, confident I've pointed Niente to the right place.

Immediately I submit the new path, Niente runs off to the file system at that location and starts scanning for FLACs, either directly within it, or within sub-, or sub-sub-sub-sub folders of that 'parent' folder:

You get a brief visual confirmation of the folder being scanned and the database the scan results will be loaded into. This may not appear for very long, however, as the scan for FLACs is relatively quick to do: remember, you're simply producing a list of file names at this point, not working out all their tagging internals and physical corruption status. So, very swiftly, the screen will change to something more like this:

You get confirmation of how many FLACs were found in that location, and can then click [OK] or press [Enter] to return to the main menu. And that's really all there is to populating your new database! It takes hardly any time to do, even on the largest of music collections.

6.0 Configuring a Default Music Folder

You've just seen that I've populated my database with knowledge about 15,701 FLACs. If I were to quit Niente at this point, rip some fresh CDs, relaunch Niente, and ask it to do a Database menu, Option 3 to add the new recordings to the database, I'd see this:

It's the same folder selection dialog we saw back in Section 5 when populating the database in the first time, starting once again in my $HOME folder. Niente doesn't remember between runs which music folder you pointed it to before, in other words. That's not especially an issue: as you can see, it will happily prompt you to remind it every time you ask to do a new file scan. Nevertheless, it's not very convenient!

Fortunately, you can fix this issue by setting a default music folder in Niente's persistent configuration file, using the Administration menu Option 1:

You simply type in the correct, full path to the 'parent' music folder in the first of the parameter fields, then click [OK] or press [Enter] to submit the new value. No validation of your entry is made: Niente takes you at your word and if you type in an invalid path or folder name, it's not going to check your homework for you! The consequences will be a problem, though: if you type in an invalid path and then go and do a Database menu Option 3 to add new recordings to your database, you'll actually only achieve the wiping out of the existing records in that database! That's because Niente won't find new recordings in the default path (because it was typed in incorrectly), so won't be able to add anything. But it will also not find any of the existing recordings in the default path (because it doesn't actually exist!) and so will delete them all.

So: make sure you type in a valid full path to your music collection, please!

Once you've set a correct default music folder in this way, you can take Database menu Options 2 or 3 without being prompted for a working music folder: the default is assumed to be the 'working' folder for this session. Should that ever not be true, you can tap the letter 'F' whilst in the Database menu and changethe working music folder. So non-default databases and non-default music folders are always selectable, should you need to.

7.0 Wiping a Database

Database menu, Option 4: Wipe a music database shouldn't really be needed very often, if at all. It literally deletes all data out of the TRACKS, ALBUMART and MAXVOLUMES table (as ever, wiping the database has zero effects on the FLAC files themselves. Niente never deletes or modifies in any way FLACs it knows about).

Be warned that wiping a database takes place immediately and without warning (largely because a database can be re-populated by simply taking Option 2 again, so it's in a sense a non-destructive action). Though not harmful to any FLACs, an unintended wiping will mean having to re-scan and re-check large amounts of data, which can be a bit of a pain. So, be reluctant to use this option -and make sure you know what your currently-selected working database is before you take it, lest you inadvertently wipe the wrong one!

8.0 Conclusion

Niente databases are easily created, and relatively easily populated. Having created a database, it's sensible to set it as the default database.

Database creation is a distinctly different operation, however, from database population. For that you do a file system scan, either starting from scratch or merely adding to what's already in the database. File system scans need to be told where to start scanning -and that folder needs to be at the 'top' of a folder structure containing all the FLACs that are to be recorded in the database.

Whatever 'top' folder you choose to scan can be set as the default music folder, meaning that Niente will assume it should use that as its working music folder any time Niente's launched in the future.

Defaults can be over-ridden: tap C to change the working database; tap F to change the working music folder.

Populating a database is, in any event, a relatively swift operation since the data collected is very minimal: merely a record of the full path and filename of every FLAC discovered during the file system scan: it is only an integrity check that analyses the 'innards' of your FLACs, which is a very time-consuming process.

neninstall

Anonymous (anonymous@undisclosed.example.com) — 2026-03-31T11:06:10+00:00

Installing Niente

1.0 Operating System Support

There are four levels of support for installing Niente onto assorted Linux distros and other operating systems, as follows:

Tier 1: Used by me daily, on real hardware, extensively tested, guaranteed to work well
Tier 2: Used by me infrequently, mostly in virtual machines, lightly tested, tested extensively in the past, things will almost certainly work
Tier 3: Hardly ever used by me and then only in virtual machines. No testing done, unless specific issues are reported, but has worked in the past just fine, so things ought still to work, too
Tier 4: Thought to work, and tested to work in the past, but you're really on your own.

Putting specific, named distros into each tier goes as follows:

Tier 1: AlmaLinux 9 and 10, Fedora, Linux Mint, Apple macOS
Tier 2: Debian, EndeavourOS, Ubuntu, Raspberry Pi OS
Tier 3: OpenSuse Leap & Tumbleweed, GeckoLinux, Arch, Manjaro, Garuda Linux, Devuan, Linux Mint Debian Edition, Peppermint OS, MX Linux, AntiX Linux, Pop! OS, Linux Lite, Zorin OS, Elementary OS, KDE Neon, Tuxedo OS, Nobara, Ultramarine
Tier 4: Windows

Every listed distro did run Niente perfectly at some time in the past and, if the distro developers haven't messed around with core libraries too much, they should still work. However, only those distros in Tier 1 will receive extensive real-world testing from Version 4.04 and up. Other distros will receive either light-touch testing to make sure most things seem to work fine (Tier 2), or will only be tested on-demand by users reporting specific problems (Tier 3). I've provided some distro-specific notes and gotchas elsewhere.

Raspberry Pi OS is in Tier 2 simply because of performance issues: Niente's integrity checks are quite CPU intensive and neither the Pi 3 or 4 have the required 'oomph' to do integrity checks on a large music collection this side of eternity. I do run a Pi 4 as my main music playing machine and Niente has been installed on it and works reliably… so it ought to qualify as a Tier 1 platform. I simply can't recommend it to anyone that wants it to run at adequate speed, however, which is why it's down at Tier 2. If I ever spring for a Pi 5, its support status may yet be subject to promotion, but I wouldn't hold my breath!

Be aware that if you install Niente on Alma Linux 9, then upgrade your OS to Alma Linux 10, ffmpeg may suddenly cease to be an installed program! (Guess how I know…). Any full or differential integrity check you then perform will be unable to compute a fresh MD5 hash on your FLACs' audio streams: every FLAC will thus be declared 'potentially physically corrupt'. To re-install ffmpeg, you will need to add the RPM Fusion Free release repository. See this page for details on how to do that. Once it's been configured, a sudo dnf install ffmpeg will work, and new Niente integrity checks will work as intended. Alternatively, just do a fresh install of Niente: the Niente installer automatically knows how to install all the repositories and software it needs.

Apple became a Tier 1 operating system when I decided at the end of January 2026 to invest in a brand new Apple Silicon iMac. It's now my principle desktop operating system and, as my daily driver, is going to be the platform on which I test things out most thoroughly. I also have access to a couple of old Apple iMacs (from 2015 and 2012) that use Intel CPUs and can only run modern versions of the operating system thanks to Open Core Legacy Patcher: their 'officially supported' operating systems end with Catalina and Monterey respectively. Accordingly, Niente will be a Tier 1 supported application on only Catalina, Monterey and whatever OS version runs on a 2024 M4 iMac (Tahoe, at the moment). All other OS versions will be Tier 4 support: definitely do-able and definitely done and documented: but you're essentially on your own.

Windows is a bit of a special case, because it probably runs Niente just fine… but I have no means of knowing that for sure. Windows 10 reached end of Microsoft's official support back in October 2025, so all the hardware I have running Niente on Windows 10 is now no longer representative of anything supported by the operating system's own manufacturer. Windows 11 is, of course, fully supported by Microsoft -but I literally have no hardware that is officially supported for running it. I can hack Windows 11 onto a bunch of spare hardware, but it will be an unsupported and unrepresentative platform. The principle, however, is that if you get Windows running the Windows Subsystem for Linux (WSL2) then you can install one of the supported distros on that (for example, Ubuntu or Fedora) and Niente will run perfectly well in that environment. So, it's not that Niente won't run on Windows: it's just that I now expend zero development effort proving it does so. Any issues arising as you try to run it are therefore really yours to resolve. I will certainly offer advice and help if asked, but it will be merely on a 'best efforts' basis. In the meantime, I have written installation instructions for Windows 11 here.

Niente does not work on the Solus Linux distro.

2.0 Installation

The basic installation procedure for any supported operating system is, in a new terminal session:

wget software.bbritten.com/neninst

The installer is small (around 20KB) , so it will take hardly any time to download it. Once the installer has been downloaded, you launch it in the same folder you saved it to, with the command:

bash neninst

You will first see a screen warning you that the installer will make quite a few changes to your system, if you let it:

You need to type 'y' (and then press [Enter]) to proceed. If you type anything else, the installer will terminate without having touched your system at all.

At the end of the installation, when you first run Niente, you may find the program display garbled (it is equally possible you won't!). If you do, just visit the Administration menu, take Option 1 to “edit the configuration file” and then press [Enter] through the various options (without changing any of them, really) until you return to the main program display: you should find all visual glitches gone (though you may need to go back into the configuration options to adjust the size of the program logo: it defaults to being 220×220 pixels in size and that might be too large on standard 1080p resolution displays).

2.1 Software packages needed for Niente to work

To start with, the Niente installer will check for the presence of various packages on your system and will seek to install any that it finds to be missing. You can usually just let it do it's thing at this point, but if you are interested, here are the packages/programs that Niente deems essential to install:

bc (program allowing Bash to perform non-integer arithmetic)
flac (the library that allows FLAC audio files to be read and understood)
ffmpeg (an audio and video stream interpreter)
xterm (a terminal emulator or console)
sqlite3 (a simple database)
coreutils (a set of essential libraries, providing functionality like MD5 hash computation)
imagemagick (an image processing program: works with both ImageMagick versions 6.x and 7.x)
fd or fd-find, depending on distro (a file searching program)
dialog (a program allowing the creation and display of user input forms for the terminal)
cuetools (a program allowing the handling of cue sheets for merged FLACs)
curl (a program to perform file downloads)

If having any of this software installed on your system gives you cause for concern, type 'n' when the installer prompts you and give up on the idea of installing Niente altogether: the program cannot run without all of them being present, I'm afraid.

3.0 Getting Started, post-Install

Once Niente is installed, you can launch it by (a) clicking on the launcher provided on the Desktop (some distros require you to 'trust' or 'mark as executable' the launcher before it will work); or (b) clicking the option provided somewhere in the main menu, which is usually to be found under 'Multimedia' or (depending on distro) 'Sounds & Video'. The main program display should then appear:

Operation of the program beyond this point is hopefully self-explanatory, with the 'top menu' giving access to each of the three main functional components of Niente in turn, plus the various administrative, housekeeping functions::

Database: The initial creation and population of a database listing every FLAC file in your music collection
Integrity Checks: Scan the FLAC files listed in the database and extract metadata and physical characteristics from them
Reporting: Query the database and generate lists of files which fail particular physical or logical consistency tests
Administration: Various configuration or program management options

In all cases, top-bar menu options can be accessed by right- or left-arrow keys (the menu wraps, so a right-arrow from Quit takes you back to Database, for example), or by tapping the first letter of the menu name (so tapping 'D' gets you directly to Database, 'R' to Reporting and so on). Once a top-bar menu option has been selected, the numbered menu items within that option will be displayed and can be invoked simply by tapping the number associated with the item. Thus tapping 'D', then '4', will invoke the database wiping option; 'I' then '3' will trigger a fast integrity check, and so on.

A handful of options are accessible regardless of which top-bar menu is selected: they are accessible at any time by tapping the letter associated with them (these options are listed on the right-hand side of the main program display area). Thus tapping 'X' will exit the program, whilst tapping'L' will remove the prgram lock (which prevents two file scanning operations from taking place at the same time).

Beyond that quick-start approach, however, you should read the relevant pages elsewhere in the user manual for an exploration (and explanation!) of the rest of the program's functionality,

4.0 Conclusion

Summarising things as compactly as I can, then:

fully update your distro, so that it's using the latest packages and patches
wget software.bbritten.com/neninst
bash neninst
type niente at a command prompt to launch the program, or click on one of the graphical launchers provided

I hope all your Niente Version 4 installations work successfully and that you get up-and-running with the new program quickly and painlessly!

| Back to Software Home | Back to Niente Documentation Home | Quick Start Guide |

nenintegrity

Anonymous (anonymous@undisclosed.example.com) — 2026-02-18T10:23:21+00:00

Integrity Checks

1.0 Introduction

When you populate a Niente database, you fill it with data about which FLACs exist -and nothing much else. Here is a screenshot of the Niente database in a third-party tool that understands how to read and display databases after scanning for FLACs (Database menu, Option 2) but before performing any integrity checks:

You'll note that each row lists FLAC files found: that's the data which a Database menu Option 2 scan generates. You'll also note, however, that each row in this TRACKS table is supposed to have 14 columns of data (one of them fell off the right-hand edge of that screenshot!) -from MD5 hash values, to extracted PERFORMER, COMMENT and ALBUM tag data (to mention just a few). Immediately after a file scan all these columns are NULL for all rows: Niente knows nothing at all about the FLAC files, except for the fact that they exist.

A Niente integrity check is the process by which these columns are filled in with data, by visiting each listed FLAC in turn and reading all the metadata tags and copying the data found there into the relevant columns. Without an integrity check, therefore, Niente can report nothing meaningful about your music collection, other than the mere number of FLAC files that exist.

Generally speaking, populating these missing columns of data doesn't take a huge amount of time: one only needs to visit a FLAC file once to read all its tags in one fell swoop, so it's not particularly demanding on your CPU or hard disk. Tag data is, in other words, logical data about the FLAC; and logical data is easily and swiftly read by merely opening the file in question.

However, one particular set of columns requires quite a bit more work to populate: the HASH_ORIG and HASH_NEW columns are the columns in which the MD5 'digital fingerprint' of the audio signal within a FLAC are recorded. The HASH_ORIG is easy to fill, in that every FLAC is 'born' with an in-built MD5 hash value the moment it is created …and so all we have to do is read it, like any other logical tag. The HASH_NEW column, however, is where Niente stores the results of re-computing the MD5 fingerprint from scratch -and re-computation involves reading the entire audio stream (so, for a Wagner opera that's going to be a lot of music to read!) and performing a fairly CPU-intensive computation on the data thereby retrieved. Filling the HASH_NEW column is therefore a major slog… and is involved in determining the physical characteristics or state of a FLAC.

In short, Niente integrity checks can be logical or physical, or both (though Niente doesn't have an option to perform only physical checks). Logical ones tend to be relatively fast, and populate around 13 of the columns in the TRACKS table. Physical ones tend to be quite slow and computationally expensive and end up populating the HASH_NEW column in the TRACKS table.

The Integrity Checks menu, Option 1 : Perform a full integrity check is the option used to perform logical+physical integrity checks, for all records in the TRACKS table, ab initio.

The Integrity Checks menu, Option 2 : Perform a differential integrity check also performs logical+physical integrity checks, but it only does so for those records which are already known to have failed the various logical and physical integrity tests that Niente performs. If you add 3 new recordings to the database, for example, they will start off without any of the 14 columns of associated data and Niente will regard that as meaning that they fail its logical and physical tests: only those 3 new recordings would therefore have their logical and physical characteristics read, computed and loaded into the database using this option: the other 15,000 rows in the database that are known to have passed the physical and logical integrity checks previously performed would be skipped this time round.

The Integrity Checks menu, Option 3 : Perform a fast integrity check only performs a logical integrity check: it does not pay attention to hash value mismatches in determining what TRACKS rows to visit and if it visits a FLAC for any reason, it won't re-compute the MD5 'fingerprint' for that file (which is why it's quite a fast check to perform). Like the differential integrity check, however, the fast integrity check only visits those FLACs which are recorded in the database as having previously failed one or more of the logical tests that Niente applies. It will not, therefore, visit all the rows mentioned in the TRACKS table (unless all rows lack data for the metadata columns in the TRACKS table, of course). You'd use this option if you get a report saying 'three of your FLACs have a recording year that doesn't match what's in their ALBUM tag': that's a logical tagging failure, so you'd fix up those tags and to get Niente to re-check just those three files for logical consistency, this is the menu option you'd take.

By way of summary, then:

Full: Logical and physical tests of all known FLACs; previous results are wiped
Differential: Logical and physical re-tests of only those FLACs that have failed previous logical or physical tests
Fast: Logical-only re-tests for FLACs that are known to have failed previous logical tests

When you have just created and populated a database with Niente, therefore, your first integrity check should be a full one. If that produces details of any logical tagging errors that you need to fix (such as the recording year not appearing in the ALBUM tag, for example), then you re-tag the affected FLACs and get Niente to notice your corrections by running a new fast integrity check: since the fixes were all in tag metadata, there's no need to worry about re-computing the physical hash value for the audio signal in any of those FLACs. If Niente ever reports physical file corruption, however, then you'd re-rip that CD, or restore the files from a known good backup -and you get Niente to notice the fix by this time performing a new differential integrity check, since that will re-compute the MD5 hash values for the affected FLACs. Finally, if you are continuously adding to your music collection, you'd regularly run new differential tests to get the new recordings noticed and tested for both logical and physical issues.

2.0 Performing an Integrity Check

All integrity checks use the contents of the TRACKS table in the database to determine what FLACs should be visited and inspected. That is, they don't go off and do a re-visit of the file system to search for FLACs: that's what loading the database is for.

All integrity checks are performed in the same way: select the Integrity Checks menu, then select options 1, 2 or 3 (as explained in Section 1.0 above, each type of check is used in different circumstances). Immediately one of these options is taken, Niente starts visiting the appropriate FLACs listed in its database and reads their contents from disk:

The program display will show you which file is currently being read -and will list out some of the data that it has found within the file. Since this is a screenshot of a full integrity check, you'll notice that it displays the MD5 Hash which Niente has re-computed from the FLAC's audio signal (remember, full and differential checks both concern themselves with a file's physical integrity and MD5 hash computations are precisely the mechanism they use to do that). If I'd selected to do a fast integrity check, the screen would have looked like this:

It's the same sort of logical data as shown before, but this time there's no 'MD5 Hash' item to display. Fast checks don't read or re-compute MD5 hashes at all, because they deliberately don't concern themselves with the physical integrity aspect of a FLAC.

Note that you can interrupt an integrity check at any time (by pressing Ctrl+C, which will trigger the exit from Niente completely), and a new integrity check will simply resume from where it left off (unless it's a full integrity check: they always start from row 1, from scratch). There is a slight catch to terminating-and-resuming an integrity check, however: Niente always creates a 'scan lock' the moment it starts to perform an integrity check, to prevent second simultaneous integrity checks from confusing it. Terminate Niente abruptly, therefore, and the program is killed off before it has a chance to remove that scan lock. This means that if you restart Niente and try to re-run an integrity check you'll see this message:

The fix for this is to tap the L key: that will forcibly remove the program lock and allow a second integrity check to pick up from where the original one got to.

Be warned: if you remove a program lock when it's not safe to do so, you can corrupt your database. That's not fatal, of course: you'd simply wipe it, re-load it and start a fresh integrity check. For a large music collection, however, that would be a lot of work to re-perform, so it's not recommended! Remove the program lock if you have to and if you can guarantee to yourself that no other integrity check is running; don't do it casually or unnecessarily.

At the end of an integrity check, if you were able to see inside the Niente database, you'd see this sort of thing in the TRACKS table:

Compare that to the first screenshot shown in the introduction to this page and you'll see that all the columns associated with each row of data now have meaningful data in their associated columns, not just the word 'NULL'. This means we now have data about a FLAC that we can read, interpret… and point out when it appears logically inconsistent (which is what Niente's various reporting options will do for you).

3.0 Album Art and Volume Boost Checks

Integrity checks gather metadata tags from FLACs and (at least if it's a full or differential check) re-computes the MD5 hash or 'fingerprint' of a FLAC's audio stream. This allows Niente to report on most sources of logical inconsistency or physical corruption. There are two special exceptions, however: checking if album art embedded within a FLAC is of a suitable size and shape; and checking if the volume levels of the FLACs within a folder are as loud as they could be. These album art and volume level checks are not performed as part of a 'standard' integrity check -simply because not everyone wants to volume-boost their FLACs or to embed album art within them, whereas everyone wants to know if their FLACs are physically corrupt!

Accordingly, the Integrity Checks menu, Option 4 : Check album art for all files and Option 5 : Check album art for new files both perform album art checks, either against every single FLAC in your collection (option 4), or only for those files known to Niente but not previously checked for album art status (option 5).

Similarly, Option 6 : Check all files for volume boosts and Option 7 : Check new files for volume boosts are provided to perform an analysis of the music stream of a FLAC file and determine its peak loudness. Option 6 performs that analysis afresh for every FLAC file known to Niente, whilst option 7 performs the same sort of analysis, but only for those FLAC files known to Niente but which have not previously been volume-level assessed at all.

In both cases, the 'all files' option literally wipes the existing album art or volume data from the Niente database and starts collecting it once more, from scratch, for every FLAC in your music collection: that makes these potentially lengthy options to run. When you've just added a couple of new CD rips to your collection and want their album art and volume levels collected, however, that 'start over' approach would be a bit of overkill: the 'new files' versions of each type of check thus helpfully only bothers to collect such data for files which are known about (thanks to them being added to Niente via the Database menu, Option 3) but which are known to lack any prior volume or album art data.

Both the Album Art and Volume Boost checks work the same way a 'regular' integrity check does: you tap the relevant menu option and Niente immediately runs off to read the FLAC files in its TRACKS table and work out the appropriate data to store back in its database.

An album art check-up displays minimal information as it works:

Such checks will be over fairly swiftly, even on huge music collections, as it's trivially easy to check for a piece of artwork's pixel dimensions (for this reason, you cannot interrupt an album art check. That is, of course you're allowed to press Ctrl+C any time you like, but if you do that in the middle of an album art check, all work performed up to that point is lost entirely: a renewed art check therefore has to start over from scratch). The “ETA” field there is a very rough guide to how long Niente thinks it will take to complete the album art scan: it will jump around a bit as the scan starts, before settling down to something which is vaguely reliable!

The results of these album art scans are stored in their own table (called ALBUMART), as follows:

As you can see, only two bits of data are collected about any piece of embedded album art: it's height and width, in pixels. Niente does not (cannot!) concern itself with whether your album art is in focus, too old, too new or of questionable artistic merit! This data is, however, sufficient to tell us (via the appropriate reports, of course) that such-and-such a file has non-square album art (which is a problem for some people!) or that this-or-that FLAC has album art which is generally deemed too small or stupidly huge.

The volume boost check display contains a little more information as it proceeds:

The filename of the FLAC being analysed is displayed, along with the loudest volume level detected in that file. If the detected peak volume level is below a configurable threshold (by default, it's -2dB, but the Administration menu, Option 1 lets you alter that), then the display increments the 'Possible Volume Boosts found' counter. It bears repeating that Niente isn't actually applying a volume boost: it's not its job and Niente never modifies the FLACs it knows about anyway. It simply collects the data that lets you determine whether to apply a volume boost or not.

Once again, the “ETA” displayed is an extremely rough approximation of how long it will take to complete the volume level scan: the scan might race through a bazillion FLACs of Scarlatti harpsichord pieces before bumping into an almighty wall of complete Wagner operas… Niente cannot know for sure how long things are going to take when it is, effectively, having to listen to every bar of music in a recording without knowing the length of recordings yet to come. Don't be surprised if the ETA bounces around from time to time!

The volume boost scan populates its own table in the database, called MAXVOLUMES. If you could see inside the Niente database, you'd see it looks like this:

You'll note that the table does not list individual FLACs, but folders. That's because you cannot meaningfully volume boost individual FLACs regardless of the volumes of the other files in a folder: you'd end up making the quiet movement of a concerto or symphony as loud as the loud movement, which is not the effect you're after! You'd never want to adjust the relative loudness of movements like that. On the other hand, if the loudest movement was really quite quiet, then it would be fine to boost the volume of all the tracks in the folder so that whilst their relative loudness remained the same, their absolute volume increased.

This is what Niente is calculating with its volume boost check: it's finding the loudest file in a folder of FLACs and working out what the maximum possible volume boost to that FLAC could be without introducing distortion or clipping. If you can apply a boost of (say) +6dB to the loudest file, then you can also apply the same +6dB boost to the quiestest file: both files then have an absolute volume increase of +6dB, but their relative loudness, one to another, remains a constant.

Performing a volume boost check is CPU intensive and can take a long time, since the audio stream data in every FLAC has to be read to determine its peak loudness. Imagine having to wade through Wagner's entire Ring Cycle to work out what the loudest bits sound like! It's going to take a while …and therefore volume boost checks can be interrupted (with a Ctrl+C). You'd resume from where you left off by taking the Integrity Checks menu, Option 6, which picks up from where things had got to, without re-calculating everything from scratch (which is what Option 5 does). You'd have to remove the program lock (press 'L') to resume an interrupted boost scan, of course.

4.0 Scheduling Unattended Integrity Checks

Some integrity checks take a long time to complete (especially full integrity checks and volume boost checks). You generally don't want to be hanging around watching your screen for multiple hours as they plough through their work! Accordingly, Niente lets you schedule unattended integrity checks by launching it with various run-time parameters. This means that instead of launching Niente with the bare command niente, you add 'switches' to the command to make Niente do something immediately without further user intervention.

For example, if I launch Niente by opening a terminal and typing the command niente –check-full, Niente will immediately start to perform a new full integrity check. Or I could type the command niente –check-volume and a new complete volume boost check will begin. When Niente is launched with one of these run-time parameters, it provides absolutely no feedback at all to the user: nothing appears on the screen, which will simply go black and sit there as if nothing is happening at all (even though the program is running like crazy in the background!) The program provides no feedback in these situations, of course, because you're not meant to be sitting there watching it: they're for unattended operation of the program!

The complete list of run-time parameters that you can launch Niente with is as follows:

Parameter	Purpose/Function	Menu Equivalent
--scan-full	Wipes the existing tracks from a database and then re-scans default music folder to re-populate it from scratch	Database → 2
--scan-new	Scans the default music folder for new or modified recordings and adds them to the existing database	Database → 3
--check-full	Performs a full integrity check (i.e., physical and logical checks for all recordings in the database)	Integrity Checks → 1
--check-differential	Performs a differential integrity check (i.e., physical & logical checks for recordings with previously-detected physical or logical corruption issues)	Integrity Checks → 2
--check-fast	Performs a fast integrity check (i.e., logical check only of recordings already known to the database)	Integrity Checks → 3
--check-art	Performs a new album art check for all recordings known to the database	Integrity Checks → 4
--check-volume	Performs a complete check of possible volume boosts for all recordings in the database	Integrity Checks → 6
--aggstats	Generates a quick aggregate statistics report and writes it to /tmp/nientestats.csv	Reporting → General → 1

The real idea of these parameters is, of course, that you'll use your operating system's scheduler to make these activities happen during the dead of night. In most cases, this means adding a suitable entry to your system's crontab. Here's the crontab I use:

59 23 * * * /usr/bin/niente.sh --scan-new
00 1 * * SUN /usr/bin/niente.sh --check-full
00 1 * * MON-SAT /usr/bin/niente.sh --check-differential
00 3 2 * * /usr/bin/niente.sh --check-art
00 3 3 * * /usr/bin/niente.sh --check-volume

…which means, as follows:

Run a scan for FLACs which aren't already in the database and add them, at 11:59PM every night
Run a full integrity check at 1AM every Sunday
Run a differential integrity check at 1AM every night that isn't a Sunday
On the 2nd day of every month, at 3AM, run a fresh, all-files album art check
On the 3rd day of every month, at 3AM, run a fresh, all-files volume check

There is no run-time parameter, you'll note, to trigger a fresh album art or volume check only for those files that don't have the relevant information collected already: it's the full 'all files' version of those checks or nothing.

There's also a potential issue if the 2nd or 3rd day of the month happens to be a Sunday: my full integrity check is running on Sunday and by 3AM it's only been running for a couple of hours, which means it won't have finished. The art and volume checks that are meant to run that morning at 2AM are thus likely to spot the existence of a program lock and therefore not be able to run themselves. I consider this a rare enough occurrence not to care about a missed art or volume check, though, so I live with it. If that ever changes, I'll have to launch those checks later on in the day, maybe in the afternoon

Anyway: you get the idea. You can use the run-time parameters to schedule integrity checks to be performed in the dead of night, when you're not having to sit around and press menu options to make them happen!

Just be aware that there's no runtime parameter to specify the database to use or the music folder to scan for recordings: those have to come from a configured default database and music folder (so visit the Administration menu, Option 1 to set them).

5.0 Conclusion

Integrity checks of all kinds end with a whimper, not a bang! That is, no alarm bells go off, nor flashing lights annoy, whenever an integrity check reveals data corruption, logical inconsistencies or poorly-sized album art. The job of an integrity check is simply to collect the data that indicates those things exist: it's up to you to run the various reports that will tell you, precisely, which files are affected by such things.

Having run an integrity check, therefore, it's important to run one or more reports to find out what the integrity check discovered as it worked.

Remember that most integrity checks can be interrupted by pressing Ctrl+C, but that doing so leaves behind a program lock that will prevent any future integrity check from starting. Tapping the 'L' key removes that lock, permitting new checks to start: but if you remove the lock when you shouldn't do, your new check will completely screw up the work being performed by the already-running check.

nenquick

Anonymous (anonymous@undisclosed.example.com) — 2025-11-05T20:50:43+00:00

A Quick Start Guide

1.0 Introduction

By way of a whirlwind tour of how you go about installing then using Niente Version 4, the following article documents a typical 'workflow'. It assumes only that you've taken care of letting your PC 'see' your music collection already. If it's stored locally, that's fine. If it's stored on a remote server, it needs to be made accessible to the PC running Niente somehow, whether that's via a mounted NFS or Samba share. On my own Niente server, for example, I have this line in its /etc/fstab:

192.168.1.64:/mnt/bulkdata/music     /sourcedata/music       nfs  defaults,nofail,_netdev,hard,rsize=1048576,wsize=1048567,timeo=600,retrans=2        0     0

…meaning that the 'source of music' is a remote server with an IP address of 192.168.1.64. It stores its music files in a folder called /mnt/bulkdata/music and I'm mapping a folder on my Niente PC, called /sourcedata/music to that remote server store, using NFS, and with a bunch of option switches to make the 'mapped network drive' read-write, a network timeout of 60 seconds, performing reads and writes over the network in 1MB chunks, and so on. My Niente PC is thus given full access to my complete classical music collection, and by pointing Niente at /sourcedata/music, it's able to see all of it at once.

2.0 Installation

Installing Niente involves opening a terminal and typing the following commands:

cd
wget software.bbritten.com/neninst
bash neninst

The installation scripts requires an initial confirmation that you want to proceed:

The installer is going to create a set of new folders within your $HOME folder (for example, $HOME/.local/share/niente4/bin, $HOME/.local/share/niente4/txt and some others), and it will also potentially install a bunch of dependent software packages if it finds them missing from your system, so this screen is warning you about that and asking for your permission to proceed. Type 'y' to go ahead. You'll have to supply the sudo password at this point, because the installer also needs to create some files in /usr/bin, which requires root privileges. That done (which might take a few minutes to complete), the installer then pulls down the Niente program itself and verifies it for accuracy once it's done so. That usually only takes a few seconds to complete, and then it's all over!

What you'll usually find at the end of the installation process (though it depends on what sort of desktop environment you're running) is that a desktop icon now exists that can be used to launch Niente (though you may need to right-click it and select a context menu choice to 'trust' or execute the shortcut before it will actually run, since the Desktop is considered an insecure location for launching executables on many distros). You should also find a program launcher in the normal start menu: this will usually be under the 'Multimedia' menu or, on some distros, the 'Sound & Video' menu. Here's my Debian start menu, for example:

If there's a launcher in your start menu, you can just click it to start the program without having to confirm or approve it first: the start menu is usually considered a trusted location for executables.

3.0 First Run

The first time you launch the Niente program, you'll be met with this message:

Niente is a database-driven program. On first launch, of course, you won't have a database, so this message appears, warning that you'll need to create a database before Niente can be used to do anything productive. Click [OK] to proceed at this point and you'll be taken to Niente's main program area:

You'll see that the program has four main menu 'areas': Database, Integrity Checks, Reporting and Administration. You use the right- and left-arrow cursor keys to scroll around that top menu bar in either direction. You can also tap the initial letters of each menu item to jump directly to it: R (or lower-case r) will take you to 'Reporting' and 'D' (or 'd') will take you back to 'Database', for example.

Whenever you launch Niente Version 4, you always start off at the 'Database' menu item.

Bearing in mind the warning you received when launching the program, your next step should be obvious: tap '1' when sitting in the Database menu to 'create a music database'. Without doing that, Niente can be used for nothing!

3.1 Create a Database

Taking the 'Create a music database' option brings up this screen:

You are asked to supply a database name. The name can be anything you like -but I'd recommend keeping it relatively short (say, under 15 characters) and without spaces, though those are not hard-and-fast requirements. Here, you see me suggesting 'main_classical' as a name and using an underscore to replace the space that would naturally be there. Press [OK] (or click on it with your mouse: either keyboard or mouse work just fine on these sorts of screens) to proceed.

The screen will change to this:

The database creation process takes hardly any time at all, so you'll see this confirmation message appear almost immediately you click [OK]. As the message tries to point out, however, the reason everything just worked so quickly is that all you've done is create the necessary database structures -the tables, the indexes and views and so on. As far as actual data goes, however, the database is completely devoid of it. It knows nothing about your music collection (yet), so as soon as the database is created structurally, your next job is to perform a scan of your music files to populate it with meaningful data. We'll come on to doing that in just a second: for now, click [OK] (or press [Enter]) to dismiss the confirmation message.

3.2 Populate a Database

Your immediate next task is therefore to scan for music and have the details regarding that music added to your new database. This is also a relatively quick thing to do, because Niente only populates the database with details of what FLAC files exist, which does involve some reading from disk, but not a lot of it: there is no attempt at this stage to learn anything meaningful about those files, other than their mere existence. It's not going to read tags, or check album art, or work out whether they are corrupt or not, for example. Not yet, anyway!

So, take Option 2 to 'Load a database with fresh scan' and you'll see this:

This folder selection dialogue always starts off pointing at your $HOME folder (in my case, /home/hjr). You can use the top pane to navigate around your file system (the '..' double dot entry allows you to go 'up' a folder level, so highlighting it and pressing the space bar would take me to /home). You can also tab down to the second pane (the one displaying '/home/hjr') in that screenshot and simply start typing the correct path: the top pane will change its contents to match whatever you've typed. Here, for example, I've manually typed '/sourcedata/music and the top pane has changed itself so that the /music subfolder is highlighted:

Use whatever file/folder navigation technique you prefer to move to the correct location, therefore. Just be warned of a little quirk with this sort of form: though the second pane lists '/sourcedata/music', I haven't actually 'gone into' the music sub-folder. The top pane tells me I'm looking at it, but I haven't actually descended into it. If I were to press OK at this point, then I'd actually have selected the /sourcedata folder as my music folder. So, make sure you press the spacebar to go into the folder you want. In my case, I actually want /sourcedata/music/classical, so my form needs to show this sort of thing:

Here, I'm actually 'in' /sourcedata/music/classical and looking at the various sub-sub-folders that are within that sub-folder, which is correct for me. I can now click [OK] (or press [Enter]).

This triggers Niente's scan of that folder for music files (FLACs):

You can see the path that Niente is searching toward the top of the screen. The scan shouldn't take long to complete, even for a very large music collection. My 15,701 FLACs were all scanned in about 30 seconds:

When the scan is complete, you'll be told how many FLACs were found. Click [OK] to return to the main menu.

3.3 What a freshly-populated database looks like

It's worth pausing at this point to have a quick look at what this database 'population' process has actually done (though I'll give the game away up-front: not much!) For this, I'll use a tool called sqlitebrowser, which you are certainly under no obligation to install or use. It's just handy to see 'inside' the sort of database Niente creates at this point:

What you'll see with this sort of tool is that Niente's database consists of just a handful of tables, one of which is called 'tracks'… and the above screenshot shows you that the tracks table is now full of data. 15701 rows, in fact, one row per FLAC file found.

But you'll notice on the right of that screenshot are a pile of columns called things like 'HASH_NEW' and 'PERFORMER' and 'COMMENT' which are obviously intended to contain data about the FLAC whose full path and filename are listed in the FILENAME column. You'll notice, however, that at this stage of the game, every single one of those columns is currently set to a value of “NULL”, which is techie talk for 'empty' or 'devoid of information'.

All you've done at this point is tell Niente what files exist. It knows nothing more than that they exist on disk (and where). Filling up those columns with meaningful data is what an 'integrity check' is for -and therefore, that's the next step in this quick getting started guide.

3.4 Perform an Integrity Check

So we've created a database and loaded it with a minimal amount of data: now we need to populate the multiple columns for each row of that data. We do that by tapping the letter 'I' (or 'i') or arrowing across to the 'Integrity Checks' menu: when we get there, we take Option 1: Perform a full integrity check.

You'll note that there are two other integrity checks we could perform on this menu, though: Option 2 is a 'differential check' and Option 3 is a 'fast check'. What's the difference?

In a nutshell, a full integrity check goes through every row in that TRACKS table and analyses each FLAC mentioned there for both physical and logical corruption. The differential integrity check goes through only rows which are already known to have physical or logical corruption and re-checks them. The fast integrity check only goes through rows which are already known to have purely logical corruption and re-checks them. So you'd only use the differential or fast checks once you've been using Niente for some time: you start off by doing a full check and from that you learn that one file is physically corrupt, so you restore that one file from backup. Now you want to check just that one file to ensure it's free from corruption: and that's what a differential check would do for you.

At this point during your first 'getting started' run, in fact, it doesn't really matter which integrity check you go for, since every row is considered physically and logically suspect (since we currently know nothing about any of them). So even if you opted to do a differential check, you'd end up checking every row anyway. That would not be true after you've been using Niente for a while, however, so keep that in mind for the future.

Anyway: let me take Option 1 and perform a full integrity check:

Immediately the integrity check starts, the name of the file being analysed is displayed, along with all sorts of information gleaned by reading the file's internals and its metadata tags. The information read is displayed in the main part of the screen. A counter will show you how far along the integrity check has progressed: here, I'm only reading the 2nd out of 412 files needing to be read.

Integrity checks are slow. There is a lot of work involved in reading metadata tags from hundreds or thousands of FLACs. There's even more work (CPU intensive work!) involved in re-computing the MD5 hash 'digital fingerprints' that tell us whether a FLAC file is physically corrupt or not. So, you have to be patient at this point: this is where all Niente's efforts are employed!

You might think, given the amount of effort involved, that at the conclusion of a full integrity check that fireworks or bells would be set off… but no: when the integrity check completes, you are simply and unceremoniously dumped back at the 'Integrity Checks' menu. You wouldn't particularly know that anything at all had taken place, in fact.

But let's pause again at this point and take a fresh look inside Niente's TRACKS table using the same sqlitebrowser tool I used earlier. When I do, I see this sort of thing:

Compare this to the equivalent, earlier screenshot and you'll notice that all the previously-NULL columns now have meaningful data in them. This data is what now allows us to query the database and create meaningful reports: what rows in the table, for example, have MD5 Hashes that don't match, or whose PERFORMER tag isn't mentioned in the ALBUM tag, and so on.

So: a database creation populates TRACKS with rows. An integrity check populates the various columns of those rows with data. Only once the Niente database contains rows with a full complement of column-based data can you query the database to create reports.

3.5 Further Integrity Checks

Before we start producing corruption reports, however, there are two other types of integrity check I'll bring to your attention: album art scans and potential volume boosts. These test, respectively, whether each FLAC has embedded album art and what its dimensions are if so; and whether or not a FLAC's peak volume level is well below what it could be before distortion is introduced. This sort of data is not collected as part of the 'ordinary' integrity check we've just completed, because it requires extra effort to collect and not everyone cares about it. Audiophiles won't go near mucking about with a FLAC's volume level, for example; whilst some music fans like their album art to consist of standalone files contained within the music folder, not embedded within the FLAC itself. Neither group of people would be interested in knowing about embedded album art sizes or peak volume levels!

If you were interested in this sort of information, though, you'd manually have to take options 4 (or 5) and 6 (or 7) to have your new data in the TRACKS table analysed for these sorts of issues. Options 5 and 7 do partial art or volume scans, finding rows in the TRACKS table that currently lack album art or volume boost data; options 4 and 6 do full scans of every row in the TRACKS, regardless of their current art or volume boost status.

The album art scan is relatively quick:

…and you can see that the display as it progresses is fairly basic, with just an indication of where the scan has reached at any given point. When it concludes:

…you get a simple confirmation message. Click OK to return to the main program menu. This scan populates a special table in Niente's database called ALBUMART:

That table contains the full path and filename of each FLAC and, as you can see in the columns at the right, works out for each of them what the height and width of its embedded album art is (in pixels).

The volume scan is much harder work:

Niente visits each row in the TRACKS table in turn and literally works out the loudest volume each file gets to (where 0 decibels is the loudest, non-distorting volume you can have). In the screenshot, for example, my Appalachian Spring recording has a peak volume of -1dB, so it's just a little quieter than it absolutely could be, but it's probably close enough to not be worth worrying about. That's why you see that 'Possible boosts detected' counter at the bottom of the screen is stuck at 0: though this is a file that could technically be volume-boosted, it's close enough to maximum loudness that it's not worth bothering about.

On the other hand, here Niente's detected a significantly-quieter-than-it-could-be recording:

Here, the file is 7.4dB quieter than as-loud-as-possible, so it is counted as a possible volume boost. Niente's default threshold for whether something counts as 'too quiet' or not is 2dB, though you can adjust that in the persistent configuration file if you like.

When the volume scan completes, you are told of the fact:

Click OK to get back to the main menu. The volume check populates a new table in Niente's database, called MAXVOLUMES:

Each row represents a folder of FLACs, and the maximum possible volume boost (measured in decibels) that could be applied to that folder without making the loudest FLAC in it distort.

In case it isn't clear, at no point during these checks is Niente modifying your FLACs. No album art is being adjusted, no volume levels are being boosted. All Niente integrity checks simply read the FLACs listed in the TRACKS table and work out things about those files. Niente never writes back to FLACs, and thus never adjusts anything about them.

3.6 Reporting

Once all necessary integrity checks have been performed, you can select the Reporting menu and start getting information out of Niente, rather than loading data into it. Your first port of call should probably be the Aggregate Statistics report, which is generated by taking Reporting → General Reports → Option 1:

From this, I can see that of my 412 recordings, 1 might be physically corrupt (statistic G2), 1 has missing tags (G4), 1 has logically inconsistent PERFORMER and ALBUM tags (L4), 5 have album art problems (O1) and 31 have volume boost potential (O2).

Responding to this report, it's important to get physical corruption sorted first. Often, you'll find that physical corruption makes it impossible to read tags correctly: My G2 and G4 issues, for example, might very well apply to the same FLAC, the physical corruption making it impossible to read metadata tags. Fix the physical corruption (by re-ripping or restoring from a backup) and you may well fix the missing tag issue too.

Of course, you'll need to know which files are affected by these problems. That's why the statistic identifier is included in the aggregate report: G2 means 'take the General Reports, Option 2 to produce the detailed report for this problem', which will list every file affected individually. Here's the G2 report, therefore:

And here's the G4 one:

So, on this occasion, the missing PERFORMER tag affects a file which isn't the one that's corrupt. I bet it's the same file as is causing the L4 PERFORMER/ALBUM tag inconsistency, though! Here's the L4 report:

And sure enough, it's the The Heiress Suite FLAC that's responsible for both statistics -and the reason is evidently that the PERFORMER tag is empty for this FLAC, so naturally it doesn't match the ALBUM tag's version of the data.

You get the idea, I hope: the Aggregate Statistic report gives you a nice overview of where physical and logical issues exists; the various detailed reports allow you to pin down where and what is causing the problem.

Fixing up any of this stuff is down to you: Niente never writes back to FLACs and therefore is not capable of fixing up any of these issues. Its job is to tell you that issues exist, not to rectify them. How you rectify them is also down to you: physical corruption might need re-ripping or restoring from backup; a logical tagging problem, such as the missing PERFORMER tag, can simply be fixed by editing the tags associated with a FLAC (using a tool such as my own Semplice tag editor, for example).

But any way: that's the end of our 'first run' with Niente. By way of recap:

Create a database
Populate the database by quick scanning for the existence of music files
Interrogate those music files for metadata and physical characteristics with an integrity check
Perform optional additional checks on album art and/or volume levels
Report on the state of your music collection and use Niente's reports to pin down what FLACs have which logical or physical problems

At this point, you can quit out of Niente altogether: tap the letter 'Q' from the main menu and press [Enter] (or type 1).

4.0 Second Run: Setting Defaults

If you were to re-launch Niente at this point, this would happen:

Niente needs a database to do anything useful. That you previously created one makes no difference to it: it doesn't know to use it as its working database for this second and subsequent session. However, rather than get told 'you need to create one' as happened on the first run (see Section 3.0 above, the first screenshot), this time Niente is at least smart enough to know that usable databases do exist: so it's now telling you that you'll have to pick one, once you click [OK]:

Here, Niente is listing all the *.db files it knows about in the $HOME/.local/share/niente4/db folder and letting you select the one you want to work with. The form works the same way, whether it's listing just one file (as here) or several: your job is to highlight the database you want to work with for the session and press the Space Bar to select it. An asterisk will appear next to the chosen database name and then you can click OK to submit the choice:

A confirmation message appears and if you click OK on that, you'll finally be taken to the main menu:

The third line of text at the top of the screen confirms that Niente is now 'Using database main_classical', meaning the choice has taken effect.

A similar sort of “I have no recollection!” issue arises if you were to want to add a bunch of new recordings to Niente's database. You've got a working database now, but take Database menu, Option 3 to add new files to it and this happens:

Niente has no memory of where you last looked for music files, so it has to start out prompting you for a music folder, from scratch, assuming that it should at least start in your $HOME folder.

Which is all well and good if you like having to spell things out every time you run a program! Surely a more convenient thing would be to tell Niente to open a particular database or use a particular music folder by default?

And that's precisely what the Administration menu, Option 1 is for:

You'll note the top two options here are currently blank: they determine what database Niente opens by default whenever it's launched and what music folder it will scan automatically without prompting. It's the default blankness of both parameters that trigger Niente's 'let's ask every time we're invoked' behaviour. A sensible approach is therefore, immediately after you've created a database and scanned a music folder to populate it, is to edit these configuration parameters and set sensible defaults, which is what you see me doing here:

There are, of course, lots of other parameters here whose settings can have interesting effects on the way Niente works… but the top two are the most important to set, unless you like being prompted all the time to re-specify the two most crucial bits of information Niente needs to work properly.

5.0 Temporarily Over-riding Defaults

Given that you will now have set default working databases and music folders, suppose you suddenly want to use a different database or scan a different, non-default music folder?

Changing the working database is easy: with the Database menu selected, tap the letter 'C' and follow the prompts to pick a database from the list of .db files that are known to exist in $HOME/.local/share/niente4
Changing the working music folder is also just as easy: again, once the Database menu has been selected, tap the letter 'F' and use the usual folder-selection form to pick a new working music folder.

Once a new database has been selected any integrity checks you perform, or reports you produce, will use that new database's TRACKS table to determine what files to scan or what data to report on. The change in 'source' of data is immediate.

For example, suppose this is my initial state when launching Niente:

From the third row of text, in yellow, you can see I've obviously set the default database to be 'nienteoverflow'. Fine: I run my Aggregate Statistics report and see this:

The overflow database knows of just five recordings, all in good shape. Now I return to the Database menu and tap 'C':

Here, I've selected 'nientemain' as the new working database… and I immediately re-run the Aggregate Statistics report:

This time, the report is on just four recordings, not five. Clearly, a new source database lies behind this report compared to the original one.

So, switching databases is simple and quick to do, and doesn't require a lot of thinking about: it merely means that what gets read when you do a new integrity check, or what gets reported on if you run a fresh report, will be immediately different than before.

Switching music folders is slightly more troublesome, however, and you need to be careful about doing it. When Niente adds the results of a new file scan to a database, it also deletes from the database any files that are no longer on disk within the currently-active working folder. In other words, say you have this situation:

/music/classical → 15,000 files
/music/overflow → 3,000 files

You create a database called “main” with /music/classical as the working music folder: the database will immediately be populated with 15,000 files.

You then tap 'F' and select the /music/overflow folder and then take Database menu, Option 3: your intent is to add the 3,000 overflow files to the same database as already houses the 15,000 files. This is not what will happen, however. The new file scan will certainly add the 3,000 overflow files into the database, but it will then note that none of the existing 15,000 rows in the database represent files which can be found on disk in the /music/overflow folder, so will delete them. Your database will now contain only 3,000 rows of data from the /overflow folder structure.

Were you to tap 'F' and switch back to /music/classical and again take Database menu, Option 3, your database would once more contain 15,000 rows of data …but nothing relating to files in the /music/overflow folder would remain.

In other words, a Niente database can only hold data from one folder structure at a time. Changing the working folder and then using Database menu Option 3 to scan the new folder will always obliterate the database data that was sourced from the original folder used to perform the earlier scan.

In this scenario, you should really create two separate databases (one called 'main', another called 'overflow', for example) and use the 'F' key to override the configuration file's default music folder setting when working with one or other other. But you cannot ever load into a single database the contents of two distinct music folder 'trees'. Your only other option, if you really wanted a single database to contain data about all 18,000 files, is to change the working folder to /music and perform a fresh scan: given that both /classical and /overflow are sub-folders within the /music folder, pointing Niente to the root of both will allow the files in both sub-folders to be scanned in a single operation.

Also bear in mind that selecting a new working music folder is different from asking Niente to scan it: you have to do both things, separately. Merely selecting a working folder doesn't trigger an automatic scan of that folder for FLACs -precisely because an automatic scan on a working folder change would result in mass data deletion from the working database.

But another reminder that when I talk about Niente 'deleting data', I'm only talking about it deleting rows of data from within its database(s): it will never delete actual FLAC files from your music folders!

6.0 Adding New Recordings

The commentary in Section 5 above might make you wary of ever using Database menu Option 3 to re-scan your music files, but it shouldn't! A re-scan can only remove data from a database if the folder tree being scanned is new. If the folder tree is the same one as the database was previously populated with, then recordings that still exist in the locations Niente expects to find them defintiely won't be removed from the database.

Meanwhile, a re-scan will pick up on new recordings that have been added into the same folder tree. It will also delete from the database any recordings that are now not in the same folder tree they used to be in, because you couldn't stand listening to them anymore or because you mucked up storing things in the right place!

For example, say I've created a database called 'main', using music folder /music/classical. Perhaps an Aggregate Statistics report says I have 1000 recordings in my collection.

I now rip a new CD and store it in folder /music/classical/Benjamin Britten/Peter Grimes (Pears - 1958). When I take Database menu Option 3, the scan will spot the new arrival and, since it's still within the same overall folder structure, it will add it to the existing recordings. I will now have 1001 recordings in my collection.

Then I notice that I forgot to store the new recording in an 'opera' genre sub-folder, so I use my operating system's file manager to cut-and-paste the previous recording into /music/classical/Benjamin Britten/opera/Peter Grimes (Pears - 1958). If I now do a Database menu Option 3 re-scan, Niente will note the arrival of a new recording in the …/opera/… sub-folder, and add it to its database: temporarily, I'll have 1002 recordings in my collection. Almost immediately, however, Niente will also spot that the original …/Benjamin Britten/Peter Grimes… folder no longer exists, so it will delete it from its database. I will therefore be back to having 1001 recordings in my collection, though the physical location of one of them will appear to have changed.

In other words, regular re-scans pick up new recordings and the deletion/movement/change in name of existing recordings, provided everything relates to the same music folder tree as was used to populate the database last time round.

7.0 Update the Software Periodically

The last thing to mention on this quick tour of starting to use Niente is: how to make sure you're using the latest version of Niente. I'll update the software periodically to add new features or to fix up bugs in the coding of old ones… and you'll therefore want to make sure you're using the latest version of the Niente software.

That's done by a visit to the Administration menu and taking Option 5 : Check for software updates.

The moment you select that option, Niente will start checking its own existing files and compare them with what equivalent files are available on this server:

It's not exciting to look at and in any case only takes a few seconds to complete, so you might not see any of that output anyway. At the end of the process, you might see this message displayed:

This is the message you see when the version of Niente's files on your PC matches those of the files on this server exactly: no harm has been done, nothing has been altered, there's nothing to see here!

But, you might also see this message:

That tells you something in one or more of Niente's program files has changed and that the version on this server differs from that on your PC. You would be well-advised at this point to click 'Yes' (or just press [Enter] which amounts to the same thing in this context) and, if you do, the screen will change to this:

It's just a standard prompt to supply your sudo password to acquire root permissions: Niente is going to copy files to /usr/bin and needs elevated privileges to be able to do so. Type in the correct password and this will happen:

Each dot that now appears represents a fresh download of a Niente executable file. When all files have been downloaded, the screen will tell you the process is complete:

Click OK at this point and you'll be returned to the main menu. It's then rather important to quit Niente and re-launch it in order to get the changes just downloaded to be applied to the running software. As you quit, you may see error messages displayed on-screen: this is quite normal. The program being quit has just had the executables that define it changed whilst it was running and therefore, it's liable to get a bit confused when it exits, expecting to find the program ending at one point but the new executable ending at another. Any errors on quitting the program can therefore be ignored: just re-launch Niente and carry on from where you got to.

My recommendation would be to run a quick check on possible software updates once a month or so. Additionally, keep an eye on the blog page of this website: I announce all new versions there as they are released.

8.0 Conclusion

There is always the danger in articles like this that in seeking to explain, I merely confuse! Though there are many subtleties to the way Niente can work with multiple databases and multiple different music folders, it's very straightforward if all your music is found within a single tree structure and you run Niente with a single database. If you keep it that simple, the Niente 'workflow' is simply:

Create the database
Run a file scan to populate it
Run a full integrity check
Optionally, run an album art check
Optionally, run a volume boost check
Run reports when needed
Periodically run a re-scan to pick up file additions and changes
Periodically, run a differential integrity check
Periodically, check for software updates

Use Niente to tell you when your tagging has gone astray, or when your file system has let you down and allowed files to become corrupted. Use it, too, in conjunction with Semplice to re-tag troublesome files or to re-rip physically corrupt FLACs. Above all, use it to gain peace of mind that your digital music assets are in good shape, physically and logically.

| Back to Software Home | Back to Niente Documentation Home | Installing Niente |

nenreports

Anonymous (anonymous@undisclosed.example.com) — 2026-02-13T13:38:14+00:00

Reporting

1.0 Introduction

When you perform an integrity check of your FLAC collection with Niente, not a lot appears to happen! Sure, we see the program visiting each FLAC it knows about in turn and learning things about it:

…but if it detects anything amiss during its file inspections, no red lights or sirens go off: the program will merely conclude its integrity check by re-displaying the main menu, which seems somewhat anti-climactic! So, performing an integrity check is an information gathering exercise, but the integrity check itself never shares that information with you. In order to actually see whether or not your music collection is suffering from physical corruption or logical inconsistencies, you need to use Niente's various reporting options. These all interrogate the data collected during an integrity check and list those records found to be failing one check or another.

In short: it's by running reports that you at last get to understand the health and status of your music collection.

All Niente's reports are accessible under the Reporting Menu:

You'll notice that there are three sub-menu options listed: General reports, Logical Problems reports …and a final category unimaginitively called 'Other Reports'! You access any of these sub-menus by tapping the number next to the appropriate menu option: if you wanted to run a particular report on any logical inconsistencies in your music collection's metadata tags, you'd start by tapping '2', therefore. If you do that, you'll see this sort of thing:

The various reports that can be generated within this category are listed in the left-hand part of the screen; the three categories of reports that were previously accessed by tapping a number are now 'promoted' to appear as options on the top-bar menu. You can therefore switch between report categories easily just by pressing the left- and right-arrow cursor keys (or by tapping the initial letter of the menu required: so typing 'g' will take you to the General Reports category, for example). When you're done producing reports, just arrow over to the Main Menu item (or tap 'm') and choose from the options presented:

Option 1 takes you back to Niente's initial main menu (where you'll find the 'Reporting' option remains selected), but Option 2 is provided so that you can quit out of Niente completely with a single key-press.

When you choose to run any of Niente's reports, they will be displayed in your system's default browser window as an HTML document:

Since each report is displayed in your browser, you can use standard browser menu options to save it as a PDF or as a text file. In Firefox, for example, just click the File → Print menu options and then select the 'Save to PDF' option from the standard print dialog. Similarly, File → Save Page As will let you save the report either as an HTML or a plain text document.

Bear in mind that every report is produced by reading from the Niente database as it was at the time of its last integrity check. If, let's say, you produce a report that tells you four files have PERFORMER/ALBUM tag inconsistencies and you re-tag all four of those files before re-running the report once more… you're just going to see the same four files listed on the new report as they were before. The database doesn't know you've re-tagged those files until you make it realise the fact by performing a new integrity check (I'd suggest a fast check in these particular circumstances). Only after a new integrity check is performed will you see the report contents change. Similarly, if Niente tells you 3 files are physically corrupt and you restore those files from a known good backup, so that the files on disk are no longer physically corrupt, Niente will still tell you they are corrupt, because unless you do a new integrity check (in this case, a differential one would be most appropriate), its database still stores details of the original files. The new integrity check will force Niente to re-read those files and when it does so it will, at that point, notice that the internal characteristics of the files have changed and write those new, uncorrupted characteristics back to its database.

Finally, before I describe the reports in some detail, remember that when it is not reporting on the physical integrity of your FLACs, it's drawing on the Axioms of Classical Tagging to determine whether something is 'wrong' about your FLACs or not. If you do not yourself subscribe to all or some of those Axioms, the relevant reports will be of no use to you -but Niente will keep reporting them as a problem anyway! If you think recording artists should be listed in the ARTIST tag, for example, and not in the COMPOSER one, then every single FLAC you own is likely to be reported as having a 'ARTIST/COMPOSER' inconsistency. You can simply ignore such reports though, if it suits you to do so.

2.0 General Reports

2.1 Quick Aggregate Statistics (Option 1)

Possibly the most useful report that Niente can produce, the Quick Aggregate Statistics report is a snapshot summary of the state of your music collection. It lists 16 specific statistics, as you can see in the last screenshot above.

Ideally, you want to see zeroes for all the rows in this report, except the first and last ones. The first row tells you how many recordings have been added to the Niente database (so hopefully that's non-zero because otherwise it means you don't have a music collection!). The last row shows the date when the last integrity check of some sort was performed and thus the date when the database was last brought up-to-date with the state of tagging and physical integrity of your collection.

Each statistic is prefixed with an identifier (such as 'L4' or 'O2'): these are the menu options you'd take to produce the report that 'explodes' that statistic out into its detailed, constituent rows. For example, the details about what 'Inconsistent PERFORMER/ALBUM tags' I have are called 'L4', which means 'Take the Logical Issues Reports menu, and run report 4 from there' (i.e., L4). The details behind the 'Recordings not yet checked' statistic, however, can be obtained by running the 'General' report number 3 (G3). Likewise, to list all the files that are missing sample rates in their file names, I'd need to run the Other report number 3, or O3.

You get the idea, I hope: each non-zero row in the Quick Aggregate Statistics report should be regarded as a trigger to produce the corresponding detailed report that will list the specifics of what's been detected as potentially going wrong.

Note that two statistics may not be listed in this Aggregate Statistics report, though they will be by default. The rows O2 (“Potential Volume Boosts”) and O4 (“Missing audio data in filenames:”) will only appear if you have configured the persistent configuration parameters Report on volume boosts and Report filenames without bitdepth data respectively. Both parameters default to 'yes', so those rows will appear by default. However, if you switch those parameters to 'no', because you simply aren't interested in doing volume boosts to your music files and/or don't care whether their physical files contain bit-depth and sample-rate information, then those rows will disappear from the aggregate report. You can always run the equivalent detailed reports, however, even if you've turned off aggregate reporting for those particular issues.

2.2 Recordings with physical integrity problems (Option 2)

This is probably a critical report -because even if you don't agree with one iota of how I believe classical music should be tagged, we can all agree that the audio stream of your FLAC files should not undergo any alteration from the moment it was created when you ripped the CD -and this report lists those FLAC files where that doesn't appear to be true:

As you can see from the report itself, here Niente is comparing the MD5 hash, or 'digital fingerprint', that is stored internally within a FLAC when it is first created with a freshly-computed MD5 hash: if there's a tiny change in the bits making up the audio stream within a FLAC, the result will be that the new hash value won't match the old one… and that tiny change is probably bit-rot, meaning the file is internally corrupt.

That said, it's impossible to compare nothing to something, so if either the new or old MD5 hashes is blank, that will also trigger the inclusion of a FLAC file on this report. That might indicate corruption -or it might indicate something has gone wrong with the Niente data collection process.

There is no fixing physical corruption within the file itself. The only thing you can do for files listed on this report is to replace the file -either by backup copies which you hopefully have available to you from a time before the file was first detected as corrupt; or by re-ripping the file from the original CD (or re-downloading it from whatever digital emporium you buy your music from!) If the file is there because one or other hash values is declared 'empty', a fresh integrity check might resolve the issue.

2.3 Recordings not yet analysed at all (Option 3)

This report selects for FLACs that are missing all the tags which the first Axiom of classical music tagging states should be considered compulsory: tags such as ALBUM, COMPOSER, ARTIST, TITLE, TRACKNUMBER and so on. If all of those are missing for a particular file, it's probably because no integrity check has yet been performed on it. This is, in fact, the 'natural' state for FLACs that have just been added to your collection: an incremental addition of the files (using the Database menu, Option 3) will mean the file's physical location will have been added to Niente's database, but until a fresh integrity check has been performed, the internal tag details for such files will remain empty. That's considered something you should know about!

Performing a new full, incremental or fast integrity check should see these rows disappear off this report.

2.4 Files with one or more missing tags (Option 4)

The not-yet-analysed report (see Section 2.3 above) will list files that have all the 'compulsory' tags missing. That's usually fixed by running a new integrity check. This report, on the other hand, lists files that have some of those tags missing:

The report will actually list which specific tags are missing over on the right-hand side.

The only way some tags can be present and others missing is if the missing tags were never actually written to the FLACs in the first place. This isn't, therefore, fixable by doing a fresh integrity check: it implies that there's actually an issue with the way you tag your files in the first place. Only a fresh round of tagging can resolve this issue!

3.0 Logical Issues Reports

I won't detail the five reports in this section. They all work in ways similar to what you've already seen in Section 2.0 above so should be familiar in operation in that regard. The point to make about them all, collectively, is that they are fundamentally 'enforcing' the rules of tagging I set out in my article on the Axioms of Classical Tagging. If you agree with all or most of the axioms presented there, then all or most of these five reporrts will prove useful to you. For specifics about what Niente expects to be present in which tags and what logical consistency checks it will therefore perform, please see the Logical Inconsistencies section of this user manual.

If, however, you fundamentally disagree with my proposed tagging strategy, then you will probably want to ignore all these reports! If you don't write your ALBUM tags as 'composition (performer - year)', for example (see Axiom 5), then you won't have any need for a report that checks whether the performer component of ALBUM matches the PERFORMER tag, or whether the recording year component of ALBUM matches the YEAR (or DATE) tag.

That's not true of the General or Other reports, on the whole: even if you tag your FLACs in a wildly different way to me, reporting on tags which are missing, or which are possible duplicates of each other, or which are physically corrupt sound like good things to know about.

So, I guess my point is: the reports in the 'Logical Issues Reports' may not be to your taste, but the data is there, should you ever change your mind!

4.0 Other Reports

4.1 Recordings with album art issues

There will be no items on this report unless you have first performed a special 'check album art' integrity check (see the Integrity Checks menu, Options 4 or 5). Performing such a check adds the pixel dimensions of the embedded album art found in a FLAC file to a special 'albumart' table within the Niente database:

Once that table has been populated, rows will appear on this report for one or more of three configurable reasons:

The album art height and width are not exactly equal to each other
The height is above or below a threshold size
The width is above or below a threshold size

By default, Niente expects album art to be square, so height and width dimensions not being identical is considered an issue. If non-square art is not actually a problem for you, you can turn off Niente's demand for square art by setting the 'Should album art be square' option in the persistent configuration file to 'no' (See Administration menu Option 1).

The configuration file also has settings for 'Threshold (pixels) for small art' and 'Threshold (pixels) for large art'. These determine if an embedded piece of album art should be considered too small or too large, respectively. From the example report shown above, it would appear that whilst all my album art is nicely square, it's considered too big: from the specific numbers shown, I would guess that my 'large art' threshold is set to 1400 pixels, so images bigger than that are considered 'too big'. Artwork which is too small will often display in a blurry, washed out manner; artwork can also be huge without actually appearing any better for it: but at either end of the spectrum, you're in charge of declaring what 'too small' and 'too large' should mean.

For anything listed on this report, the fix is to re-acquire better album art and manually apply it to the FLACs in question (using a tool such as Semplice, for example).

4.2 Recordings with possible real volume boosts

There will be no items on this report unless you have first performed a special 'check for volume boosts' integrity check (see the Integrity Checks menu, Options 6 or 7). Performing such a check makes Niente scan the contents of each FLAC listed in your database for peak loudness levels (making it quite a slow process). This is over-simplifying to some extent, but at 0dB (decibels), a FLAC is considered to be as loud as it is possible to be without clipping or distortion. A FLAC whose peak loudness is measured to be -1dB is slightly quieter than that; one whose peak loudness is -8dB is very much quieter than that.

The configuration file (see the Administration menu, Option 1) allows you to specify a 'Threshold (dB) for volume boosts' parameter. By default, it's set to '2', meaning that if a FLAC is measured to have a peak loudness of (say) -1.5dB, though it's some way off being 'maximally loud' it's not crossed the -2dB threshold for being considered a 'problem'. A FLAC measured at -3dB peak loudness would appear on this report, however, because it's quieter than that the -2dB threshold:

In this example report, you'll see that one of my Alessandro Striggio choral works could be volume-boosted by a whopping 10.9 decibels, were I to use a tool like Semplice to do so. This does not mean that it's a good idea to actually perform that sort of volume boost: one organ recording I have in my collection has a peak volume some 19dB lower than its maximum possible loudness, but when you apply a volume boost to it, you quickly discover why: it was recorded in a cathedral that can be heard to be full of footsteps and people walking around! The recording engineer decided to produce the CD at its very quiet level precisely to hide that 'noise floor' under the more foreground sound of the organ. Apply a volume boost to it and that noise floor becomes so prominent that it's difficult to focus on anything but the noise! So, just because recordings are listed as boostable does not mean that they actually should be boosted! Making that sort of decision is why you have a pair of ears :)

You will note, too, that this report lists folders, not files. Whilst the 'check for volume boosts' integrity check does work out the peak volume in each individual file, this report aggregates and summarises by folder. It would, after all, be pointless to tell you that file 02-Dolce.flac could be boosted by 8dB if file 01-Furioso.flac already has a peak volume that is at the theoretical, non-distorting maximum: in such a scenario, you couldn't volume-boost just file 2 without completely screwing up the relative loudness between the two tracks. You also couldn't boost both files by 8dB, because that would make file 1 sound ghastly. Therefore, confronted with two files with these loudness values, Niente will leave the entire folder off the report: nothing in that folder can be boosted without either over-boosting file 1, or changing the relative volume between files 1 and 2.

Note that Niente is not itself going to alter the volume levels in any file. It merely reports on those recordings which a tool like Semplice, for example, would be able to boost the volume of, as a completely separate exercise. It is therefore entirely safe to perform a volume boost check and to report on the results: nothing is actually modified in your music files by performing either action.

Finally, recall that the persistent configuration file has a setting for 'Report on volume boosts', which is 'yes' by default, but could be set to 'no'. That parameter controls whether a count of possible volume boosts should appear in your aggregate statistics report. It does not stop you running this report, no matter what it's set to.

4.3 Recordings with missing ReplayGain

This report will list any FLAC file which does not possess a REPLAYGAIN_ALBUM_GAIN metadata tag. That tag data is collected as part of a routine full, differential or fast integrity check:

ReplayGain is an audio industry standard way of performing software volume boosts. Rather than adjusting the physical volume level of a FLAC, you can simply store a 'decibel boost' tag in the metadata for a FLAC. A suitable media player can read that tag and apply the required volume boost dynamically, in real time, without the data bits in the FLAC's audio stream ever being modified. Niente refers to this as being a 'metadata volume boost', because the degree of boost is entirely governed by the contents of the tag metadata found in a FLAC.

Niente is not computing this ReplayGain value for you: it is simply recording whether or not such a computation has been performed and written as a tag by another tool. Semplice, for example, will analyze a FLAC and compute a ReplayGain value for it; Niente is just checking that process has been performed by that sort of independent tool.

4.4 Files missing audio data in filenames

It's not compulsory, but it is sometimes quite helpful to have some indication of the technical audio qualities of a FLAC visible in the physical filename of the FLAC: whether it's a standard rip from a CD or a high-resolution rip from an SACD, for example, is something it's quite helpful to see made visible in your PC's standard file manager.

The two specific bits of audio data this report expects to find in a physical file's name are bit-depth and sample rate. A FLAC ripped from a standard audio CD can be expected to have been mastered at 16-bit and 44,100Hz, for example; one from an SACD might be 24-bit and 192,000Hz. A tool like Semplice will (if so configured) physically change a FLAC's filename to include this audio data: so you might end up with a FLAC called 01-Allegro-16-44100.flac, for example. This report then looks for files that don't have that sort of “hyphen-number-hyphen-number” component in their filenames:

Notice that the report is very specific about the format this audio data needs to take: that third row in the report, for example, does contain a bit-depth and sample rate, but they are fullstop (period) delimited, not hyphen-delimited and that doesn't count as far as Niente is concerned!

The fix for anything listed on this report is to manually change the physical filename by hand or, perhaps, to use a tool like Semplice to auto-adjust the filename for you. So long as the two bits of audio data end up in the filename in the correct format, a fresh integrity check will have Niente noticing that these filenames now do contain the required data.

You may have absolutely no interest in naming your music files in this way, of course, in which case this report is an irrelevance for you. You may then well want to take the Administration menu, Option 1 and set the 'Report filenames without bitdepth data' to a value of “no”. That will not stop you being able to run this report. It will, however, mean that the “O4” statistic will drop off the Aggregate Statistics report: the lack of audio data in filenames will not be an issue that Niente cares to report on.

4.5 Folders with multiple physical files

A symphony will usually consist of four movements: should a recording of a symphony come with four 'tracks'? In this writer's opinion, there's only one symphony, so there should only be one physical FLAC, containing within itself all four movements. Semplice can construct such 'SuperFLACs' by merging multiple per-track FLACs into a single per-composition FLAC. This report lists examples of where that has not happened: where, in other words, there are multiple FLACs in the same folder:

Here, for example, I would appear to have three FLACs in one folder, which I would consider a problem. Note that the ALBUM and ARTIST tags for the three FLACs would also have to be identical for the folder to appear on this report: if I had a Mozart symphony, a Beethoven Piano Concerto and a Britten opera all housed in the same folder, that would not be considered a problem (though I personally would regard that as extremely poor music collection curation!)

4.6 Possible duplicate recordings

When a FLAC file is first created, a 'digital fingerprint' of it, in the form of an MD5 hash value, is written into the very fabric of the FLAC itself. That hash value is calculated from the audio signal contained within the FLAC: it is therefore vanishly unlikely that two different FLACs will ever have the same hash value fingerprint. If they do, it is extremely probable that they are actually two copies of the same recording, regardless of the fact that their filenames, tags or other attributes might be very different:

I've had this sort of thing happen to me when I've catalogued something as 'Orchestral' then later wondered whether I had a copy of it and looked under 'Symphonic'. Assuming I don't have a copy, I then purchase the recording again and catalogue the new rip under 'Symphonic'. Despite the change in GENRE tag, the audio data doesn't lie and will probably turn into the same MD5 hash value for each… and, at that point, both recordings will appear on this report.

The 'fix' for anything appearing as a possible duplicate is first to listen to the recordings, then pick a “winner”: deletion of the duplicate off your hard disk (followed by an incremental database scan and a fresh differential integrity check) will see one of the recordings removed from the Niente database and thus off this report.

4.7 Display the operations log

Every time you ask Niente to create a database or perform an integrity check, it records the fact in its Operations Log. You can view this log at any time by taking Reports Menu Option 14. It is not a particularly exciting report and I doubt you'll ever really want to run it:

…but it's there if you want it and it can prove handy in reminding you the last time you did a full integrity check, for example: if it was a long time ago, it might be time to do a fresh one.

5.0 Conclusion

Running integrity checks of various types is certainly where Niente puts in the most work: but it's when you run reports that are driven off the database that's populated by integrity checks that Niente really becomes useful. The Quick Aggregate Summary should be your initial guide to what's going wrong with your music collection: use its various non-zero statistics to guide you to running the related reports which drill down to give your the specifics as to which FLACs are violating the rules, and how. A bunch of 'other reports' can then be used to view interesting information about your collection which maybe doesn't rise to the level of a physical or logical error as such, but may still be something you'd like to fix up anyway.

If you subscribe to this website's promoted ways to tag classical music, a bunch of tag-related reports will prove useful in making sure you stick to the 'rules'. If you don't, then there are still plenty of reports which you should find of use and interest.

nenruntime

Anonymous (anonymous@undisclosed.example.com) — 2025-11-11T11:49:56+00:00

Runtime Parameters

1.0 Introduction

Niente is, inevitably, a heavy-duty program to run that happens also to be extremely boring to watch running! It's job, after all, is to run off to your PC's hard disk and scan lots and lots of FLAC files, reading their multiple pieces of metadata and (during a full or differential integrity check, at least) re-computing MD5 hash sums for the audio signal they contain. It's tedious, quite slow and not at all exciting!

It is, accordingly, much more likely that you will want to schedule Niente to do its work in an unattended, non-interactive manner -and for that sort of thing, rather than navigating your way around Niente's (relatively!) attractive menuing program interface, you'll want to be able to give commands to schedulers such as cron to run things without you needing to be present. For that, Niente provides a set of eight run-time parameters (that is, arguments you can add to the basic 'niente' command), each of which can perform different functions.

Here are the available parameters, in table form:

Parameter	Purpose/Function	Menu Equivalent
--scan-full	Wipes the existing tracks from a database and then re-scans default music folder to re-populate it from scratch	Database → 2
--scan-new	Scans the default music folder for new or modified recordings and adds them to the existing database	Database → 3
--check-full	Performs a full integrity check (i.e., physical and logical checks for all recordings in the database)	Integrity Checks → 1
--check-differential	Performs a differential integrity check (i.e., physical & logical checks for recordings with previously-detected physical or logical corruption issues)	Integrity Checks → 2
--check-fast	Performs a fast integrity check (i.e., logical check only of recordings already known to the database)	Integrity Checks → 3
--check-art	Performs a new album art check for all recordings known to the database	Integrity Checks → 4
--check-volume	Performs a complete check of possible volume boosts for all recordings in the database	Integrity Checks → 6
--aggstats	Generates a quick aggregate statistics report and writes it to /tmp/nientestats.csv	Reporting → General → 1

You'll note that these parameters depend on what's configured in the persistent configuration file (Administration menu, Option 1) to determine (a) what database to refresh or check and (b) what music folder is to be used to locate new or modified recordings. Make sure you've configured appropriate values for the 'default music folder' and 'default music database name' parameters before using these run-time parameters, therefore.

The one standout peculiarity in these parameters is the last one: --aggstats. It's odd, because it generates a report (the Quick Aggregate Statistics one) …and reports are generally only useful if someone is around to read them. Its existence in this list of 'things to do unattended' would therefore seem to be a bit peculiar… and I confess it's there simply for the benefit of this website! You may know that my own listening habits are published on this site …and that, specifically, the Aggregate Statistics report lists the results of my latest Niente integrity check. I therefore need my dedicated Niente server to generate a Quick Aggregate Statistics report at around midnight each day in unattended mode (it's written out to the /tmp folder) and have that copied across to this site's web server. Niente doesn't handle the file copying (that's cron's job!), but at least the /tmp/nientestats.csv text file is there on disk, ready for the secure copy across the network when it finally kicks in. Incidentally, though the file's extension says it's a comma separated variable file, it is in fact a pipe-separated one: that is, the field separator is a | character, not a comma. It amounts to the same thing for processing purposes, regardless of the file extension, anyway!

2.0 Using Runtime Parameters

Run-time parameters are double-dashed keywords added to the basic 'niente' command. For example, if you wanted to schedule a nightly re-scan of your music folders, at 1 minute to midnight, to check if any new recordings had been added to the collection, you might add this to your crontab:

59 23 * * * /usr/bin/niente4.sh --scan-new

And if you wanted to do a full integrity check on the first day of each month at 1AM, you might make this crontab entry:

00 1 1 * * /usr/bin/niente4.sh --check-full

…and so on.

Note that the operations triggered by these unattended operations all set the PATH variable to PATH=/usr/local/bin:/usr/bin:/bin:$PATH, so if you are creating your own scripts to automate things, you shouldn't need to worry about setting the PATH variable yourself (which, of course, is usually not set correctly when crontab jobs are run outside of a defined user context).

You can, of course, use the run-time parameters direct from the command line: they aren't only to be used in a crontab, though that's where they make most sense. If you simply want to perform a fast integrity check without having to tap your way through a set of program menus, just type the command niente --check-fast and the task will run immediately. There won't be any program feedback, however: if the recordings scan or integrity check takes hours to complete, you'll simply be staring at a blank screen for that many hours. There'll be no indication of progress, in other words. You can, of course, add an ampersand to the command so that you at least get your terminal back as the operation runs in the background: niente --check-full & will perform a full integrity check but without tying up your terminal session for the duration (just press [Enter] twice after submitting that command to get your terminal back in foreground use whilst the job runs in the background).

Unattended operations will always leave a record of their start and completion times in the Operations Log (visible via the Administration menu, Option 6), so you can always verify that cron jobs are running correctly after the event by looking there.

If you are working with a NAS store of music, mounted via NFS or some other file sharing mechanism, be aware that running Niente in unattended mode carries risks: if, for example, your Niente machine is rebooted and, for whatever reason, the NAS music share is unavailable when it comes back up, your usual music folder will appear to be empty. Fire off a niente4.sh --scan-new operation at this point and your entire Niente database will be wiped, because all previously-existing music files will appear to have ceased to exist! That's obviously not a disaster, in the sense that you can always re-populate from scratch once the network drive is mounted properly… but it's a pain to have to re-compute all your integrity checks from scratch!

For this reason, when I schedule my Niente unattended operations in cron, I do so like this:

59 23 * * * /usr/bin/mountpoint -q /netmusic && /usr/bin/niente4.sh --scan-new
59 2 * * * /usr/bin/mountpoint -q /netmusic && /usr/bin/niente4.sh --check-differential

This simply runs the mountpoint command to ensure that “/netmusic” is actually a mounted file system and not an empty folder. It runs it silently (that's the -q switch at work) and only runs the Niente commands after the double-ampersand operator if the music folder is mounted properly. That saves inadvertent 'wipe-outs' of your complete Niente database!

| Back to Software Home | Back to Niente Documentation Home |

niente

Anonymous (anonymous@undisclosed.example.com) — 2025-11-06T14:37:26+00:00

Niente Version 4 : The FLAC Checker

User Manual Index

1.0 What is Niente?

Niente is a FLAC integrity checker for Linux, Windows 10 & 11 and Raspberry Pi.

You point it at a tree structure of folders full of FLACs and let it construct a database of what FLAC files exist. At any point after that initial folder scan, you can tell Niente to step through each file found in its database and analyse it for physical corruption and logical inconsistencies. After that, and at your leisure, you tell Niente to generate reports about the various sorts of corruption it has found.

Physical corruption is perhaps the most serious issue (caused by bit-rot and hard disk corruption) and is detected because during every analysis run, Niente computes a digital 'fingerprint' of the audio signal found in each file, storing the results in its database. Every subsequent analysis triggers the calculation of fresh audio fingerprints for each FLAC. Should the new fingerprint ever not match the previous one, you immediately know that some sort of physical corruption of the audio signal has taken place -at which point, you re-rip the original CD or revert to a known-good backup.

In addition to checking for physical corruption or degradation in this way, Niente will scan for various types of logical corruption or inconsistencies, as follows:

Is the YEAR (or DATE) tag completely empty?
If the YEAR tag contains data, is it consistent with what date is found in the ALBUM tag?
Is the PERFORMER tag completely empty?
If the PERFORMER tag contains data, does it match something found in the COMMENT tag?
Are there recordings which have under-sized (or non-square) embedded album art?
Are there recordings whose peak volume levels are significantly below what they could be (and thus could use a 'volume boost')?
Anything listed with these sorts of logical inconsistencies can be simply fixed up with a little bit of re-tagging or volume boosting (perhaps using my own Semplice program!)

Crucially, Niente will only ever perform these checks in a manner that doesn't alter the FLAC files themselves: files are only ever read from, never written to.

A large music collection can take a long time to analyse fully (my own 16,000+ FLACs take about 24 hours to scan on a 7 year old laptop, for example). Fortunately, Niente helps in this regard by allowing you to do 'partial analysis' as well as 'full analysis': partial runs only process the files which haven't already been processed or which haven't passed a previous analysis as being 'clean'. An infrequent full analysis can then be scheduled infrequently (say, once a month or so) to analyse from scratch every music file in your collection. Niente also offers a much quicker 'logical only' analysis, where it is allowed to perform its inter-tag consistency analysis without ever once worrying about whether your music files are physically corrupted: since it's only doing half the work, this is a much faster check altogether.

Though Niente can be run interactively using a simple-to-use menu interface, its file-scanning and integrity checking tasks can be automated as non-interactive, command line tasks: that time-consuming analysis of a large music collection can thus be scheduled to take place during the night or at other 'off-peak' hours.

2.0 The Name

If you are a classical music fan, you will probably already know that the musical term niente means “a gradual dying away of volume until …nothing” -and if you aren't, then: now you know!

The point of the name was to suggest that the ultimate goal for checking your FLACs for physical integrity and logical consistency is that you want a report that lists a bunch of zeroes: nothing in your music collection falls foul of the physical or logical tests. Additionally, the software itself should fade away from your notice until only a bare recollection of its existence is left: it's ideally to be left to run as a background task that you pay no attention to, unless problems are detected. Otherwise, it should just disappear from view!

physicalcorruption

Anonymous (anonymous@undisclosed.example.com) — 2025-11-05T20:29:45+00:00

Physical Corruption

1.0 What is Physical Corruption (aka Bit Rot)?

Computers store the data they need to process in RAM chips temporarily; and on hard disks (or solid state drives) more permanently. Every time your computer writes data to one of these forms of data storage, it can make a mistake. Even when it writes it correctly, the data at rest in any of these storage locations can change over time -the magnetic material of which a hard disk is made can physically degrade, for example; or a power-spike can affect the contents of data temporarily at rest on a RAM chip. Finally, even if your computer writes the data correctly; and even if it is stored immutably in or on its storage medium; the computer can mis-read the data when it next needs to access it: the charge levels of the electrons in solid state drive might have dropped below what can reliably be read, or the hard disk might simply mis-read a tiny magnetic 1 as a 0, given the enormous data densities and high speeds of modern hard disks.

In short: whether the data degrades because of mechanical or material failures, or because power grids occasionally supply electricity at voltages and frequencies outside their normal range, or simply because (and it is has happened!) a cosmic ray happens to strike a storage device at the wrong time and in the wrong place …your digital data may not always remain in the state you want it to be in. That's called bit rot in the computer industry and for anyone listening to classical music stored in digital form, its practical consequences can range anywhere between “wouldn't have known” and “glitching like old scratched CDs used to when they were having a fit”.

Digital music collections, therefore, need protecting against bit rot. Niente has a part to play in detecting bit rot if it happens, but it can never fix it if it finds it. Prevention is therefore miles better than the cure -and I thought I'd briefly discuss here how to prevent bit rot from happening in the first place.

2.0 Bit Rot Prevention - Physical

To prevent bit rot, as much as possible, you want to be using reliable computer kit in a controlled environment. By this I mean, try not to stick your music storage devices in lofts that alternately freeze in Winter and cook in Summer (guilty as charged, though: sometimes you have no choice in such things!). Keep your computers in as dust-free an environment as you can possibly make it. If at all possible, run your computers from Uninterruptible Power Supplies (otherwise known as batteries!), as these will have current surge protections built-in: if your domestic electricity supply fails completely, a good UPS can shut your servers down gracefully, so they don't just crash; and if your power supply is 'dirty', having lots of spikes and surges, the battery features of a UPS can smooth those fluctuations out. Incidentally, this is why an old laptop can make quite a good music server: the batteries that make laptops portable can also prove useful in cleaning up questionable power supplies. If your budget won't spring for a full-featured UPS, at the very least invest in one of those multi-socket power extenders that provide some element of surge protection.

Next on the prevention list: if at all possible, use ECC RAM for your computer's physical memory. ECC stands for 'Error Correcting Code' and RAM that is ECC capable use nine chips rather than standard RAM's eight. The extra chip is used to store “parity” data that can be used to reconstruct the 'real' data, if part of it goes wrong. Imagine you wanted to store the numbers '2' and '3' in RAM: on conventional RAM, the 2 would be stored in one piece of RAM, the 3 in another. In ECC RAM, as well as storing the 2 and the 3, we also store a '1' on the extra parity chip. Why? Because if a cosmic ray wiped out the 2, but left the 3, I could take the 3, minus the 1, and reconstruct the 2: I get 3 and 2 back again. Or, if I lost the 3, I could take the 2 and add the 1, reconstructing the 3. That explanation is embarrassingly simplified, I hasten to add! But the principle is true: if I construct 'extra' data from the data you actually want to store, I can later use that extra data to reconstruct any real data that happens to go missing or get corrupted. ECC memory, therefore, helps prevents bit rot happening whilst data is temporarily at rest in your computer's working memory. Technically, ECC RAM can detect and correct 'single bit memory errors', thereby preventing already-corrupted-in-memory data from being written to disk.

ECC RAM is slightly more expensive than ordinary RAM and not every CPU or motherboard can use it. In particular, Intel is notorious for actively preventing their consumer CPUs (things like i7, i5 and i3 chips, for example) from making use of it, though AMD's Ryzen chips are frequently said to be able to use it effectively, even when AMD don't officially endorse its use. Intel server and workstation chips (so, Xeons) usually do support the use of ECC RAM -and I would therefore encourage you to buy computer hardware which uses Xeons or Ryzen chips to use for your digital music storage server(s). An old server that uses a 2011-ish vintage Xeon can be purchased very cheaply these days:

The Xeon E5-2407 was released in 2012, so we are talking pretty ancient by now… but it has more than enough power to run a storage server and it supports the use of ECC memory, so will physically help keep your music in pristine, non-rotting fashion! If your preferred storage server is a more modern, prebuilt device like a QNAP or a Synology NAS, be aware that the 2- and 4-disk consumer appliances tend not to support ECC RAM, but the higher-end 8-disk units do. Shop around and prefer ECC-capable models, if you and your wallet can stretch to it, anyway.

3.0 Bit Rot Prevention - Software

If you are not a computer-ese guru, the next bit of bit-rot prevention advice is likely to sound like complete gobbledygook, I realise. I can only urge you to try to get on top of this particular subject matter, however, because the longevity of your music collection really depends on it!

ECC RAM will help ensure that what your computer writes to disk is in good order. Once it has been written to disk (or SSD), though, it can degrade over time, for the reasons outlined previously -and ECC RAM cannot help you detect that. Similarly, pristine data that sits on a hard disk which simply and completely mechanically fails is pristinely lost: no amount of ECC RAM is going to be able to walk you back from that particular form of catastrophe!

What you need, therefore, is a bit-rot-detecting file system that your operating system can rely on to do hard disk bit-rot detection and hard disk failure recovery. For Linux and *BSD users, this is not a difficult requirement to meet: the ZFS file system has built-in bit-rot and hard disk failure detection and healing capabilities when used in a multi-disk storage array and it will work fine on Linux, even though its licence is technically incompatible with Linux's own GPLv2. An alternative to ZFS is Btrfs, whose licence is fully compatible with Linux's, but whose tendency to lose data in certain multi-disk setups means I can't recommend it. Plenty of people do use it for its bit-rot protection, nonetheless.

The underlying principle of ZFS is that it does to data on a file system what ECC memory does to RAM chips: it writes extra data that it can use to re-construct data it detects to have been corrupted or lost. Using the previous example: I write 2 and 3 to the hard disk; ZFS writes a 1 on another part of the storage array. If a cosmic ray strikes the hard disk platter and alters the 3 into being a 9, then ZFS will be able to detect the error, since the surviving 2, plus the extra 1, doesn't equal the 9 also found on the hard disk. Having detected the error, ZFS can then correct it, because it knows that the 9 should actually be equal to 2+1, and therefore can over-write it with a replacement for the lost 3. To get this sort of error detection and correction going, you simply schedule regular 'scrubs' of your ZFS storage 'pools'.

I won't go into too much more detail about all this here, other than to summarise by saying: you should store your digital music collection on a ZFS file system that writes to at least 2 physical hard disks, preferably 4. Personally, I use a zpool which is configured as a 'mirrored stripe': that is, I put two hard disks into a state where one mirrors the contents of the other. If one disk fails, a good copy of the data is still available from the surviving disk. Two more hard disks are then put into a second mirror, with the same result. Finally, both mirrors are put into a single 'stripe', so that a chunk of data is written not to one or the other, but to both mirror pairs, spread out across them. The net result is that I can have two hard disks mechanically fail -and still be able to recover all my data. The cost is that if my storage array uses four 4TB hard disks (so, 16TB raw storage in all), I end up creating two 4TB mirrors and then striping across both… meaning that I've only got 8TB of usable storage, not 16TB. Effectively, I lose two hard disks to 'data redundancy': two disks are effectively there to protect your data, rather than store it by themselves.

There is another 'cost' to this approach, however: you will have to not use Windows on your storage server, because ZFS does not yet reliably work on Windows (though development efforts continue) and Windows itself has no equivalent 'self-healing' file system. Technically, the ReFS file system was supposed to be usable in this sort of way, but Microsoft has mucked about with it since it was first released in such a way as to make it look like abandonware at this stage. I wouldn't want to store anything I care about on an ReFS file system, anyway! Whilst it's only your storage server that needs to be running Linux or *BSD, leaving your PC free to continue to enjoy the delights of Windows 11, it does mean you need to learn how to set up a Linux or *BSD server of some sort. A relatively simple way to dip your toes in those waters is to experiment with setting up a TrueNAS or OpenMediaVault server (both involve installing an operating system which is more of a 'software appliance', making things quite easy to administer: both are completely free of charge to obtain and use, too).

4.0 Bit Rot Prevention - Duplication and Backup

In my (all too brief and over-simplified) explanation of ZFS, I explained how my own personal music server can survive the loss (or corruption) of two hard disks. This is true: but it won't help if I suffer corruption or loss on three of my four hard disks! In other words, whilst ZFS is a powerful way of detecting and fixing limited data corruption and loss, it can't fix everything.

For that sort of capability, you need to make whole copies of your data, from your 'true server' to a duplicate server.

In my own setup, for example, I have a 4-disk server running ZFS duplicating to another 4-disk server, also running ZFS. If one server bites the dust, my music collection remains safe on the other. ZFS has a duplicating capability built-in, so no other software is really required. However, I choose to script my duplication runs using rsync software -other products are available which can achieve the same sort of results. The details of how you duplicate your music collection are not as important as the fact that you should duplicate it.

As it happens, I'd go one step further and recommend a third duplicate onto a third server. My third server only runs 4x2TB hard disks in a stripe: if I lose a single hard disk, I lose the entire array. So it's not a robust duplicate, but it's there as a fallback of last resort. Two other servers have to suffer fairly catastrophic failures before I need to rely on this third duplicate one, so it's a risk I'm prepared to take (and which my wallet wasn't prepared to properly mitigate!)

Finally, follow the 3-2-1 rule. That is, have (at least) three copies of your data; two of them on-site, but on different physical media; one of them off-site. I certainly meet the first two of those requirements: I have the 'source' music collection, a duplicate copy on a second server, and a third copy on a slightly-risky third server. So, I have two backups, plus the originals, at home, on different disks and different disk configurations. However, if my house burns down, it takes all three sets of my music with it, resulting in me having no more music! To meet the '1' part of the 3-2-1 rule, therefore, I continually backup my third server to 'The Cloud', in the form of a cheap, unlimited data plan with Backblaze. For US$99 a year (at the time of writing in 2025), I can store as much data with them as I need to, on the other side of the world, which should come in handy should my house ever be destroyed by flood, fire or hurricane. Should I need my data restored from them at any point, they will ship it to you on a hard disk, which you can return to them once you've copied it onto your own storage …and thus not pay for.

One drawback with Backblaze's 'personal' plans is: they only work when the source of the data is a Windows PC. So, I have a fourth computer in my loft, pulling data from my third server, running Windows 10. If the prospect of running Windows fills you with as much dread as it did me, you could always spring for one of Backblaze's more 'professional' products: their 'B2 Cloud Storage' product appears to cost $6 per TB per month at the time of writing, for example, and permits backups from anything that can run the right client tools, including Linux boxes.

If the cost of backups in the cloud puts you off, then at least spring for a USB hard drive onto which you take periodic backups -and then store that hard drive with a trusted neighbour or relative.

One final but related point to mention here, though it possibly descends to the depths of complete data paranoia: I have a fourth server in the house which I only power on the first day of each month, and which then pulls an exact copy of the data from the third server before immediately shutting itself down. The reason for yet another in-house copy of the data is that it's offline for most of the time, whereas the other three servers (plus the Windows PC) are permanently running. If my other half's resolutely Windows PC was ever to pick up a piece of crypto ransomware, for example, then it's possible that would start encrypting data right across the home network -including on all three storage servers. No cryptoware can damage data that's not accessible because its host server is powered off, though! That USB drive you trusted your neighbour to store for you? That counts as offline storage, too, as well as being off-site… so do that sort of thing, too!🙂

5.0 Niente's Purpose

Summing up so far, therefore: if you run your storage hardware in clean, controlled conditions; if you provide a relatively stable and clean power supply to it; if you use ECC RAM to prevent bit-flips in memory; if you use the ZFS file system across multiple hard disks; if you duplicate your data onto separate storage, also configured with ZFS across multiple hard disks; if you ensure that you copy your data off-site, at least periodically; and if you finally ensure that at least one copy of your data is not permanently accessible over your home network… then you are unlikely ever to suffer from bit rot, corruption, data losses caused by hard disk failures and so on.

In which case, the question arises: what's the point of Niente, then?!

I'll answer that in two ways. First, and most simply, Niente doesn't just check for the presence of physical corruption. It does logical inconsistency checking too, so it does things which ECC RAM, ZFS file systems and a thousand backups could never detect or resolve! ZFS is not going to know that if 'Fred Smith' is listed as the performer on a recording, he ought to be listed in the COMMENT tag, too, for example.

But the second part of my answer is that FLACs are written by software and that software can itself go wrong over time. A FLAC could degrade internally, for example, by you re-tagging the list of performers stored in the COMMENT tag. The software used to do that tagging might not be entirely clean in the way it writes back to the FLAC, and might cause internal corruption to the audio signal it contains which wouldn't appear to count as physical 'bit rot' from the point of view of ZFS or ECC RAM. It's not supposed to do that, of course… but software can contain bugs, so what's supposed to happen and what actually happens can quite often be two different things!

If you are doing everything 'right' as far as computer memory, robust file systems and multiple copies and backups of your data… there is nevertheless purpose in periodically running a Niente integrity check against your music collection, in order to detect such 'software errors' and to give you a chance to correct them (by restoring good copies of the affected files from all those duplicate and backup copies, of course!).

6.0 Niente's Functionality

6.1 General Principles

In case you haven't met this particular aspect of computing before, let's start axiomatically: it is possible to apply a mathematical function to any piece of data and thereby derive a single, unique 'hash value' for that data. The hash value cannot (usually) be converted back into the data itself, but the same data subject to the same mathematical function at a later date should return the same hash value, so that there is a one-to-one correspondence between the data and its hash value.

By way of example, let's take the phrase “This is some data!” and pass it through a particular mathematical function to generate what's called the MD5 hash. This is easy to do on most operating systems, at the command line:

Here we see that the phrase 'encodes' to a long string of letters and digits, starting “e914b8466…”. If I ask for a new MD5 hash for that same data, I should always get the same result:

A key feature of the MD5 hash function, however, is that if you change the input data by even a tiny amount, the resulting hash will likely be wildly different from the original:

Here, you see me remove the final exclamation mark from the input phrase. So the phrase is now just one character different from before… but the resulting MD5 hash is nowhere close to the original. Now it starts “4b4cbba68adce2d…” and is therefore detectably different from the original hash in almost every place.

Hashes don't just have to be generated from text strings, though: any data can be fed to the MD5 hashing function and return an MD5 hash, including FLAC files:

Here, you see me first checking that a FLAC exists in my Desktop folder and then passing that entire FLAC through the MD5 function, to once more return a simple hash value, this time one beginning 'e97d…'. Were I to change one bit within that FLAC, the entire hash value would change. Let me demonstrate that for you now.

First, I'll open that same FLAC file in a hexadecimal editor (that's just an editor which can alter the contents of binary files, just as Word or Notepad can alter the contents of text files):

Being binary data, it looks complete gibberish, of course. Let me alter one small piece of this data, though:

If you compare that screenshot to the previous one, you'll notice only a single change to the binary data: a “4F” has become a “6F” on line 00000168. In plain English, that weird technical change has changed the word 'PERFORMER=' to 'PERFoRMER='. A tiny change, therefore. So now let's see what that one change has made to the MD5 hash value for this FLAC file:

Now we are getting “4ac0c7c0c78ce0a83430bf36ce8fd92f” where before we had “e97d860551bc33ab9e7009259ecf69d0”: one tiny change in the source data results in a huge change in the MD5 hash value, therefore.

We can work this in reverse, too, of course: if we keep getting the same MD5 hash as we got before, we can conclude with absolute certainty that no alteration to the underlying data can possibly have taken place. But if we ever see a change in the MD5 hash value, we know with equal certainty that, to one extent or another, the data we now have is not the same data we had originally. This is the underlying principle of the way Niente performs a physical integrity check of your FLAC files. Every time you ask it to perform a full or differential integrity check, Niente computes a new MD5 hash value for the FLAC files it's interested in and stores it in its database. It can then compare that new MD5 hash value to the one it had before: if they are different, the FLAC file has changed internally (for whatever reason, and to whatever extent, Niente cannot know) and that needs looking into.

6.2 Nuances

I pause at this point to explain a subtlety: a FLAC file contains more than just music! The FLAC can (and should, in my view) contain embedded album artwork, various metadata tag information telling us who the composer is, who is performing and what they're performing, for example. This tag data is usually supplied by you, typing it in (using a tool such as Semplice)… and with the best will in the world, you're going to make mistakes from time to time when typing it in. You'll therefore want to go back and correct such tag-typos… and at that point, you'll be modifying the internal contents of the FLAC file as a whole.

If Niente did what I just did in Section 6.1 above and calculated an MD5 hash value for the entire FLAC as a whole, therefore, all such tag amendments would trigger a change in the hash value… and Niente would forever be declaring the file potentially corrupt, despite the change being perfectly legitimate.

Fortunately, FLAC files store their internal bits and pieces in distinct 'blocks'. Album art is stored within a picture block, for example; tag data is stored within multiple 'vorbis comment' data blocks. Crucially, the audio bit of a FLAC (the bit we really care about, I suppose!) is stored within its own 'stream block'. Niente therefore applies the MD5 hash algorithm only to the audio stream part of the file. You can therefore modify metadata tags and add and remove album artwork until the cows come home -and Niente will not regard any such changes as being a sign of internal corruption. Only if the audio data part of the FLAC changes will the MD5 hash value change -and that can only happen if some sort of 'bit rot' is affecting that part of the file inappropriately (as might occur if, for example, a tagging program you use doesn't understand how to write back to FLACs properly).

Another subtlety I'll mention at this point is that when any FLAC file is first created, an MD5 hash value is computed for the audio stream component of the file and stored within the file itself, entirely automatically and without your knowledge or express permission. All FLAC encoders that meet the FLAC specifications should do this. This means that there's an MD5 hash we can compare to from the moment a FLAC file is created. You can see this 'native' MD5 hash by exposing it using the metaflac tool (that's included whenever you install the FLAC encoding/decoding software):

In this screenshot, we see I have a new FLAC file. I first use metaflac to expose its 'internal, original MD5' hash value: metaflac returns a value of a476c66b3f4d9b2273b403ca1e90e120. I then use the md5sum program to compute my own MD5: I get aa14fca10894ce55e91ea186993aa54f. Oh no: they're different! But, hang on… we expect them to be different: metaflac's result is the MD5 hash for only the audio component of the file. The value being returned by the md5sum program is the 'fingerprint' of that audio signal plus all the metadata and album art. They are naturally and inevitably not the same data, so the hashes won't agree.

Fortunately, Niente is fully aware of this. It certainly reads the 'internal, original MD5' that was embedded within the FLAC at the moment of its creation. When it computes a new MD5 hash value, however, it does so by using methods which are a good deal subtler than what md5sum is capable of! It thus computes the audio-only MD5 hash value, which can legitimately be compared to the 'birth MD5' value.

6.3 When are new hashes computed?

Once you run Niente for the first time, you are probably first going to take the Database menu, 1: Create a music database option. This will trigger Niente to create a brand new database (the name of which is prompted for, or read from the persistent configuration file). Creating a database structure is a matter of mere tenths of a second however: it takes practically no time at all, because the database immediately after creation contains no actual usable data at all. So that option automatically and without further involvement from you immediately goes on to run off to your PC's hard disk (the specific location is again defined in the persistent configuration file) to scan it for any FLAC files that are stored there. If it finds any, it records details of their path and filename inside its database. Niente at that point therefore knows what FLAC files exist …but it does not compute nor create any MD5 hash information (or indeed any other internal information) about those FLACs at this stage.

Only when you take the Integrity Checks menu, Options 1, 2 or 3 does Niente set to work to read the FLACs it knows about and derive information from them. Option 3 is called a 'fast' integrity check because it doesn't spend its time computing MD5 hashes at all, though: its job is to determine the logical consistency of the FLAC files' internal metadata tags. So, only Options 1 and 2 will actually compute fresh MD5 hashes for each FLAC known about. Option 1 computes it for every single FLAC in the database; Option 2 computes it only for those FLACs which, from previous checks, are known to have had logical or physical integrity issues, or which don't appear to have ever had MD5 hashes computed beforehand (meaning, this FLAC has only just been added to the database). If a previous full check told you a file was physically corrupt, for example, you might restore it from a backup; you'd then run a differential check to have that one replacement FLAC re-checked in moments, rather than re-work your entire music collection for hours on end.

7.0 Conclusion

In this article, I hope to have at least hinted at the need for 'defence in depth' when it comes to protecting a digital music collection from catastrophic, physical corruption. It starts with running your servers in clean conditions, with clean power supplies. It extends to using proper server-grade machines which can make use of ECC memory. It also involves storing your music on multiple multi-disk arrays using a bit rot-proof file system, such as ZFS -rather than bunging it on a single USB drive using NTFS and hoping for the best!

If your hardware foundations are sound, then most of Niente's functionality regarding the detection of unexpected physical alteration of the audio stream in your FLAC files is rendered a bit redundant. But not everyone will be using ECC RAM; Windows users may not want to be messing around with Linux and ZFS; software meant to help you tag your FLACs might end up accidentally messing with the audio stream itself because of bugs… and so, even in an ideal hardware and filesystem environment, there is still a purpose to scheduling nightly Niente differential integrity checks and monthly (or maybe fortnightly: it depends on your backup strategy and the size of your music collection, really) full integrity checks.

| Back to Software Home | Back to Niente Documentation Home |