Translation(s): English - Français - 한국어
TypeTool 3 is our basic font editor for Windows (and for macOS up to 10.14 Mojave). It is the little sibling to FontLab Studio 5, so it has most of the same tools, plus the same interface used to create most of the world’s commercial fonts. Bitmap Font Writer 1.3 Stefan Pettersson Font Tools. Download; Screenshot; Bitmap Font Writer is a tool that will let you work with bitmapped fonts. Instead of using copy/paste in your paint program to combine characters into words, this program automatically generate text for buttons etc with your bitmap font. Like most bitmap font creators, it is of course graphics API independent because it simply exports an image (and an easy to read data structure). However, implementing your own text-rendering system, in OpenGL or Direct3D, is not too difficult-render a quad for each letter and apply the bitmap font texture with appropriate coordinates.
Contents
- Adding fonts
- Font lists
- Bugs
- Font design and formats
- Further Resources
- Other links
Adding fonts
Packages
Fonts can be added system-wide to Debian by installing the appropriate package; fonts are specified in the “Fonts” section. As default system-wide fonts will be installed into /usr/share/fonts by the package-manager.
Notes:
For most uses, you’ll want TrueType (TTF) and OpenType (OTF) fonts – these packages start with fonts-.
- Some fonts might have a -variable build, which are known as (VF), variable font.
Some non-free font downloader packages are in contrib, which you will need to add to your sources if not present.
Manually
Install a font manually by downloading the appropriate .ttf or otf files and placing them into /usr/local/share/fonts (system-wide), ~/.local/share/fonts (user-specific) or ~/.fonts (user-specific). These files should have the permission 644 (-rw-r--r--), otherwise they may not be usable.
Run fc-cache to update the font cache (add -v for verbose output). The above mentioned paths can be customized in the fontconfig configuration file at /etc/fonts/fonts.conf – you can also include subdirectories or links, which is useful if you have a directory of fonts on a separate hard drive (or partition or other location).
If you are installing bit map fonts you might need to enable this with dpkg-reconfigure:
Then enable bit maps font in the third screen.
GNOME users can simply open a Nautilus window to fonts:// and drag&drop the font files in there.
You can verify the fonts are present by looking for them in an application (such as a word processor), or by using the command fc-list. A python based graphical utility, font-manager, is also available to preview all installed and available fonts.
Configuration
fontconfig is the underlying configuration tool; you may find the following programs useful:
fc-list – lists fonts
fc-match -s helvetica – show an ordered list of fonts matching a certain name or pattern
fc-cache -fv – rebuilds cached list of fonts (in ~/.config/fontconfig, older caches may also be in ~/.fontconfig)
To view a list of monospaced client-side fonts (available from Xft, so it is possible to apply font hinting and antialiasing):
To view a list of server-side (available directly from X server, so font hinting and antialiasing are not available) monospaced fonts:
You may also find the following useful to change the default font rendering:
Font lists
The page http://www.miriamruiz.es/debfonts/ displays the fonts contained in some packages, but the list of packages and fonts isn't updated any more.
The Debian Fonts Reviewserviceneeds to be revived.
The Free Font Compilation is is also no longer updated.
Various libre fonts are missing from Debian and need to be packaged.
Commonly Used Fonts
The fonts-liberation package supplies fonts with the same metrics as Times, Arial and Courier. These fonts are named Liberation and are present in most cases. If you require the non-free original Microsoft fonts the ttf-mscorefonts-installer package (in contrib) can be used to obtain them.
East Asian fonts: fonts-arphic-umingfonts-wqy-zenheifonts-sazanami-minchofonts-sazanami-gothicfonts-unfonts-core
(from Wikipedia: Help:Multilingual support (East Asian))
If you want to use non-free fonts like Calibri which originate from Microsoft Office, you can download and install them (gratis) from the Microsoft Powerpoint Viewer.
Screenshots of Fonts in Debian
With: http://screenshots.debian.net/packages?search=fonts-&show=with
Without: http://screenshots.debian.net/packages?search=fonts-&show=without
Troubleshooting
If fonts do not display properly, you may want to make sure the right font gets loaded, for example with:
If it doesn't, you may want to regenerate the caches with:
You can also run this as a user with fc-cache -fv.
Otherwise, you can also look at the font in a viewer like font-manager.
Individual font rendering can be tested directly with the ftview program available in the freetype2-demos package. For example, here is how to show sample glyphs from the Liberation Mono font using the 3.5 and 4.0 rendering engines:
This was quite useful to diagnose changes in the engine after the Debian buster upgrade, described in 866685.
Bugs
Usertags
The fonts team will use these tags for usertags (user: pkg-fonts-devel@lists.alioth.debian.org)
non-free: for packages that contain non-free fonts taken from the web (severity serious)
license-violation: for packages that contain fonts that are GPL/LGPL but do not distribute source (severity serious)
rfn-violation: for packages that contain OFL fonts with a Reserved Font Name that have not been renamed or have lost the upstream RFN notice (severity serious)
?contrib: for packages that contain free fonts that cannot be built with free tools (severity serious)
duplicate: for packages that contain fonts that duplicate fonts from other packages (severity normal?minor?wishlist?)
- split: for packages that contain fonts we would like to see split into other packages (severity wishlist)
fontconfig: for packages that should switch to dynamically looking up font paths using fontconfig (severity wishlist)
- render: for packages that should switch to a font renderer that automatically uses the right fonts (severity wishlist)
Font design and formats
Source Font Formats
SFD (Spline Font Database, ?FontForge's ASCII file format for vector fonts)
UFO (Unified Font Object)
Glyphs (proprietary format of Glyphs)
Generating Fonts from Source
The upstream build system should always be used for generating fonts. If upstream does not have a build system, then it is a good idea to contribute one to them based on the following Free Software tools.
The fontforge is an editor for outline and bitmap fonts that generates all kinds of fonts. It is also scriptable and has an addon tool xgridfit for hinting. Fonts using these tools can be found using these commands:
Maybe this is more useful to find packages that build from source with fontforge or fontmake (will not work with multi-line Build-Depends):
There is also birdfont and ttfautohint and fontmake
Output Font Formats
ttf, otf, bdf, pfb, fnt, woff
Font Tools
Tool | Debian package | Comments |
Convert BDF bitmap font to vector format (fontfourge source) | ||
Programs for font conversion, testing, and other manipulation. | ||
fttools | ||
tools for ?OpenType, multiple-master, and Type 1 fonts | ||
freetype1-tools | ||
Font converter from TrueType to Adobe Type1. | ||
Command line utility that generates BDF bitmap fonts from ?OpenType fonts. | ||
A Python library to open and manipulate OTF and TTF files. | ||
Python program to show and compare fonts | ||
Simple interface to show a preview of all fonts installed |
There are several font tools which are not included in Debian, but are used to produce fonts included in Debian:
Available in Debian although not yet in stable. |
Someone is working on inclusion into Debian. |
Someone requested inclusion into Debian. |
Someone needs to file an RFP or ITP bugreport and update this page with resulting bug number. |
Was available in Debian but is not part of stable or unstable. |
Tool | Comments |
Font specimen generator, inspired by Wikipedia version | |
AppStream metadata generator for fonts (pregenerated fonts- entries) (a dh_font deb helper script should be made) this is good if you want the fonts to appear in the gnome/kde app stores |
Further Resources
Reference manual
Wiki pages
* tahoma
Other links
Salsa Group 'Team Fonts'
Chinese fonts in Debian - a blog post
Fedora fonts information
Arch Linux fonts documentation
Outdated
Old, retained for historical interest and reference:
Debian Fonts Task Force
TrueType Fonts in Debian mini-HOWTO – 2000 FAQ by Bear Giles
Debian Font Guide, Rob Weir
Repost from my tumblr: http://purplelilgirl.tumblr.com/
Related to this post: Tutorial: The first step to making a ‘Talking’ iPhone app, chipmunkifying your voice!
There are dozens of “Talking” apps on the iPhone app store, as I’ve mentioned before. Basically what those apps do is, you say something, and then the animal will repeat it, in this chipmunk like voice. But even they are different apps, and they are certainly different animals (hippo, bird, cat, giraffe, duh), some of them share the same voices! Why does that adorable hippo sound like the cat?!
The solution I posted in my previous blog is simply use CocosDenshion to manipulate the recorded voice (your voice), to a higher or lower pitch to produce the voice of the animal (chipmunk). But the flaw of tha solution is that if you change the pitch, you are also changing the speed. So if you lower the pitch, you get this really low voice that is being played really sloooow.
And I don’t want that I want to change the pitch but not change the speed. So I need a different solution. And the solution is Dirac3.
According to its website:
DIRAC redefines the limits of what todays’ technology can do for your application if you want to change the speed and pitch of music independently without sacrificing quality. Used by leading hi-end audio processing applications and custom built solutions in studios around the world, DIRAC is our critically acclaimed time stretching and pitch shifting technology that can be applied both musically monophonic and polyphonic signals with equal ease and success. Its straightforward API makes it an ideal tool for any software project that requires time stretching and pitch shifting.
Basically Dirac allows you to change the pitch of your audio, without speeding it up or slowing it down.
Dirac 3 has a free version, called Dirac LE, which you can simply download from their website: http://dirac.dspdimension.com/files/DIRAC3LE.zip Dirac LE is also available iPhone/iPad ARM 6 and 7 compliant (Xcode, iOS 3.2+ and iOS4+).
Okay, download Dirac LE, and then let’s get started (oh, I am setting up mine as I write this blog post, as well).
According to the “iPhone ReadMe (or suffer).rtf” that came with the zip file, we need to include the vecLib/Accelerate frameworks to your project. Go to Frameworks, right click, add Existing Frameworks, and then look for “Accelerate.framework”, add. Oh, and any file that will contain Dirac calls need to be .mm, instead of .m.
And then Add Exsiting Files, add “Dirac.h” and “libDIRAC_iOS4-fat.a” to your project.
I will be using the Time Stretching Example as my guide, (it’s also in the zip file). Oh, the zip file also contains a 32 page pdf file explaining Dirac.
From the Time Stretching Example, copy the files in ExtAudioFile folder, EAFRead.h, EAFRead.mm, EAFWrite.h, EAFWrite.mm. These are the files Dirac will use to read and write audio files.
And then we create a new file, I’m calling it AudioProcessor.mm, take note it’s .mm, because it will be calling Dirac. And basically I just copy pasted most of the code from iPhoneTestAppDelegate of the example. (Guilty for being a copy paster coder).
And then edit some stuff, so AudioProcessor.h:
#import <Foundation/Foundation.h>
#import “EAFRead.h”
#import “EAFWrite.h”
@interface AudioProcessor : NSObject <AVAudioPlayerDelegate>
{ AVAudioPlayer *player;
float percent;
NSURL *inUrl;
NSURL *outUrl;
EAFRead *reader;
EAFWrite *writer;
}
@property (readonly) EAFRead *reader;
@end
And then edit some more stuff, AudioProcessor.mm:
#include “Dirac.h”
#include <stdio.h>
#include <sys/time.h>
#import <AVFoundation/AVAudioPlayer.h>
#import <AVFoundation/AVFoundation.h>
#import “AudioProcessor.h”
#import “EAFRead.h”
#import “EAFWrite.h”
double gExecTimeTotal = 0.;
void DeallocateAudioBuffer(float **audio, int numChannels)
{
if (!audio) return;
for (long v = 0; v < numChannels; v++) {
if (audio[v]) {
free(audio[v]);
audio[v] = NULL;
}
}
free(audio);
audio = NULL;
}
float **AllocateAudioBuffer(int numChannels, int numFrames)
{
// Allocate buffer for output
float **audio = (float**)malloc(numChannels*sizeof(float*));
if (!audio) return NULL;
memset(audio, 0, numChannels*sizeof(float*));
for (long v = 0; v < numChannels; v++) {
audio[v] = (float*)malloc(numFrames*sizeof(float));
if (!audio[v]) {
DeallocateAudioBuffer(audio, numChannels);
return NULL;
}
else memset(audio[v], 0, numFrames*sizeof(float));
}
return audio;
}
/*
This is the callback function that supplies data from the input stream/file whenever needed.
It should be implemented in your software by a routine that gets data from the input/buffers.
The read requests are *always* consecutive, ie. the routine will never have to supply data out
of order.
*/
long myReadData(float **chdata, long numFrames, void *userData)
{
// The userData parameter can be used to pass information about the caller (for example, “self”) to
// the callback so it can manage its audio streams.
if (!chdata) return 0;
AudioProcessor *Self = (AudioProcessor*)userData;
if (!Self) return 0;
// we want to exclude the time it takes to read in the data from disk or memory, so we stop the clock until
// we’ve read in the requested amount of data
gExecTimeTotal += DiracClockTimeSeconds();
// ……………………….. stop timer ……………………………………
OSStatus err = [Self.reader readFloatsConsecutive:numFrames intoArray:chdata];
DiracStartClock();
// ……………………….. start timer ……………………………………
return err;
}
@implementation AudioProcessor
@synthesize reader;
-(void)playOnMainThread:(id)param
{
NSError *error = nil;
player = [[AVAudioPlayer alloc] initWithContentsOfURL:outUrl error:&error];
if (error)
NSLog(@”AVAudioPlayer error %@, %@”, error, [error userInfo]);
player.delegate = self;
[player play];
}
-(void)processThread:(id)param
{
NSLog(@”processThread”);
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
long numChannels = 1; // DIRAC LE allows mono only
float sampleRate = 44100.;
// open input file
[reader openFileForRead:inUrl sr:sampleRate channels:numChannels];
// create output file (overwrite if exists)
[writer openFileForWrite:outUrl sr:sampleRate channels:numChannels wordLength:16 type:kAudioFileAIFFType];
// DIRAC parameters
// Here we set our time an pitch manipulation values
float time = 1.0;
float pitch = 1.0;
float formant = 1.0;
// First we set up DIRAC to process numChannels of audio at 44.1kHz
// N.b.: The fastest option is kDiracLambdaPreview / kDiracQualityPreview, best is kDiracLambda3, kDiracQualityBest
// The probably best *default* option for general purpose signals is kDiracLambda3 / kDiracQualityGood
void *dirac = DiracCreate(kDiracLambdaPreview, kDiracQualityPreview, numChannels, 44100., &myReadData, (void*)self);
// void *dirac = DiracCreate(kDiracLambda3, kDiracQualityBest, numChannels, 44100., &myReadData);
if (!dirac) {
printf(“!! ERROR !!nntCould not create DIRAC instancentCheck number of channels and sample rate!n”);
printf(“ntNote that the free DIRAC LE library supports onlyntone channel per instancennn”);
exit(-1);
}
// Pass the values to our DIRAC instance
DiracSetProperty(kDiracPropertyTimeFactor, time, dirac);
DiracSetProperty(kDiracPropertyPitchFactor, pitch, dirac);
DiracSetProperty(kDiracPropertyFormantFactor, formant, dirac);
// upshifting pitch will be slower, so in this case we’ll enable constant CPU pitch shifting
if (pitch > 1.0)
DiracSetProperty(kDiracPropertyUseConstantCpuPitchShift, 1, dirac);
// Print our settings to the console
DiracPrintSettings(dirac);
NSLog(@”Running DIRAC version %snStarting processing”, DiracVersion());
// Get the number of frames from the file to display our simplistic progress bar
SInt64 numf = [reader fileNumFrames];
SInt64 outframes = 0;
SInt64 newOutframe = numf*time;
long lastPercent = -1;
percent = 0;
// This is an arbitrary number of frames per call. Change as you see fit
long numFrames = 8192;
// Allocate buffer for output
float **audio = AllocateAudioBuffer(numChannels, numFrames);
double bavg = 0;
// MAIN PROCESSING LOOP STARTS HERE
for(;;) {
// Display ASCII style “progress bar”
percent = 100.f*(double)outframes / (double)newOutframe;
long ipercent = percent;
if (lastPercent != percent) {
//[self performSelectorOnMainThread:@selector(updateBarOnMainThread:) withObject:self waitUntilDone:NO];
printf(“rProgress: %3i%% [%-40s] “, ipercent, &”||||||||||||||||||||||||||||||||||||||||”[40 – ((ipercent>100)?40:(2*ipercent/5))] );
lastPercent = ipercent;
fflush(stdout);
}
DiracStartClock();
// ……………………….. start timer ……………………………………
// Call the DIRAC process function with current time and pitch settings
// Returns: the number of frames in audio
long ret = DiracProcess(audio, numFrames, dirac);
bavg += (numFrames/sampleRate);
gExecTimeTotal += DiracClockTimeSeconds();
// ……………………….. stop timer ……………………………………
printf(“x realtime = %3.3f : 1 (DSP only), CPU load (peak, DSP+disk): %3.2f%%n”, bavg/gExecTimeTotal, DiracPeakCpuUsagePercent(dirac));
// Process only as many frames as needed
long framesToWrite = numFrames;
unsigned long nextWrite = outframes + numFrames;
if (nextWrite > newOutframe) framesToWrite = numFrames – nextWrite + newOutframe;
if (framesToWrite < 0) framesToWrite = 0;
// Write the data to the output file
[writer writeFloats:framesToWrite fromArray:audio];
// Increase our counter for the progress bar
outframes += numFrames;
// As soon as we’ve written enough frames we exit the main loop
if (ret <= 0) break;
}
percent = 100;
//[self performSelectorOnMainThread:@selector(updateBarOnMainThread:) withObject:self waitUntilDone:NO];
// Free buffer for output
DeallocateAudioBuffer(audio, numChannels);
// destroy DIRAC instance
DiracDestroy( dirac );
// Done!
NSLog(@”nDone!”);
[reader release];
[writer release]; // important – flushes data to file
// start playback on main thread
[self performSelectorOnMainThread:@selector(playOnMainThread:) withObject:self waitUntilDone:NO];
[pool release];
}
– (void)audioPlayerDidFinishPlaying:(AVAudioPlayer *)player successfully:(BOOL)flag
{
}
– (void) initAudioProcessor: (NSURL*) filePath
{ NSLog(@”initAudioProcessor”);
//NSString *inputSound = [[[NSBundle mainBundle] pathForResource: @”voice” ofType: @”aif”] retain];
NSString *outputSound = [[[NSHomeDirectory() stringByAppendingString:@”/Documents/”] stringByAppendingString:@”out.aif”] retain];
inUrl = [filePath retain];
outUrl = [[NSURL fileURLWithPath:outputSound] retain];
reader = [[EAFRead alloc] init];
writer = [[EAFWrite alloc] init];
// this thread does the processing
[NSThread detachNewThreadSelector:@selector(processThread:) toTarget:self withObject:nil];
}
– (void)dealloc
{
[player release];
[inUrl release];
[outUrl release];
[super dealloc];
}
In my AudioController (code in previous blog), create a AudioProcessor object:
AudioProcessor *audioProcessor = [[AudioProcessor alloc] init];
[audioProcessor initAudioProcessor: [NSString stringWithFormat: @”%@”, recordedTmpFiles[recordedTmpFileIdx]]];
recordedTmpFiles[recordedTmpFileIdx] is the filepath of the recorded audio.
Hiero Bitmap Font Tool Downloads
Just adjust float pitch, to change the well, pitch of your voice. For a chipmunky voice, set the pitch to > 1, for a low voice set the pitch to < 1.
GitHub - Glampert/font-tool: Command Line Tool That Converts ...
And that’s it 🙂