619 lines
14 KiB
C
619 lines
14 KiB
C
/*
|
|
* $Id$
|
|
* Implementation file for mp3 scanner and monitor
|
|
*
|
|
* Copyright (C) 2003 Ron Pedde (ron@pedde.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#define _POSIX_PTHREAD_SEMANTICS
|
|
#include <ctype.h>
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <id3tag.h>
|
|
#include <limits.h>
|
|
#include <restart.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "db-memory.h"
|
|
#include "err.h"
|
|
#include "mp3-scanner.h"
|
|
#include "playlist.h"
|
|
|
|
/*
|
|
* Typedefs
|
|
*/
|
|
|
|
typedef struct tag_scan_id3header {
|
|
unsigned char id[3];
|
|
unsigned char version[2];
|
|
unsigned char flags;
|
|
unsigned char size[4];
|
|
} SCAN_ID3HEADER;
|
|
|
|
#define MAYBEFREE(a) { if((a)) free((a)); };
|
|
|
|
|
|
/*
|
|
* Globals
|
|
*/
|
|
int scan_br_table[] = {
|
|
0,32,40,48,56,64,80,96,112,128,160,192,224,256,320,0
|
|
};
|
|
|
|
char *scan_winamp_genre[] = {
|
|
"Blues", // 0
|
|
"Classic Rock",
|
|
"Country",
|
|
"Dance",
|
|
"Disco",
|
|
"Funk", // 5
|
|
"Grunge",
|
|
"Hip-Hop",
|
|
"Jazz",
|
|
"Metal",
|
|
"New Age", // 10
|
|
"Oldies",
|
|
"Other",
|
|
"Pop",
|
|
"R&B",
|
|
"Rap", // 15
|
|
"Reggae",
|
|
"Rock",
|
|
"Techno",
|
|
"Industrial",
|
|
"Alternative", // 20
|
|
"Ska",
|
|
"Death Metal",
|
|
"Pranks",
|
|
"Soundtrack",
|
|
"Euro-Techno", // 25
|
|
"Ambient",
|
|
"Trip-Hop",
|
|
"Vocal",
|
|
"Jazz+Funk",
|
|
"Fusion", // 30
|
|
"Trance",
|
|
"Classical",
|
|
"Instrumental",
|
|
"Acid",
|
|
"House", // 35
|
|
"Game",
|
|
"Sound Clip",
|
|
"Gospel",
|
|
"Noise",
|
|
"AlternRock", // 40
|
|
"Bass",
|
|
"Soul",
|
|
"Punk",
|
|
"Space",
|
|
"Meditative", // 45
|
|
"Instrumental Pop",
|
|
"Instrumental Rock",
|
|
"Ethnic",
|
|
"Gothic",
|
|
"Darkwave", // 50
|
|
"Techno-Industrial",
|
|
"Electronic",
|
|
"Pop-Folk",
|
|
"Eurodance",
|
|
"Dream", // 55
|
|
"Southern Rock",
|
|
"Comedy",
|
|
"Cult",
|
|
"Gangsta",
|
|
"Top 40", // 60
|
|
"Christian Rap",
|
|
"Pop/Funk",
|
|
"Jungle",
|
|
"Native American",
|
|
"Cabaret", // 65
|
|
"New Wave",
|
|
"Psychadelic",
|
|
"Rave",
|
|
"Showtunes",
|
|
"Trailer", // 70
|
|
"Lo-Fi",
|
|
"Tribal",
|
|
"Acid Punk",
|
|
"Acid Jazz",
|
|
"Polka", // 75
|
|
"Retro",
|
|
"Musical",
|
|
"Rock & Roll",
|
|
"Hard Rock",
|
|
"Folk", // 80
|
|
"Folk/Rock",
|
|
"National folk",
|
|
"Swing",
|
|
"Fast-fusion",
|
|
"Bebob", // 85
|
|
"Latin",
|
|
"Revival",
|
|
"Celtic",
|
|
"Bluegrass",
|
|
"Avantgarde", // 90
|
|
"Gothic Rock",
|
|
"Progressive Rock",
|
|
"Psychedelic Rock",
|
|
"Symphonic Rock",
|
|
"Slow Rock", // 95
|
|
"Big Band",
|
|
"Chorus",
|
|
"Easy Listening",
|
|
"Acoustic",
|
|
"Humour", // 100
|
|
"Speech",
|
|
"Chanson",
|
|
"Opera",
|
|
"Chamber Music",
|
|
"Sonata", // 105
|
|
"Symphony",
|
|
"Booty Bass",
|
|
"Primus",
|
|
"Porn Groove",
|
|
"Satire", // 110
|
|
"Slow Jam",
|
|
"Club",
|
|
"Tango",
|
|
"Samba",
|
|
"Folklore", // 115
|
|
"Ballad",
|
|
"Powder Ballad",
|
|
"Rhythmic Soul",
|
|
"Freestyle",
|
|
"Duet", // 120
|
|
"Punk Rock",
|
|
"Drum Solo",
|
|
"A Capella",
|
|
"Euro-House",
|
|
"Dance Hall", // 125
|
|
"Goa",
|
|
"Drum & Bass",
|
|
"Club House",
|
|
"Hardcore",
|
|
"Terror", // 130
|
|
"Indie",
|
|
"BritPop",
|
|
"NegerPunk",
|
|
"Polsk Punk",
|
|
"Beat", // 135
|
|
"Christian Gangsta",
|
|
"Heavy Metal",
|
|
"Black Metal",
|
|
"Crossover",
|
|
"Contemporary C", // 140
|
|
"Christian Rock",
|
|
"Merengue",
|
|
"Salsa",
|
|
"Thrash Metal",
|
|
"Anime", // 145
|
|
"JPop",
|
|
"SynthPop",
|
|
"Unknown"
|
|
};
|
|
|
|
#define WINAMP_GENRE_UNKNOWN 148
|
|
|
|
|
|
/*
|
|
* Forwards
|
|
*/
|
|
int scan_foreground(char *path);
|
|
int scan_gettags(char *file, MP3FILE *pmp3);
|
|
int scan_getfileinfo(char *file, MP3FILE *pmp3);
|
|
int scan_freetags(MP3FILE *pmp3);
|
|
|
|
/*
|
|
* scan_init
|
|
*
|
|
* This assumes the database is already initialized.
|
|
*
|
|
* Ideally, this would check to see if the database is empty.
|
|
* If it is, it sets the database into bulk-import mode, and scans
|
|
* the MP3 directory.
|
|
*
|
|
* If not empty, it would start a background monitor thread
|
|
* and update files on a file-by-file basis
|
|
*/
|
|
|
|
int scan_init(char *path) {
|
|
int err;
|
|
if(db_is_empty()) {
|
|
if(db_start_initial_update())
|
|
return -1;
|
|
|
|
|
|
DPRINTF(ERR_DEBUG,"Scanning for MP3s in %s\n",path);
|
|
|
|
err=scan_foreground(path);
|
|
|
|
if(db_end_initial_update())
|
|
return -1;
|
|
} else {
|
|
/* do deferred updating */
|
|
return ENOTSUP;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* scan_foreground
|
|
*
|
|
* Do a brute force scan of a path, finding all the MP3 files there
|
|
*/
|
|
int scan_foreground(char *path) {
|
|
MP3FILE mp3file;
|
|
DIR *current_dir;
|
|
char de[sizeof(struct dirent) + MAXNAMLEN + 1]; /* overcommit for solaris */
|
|
struct dirent *pde;
|
|
int err;
|
|
char mp3_path[PATH_MAX];
|
|
char m3u_path[PATH_MAX];
|
|
char linebuffer[PATH_MAX];
|
|
int fd;
|
|
int playlistid;
|
|
struct stat sb;
|
|
|
|
if((current_dir=opendir(path)) == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
while(1) {
|
|
pde=(struct dirent *)&de;
|
|
|
|
err=readdir_r(current_dir,(struct dirent *)de,&pde);
|
|
if(err == -1) {
|
|
DPRINTF(ERR_DEBUG,"Error on readdir_r: %s\n",strerror(errno));
|
|
err=errno;
|
|
closedir(current_dir);
|
|
errno=err;
|
|
return -1;
|
|
}
|
|
|
|
if(!pde)
|
|
break;
|
|
|
|
if(pde->d_name[0] == '.') /* skip hidden and directories */
|
|
continue;
|
|
|
|
sprintf(mp3_path,"%s/%s",path,pde->d_name);
|
|
DPRINTF(ERR_DEBUG,"Found %s\n",mp3_path);
|
|
if(stat(mp3_path,&sb)) {
|
|
DPRINTF(ERR_WARN,"Error statting: %s\n",strerror(errno));
|
|
}
|
|
|
|
if(sb.st_mode & S_IFDIR) { /* dir -- recurse */
|
|
DPRINTF(ERR_DEBUG,"Found dir %s... recursing\n",pde->d_name);
|
|
scan_foreground(mp3_path);
|
|
} else {
|
|
DPRINTF(ERR_DEBUG,"Processing file\n");
|
|
/* process the file */
|
|
if(strlen(pde->d_name) > 4) {
|
|
if(strcasecmp(".m3u",(char*)&pde->d_name[strlen(pde->d_name) - 4]) == 0) {
|
|
/* we found an m3u file */
|
|
|
|
DPRINTF(ERR_DEBUG,"Found m3u: %s\n",pde->d_name);
|
|
strcpy(m3u_path,pde->d_name);
|
|
m3u_path[strlen(pde->d_name) - 4] = '\0';
|
|
playlistid=sb.st_ino;
|
|
fd=open(mp3_path,O_RDONLY);
|
|
if(fd != -1) {
|
|
db_add_playlist(playlistid,m3u_path);
|
|
|
|
while(readline(fd,linebuffer,sizeof(linebuffer)) > 0) {
|
|
while(linebuffer[strlen(linebuffer)-1] == '\n')
|
|
linebuffer[strlen(linebuffer)-1] = '\0';
|
|
|
|
if((linebuffer[0] == ';') || (linebuffer[0] == '#'))
|
|
continue;
|
|
|
|
/* otherwise, assume it is a path */
|
|
if(linebuffer[0] == '/') {
|
|
strcpy(m3u_path,linebuffer);
|
|
} else {
|
|
snprintf(m3u_path,sizeof(m3u_path),"%s/%s",path,linebuffer);
|
|
}
|
|
|
|
DPRINTF(ERR_DEBUG,"Checking %s\n",m3u_path);
|
|
|
|
/* might be valid, might not... */
|
|
if(!stat(m3u_path,&sb)) {
|
|
/* FIXME: check to see if valid inode! */
|
|
db_add_playlist_song(playlistid,sb.st_ino);
|
|
} else {
|
|
DPRINTF(ERR_WARN,"Playlist entry %s bad: %s\n",
|
|
m3u_path,strerror(errno));
|
|
}
|
|
}
|
|
close(fd);
|
|
}
|
|
} else if(strcasecmp(".mp3",(char*)&pde->d_name[strlen(pde->d_name) - 4]) == 0) {
|
|
/* we found an mp3 file */
|
|
DPRINTF(ERR_DEBUG,"Found mp3: %s\n",pde->d_name);
|
|
|
|
memset((void*)&mp3file,0,sizeof(mp3file));
|
|
mp3file.path=mp3_path;
|
|
mp3file.fname=pde->d_name;
|
|
|
|
#ifdef MAC /* wtf is this about? */
|
|
mp3file.mtime=sb.st_mtimespec.tv_sec;
|
|
mp3file.atime=sb.st_atimespec.tv_sec;
|
|
mp3file.ctime=sb.st_ctimespec.tv_sec;
|
|
#else
|
|
mp3file.mtime=sb.st_mtime;
|
|
mp3file.atime=sb.st_atime;
|
|
mp3file.ctime=sb.st_ctime;
|
|
#endif
|
|
|
|
/* FIXME; assumes that st_ino is a u_int_32 */
|
|
mp3file.id=sb.st_ino;
|
|
|
|
/* Do the tag lookup here */
|
|
if(!scan_gettags(mp3file.path,&mp3file) &&
|
|
!scan_getfileinfo(mp3file.path,&mp3file)) {
|
|
db_add(&mp3file);
|
|
pl_eval(&mp3file);
|
|
} else {
|
|
DPRINTF(ERR_INFO,"Skipping %s\n",pde->d_name);
|
|
}
|
|
|
|
scan_freetags(&mp3file);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
closedir(current_dir);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* scan_gettags
|
|
*
|
|
* Scan an mp3 file for id3 tags using libid3tag
|
|
*/
|
|
int scan_gettags(char *file, MP3FILE *pmp3) {
|
|
struct id3_file *pid3file;
|
|
struct id3_tag *pid3tag;
|
|
struct id3_frame *pid3frame;
|
|
int err;
|
|
int index;
|
|
int used;
|
|
unsigned char *utf8_text;
|
|
int genre=WINAMP_GENRE_UNKNOWN;
|
|
int have_utf8;
|
|
int have_text;
|
|
id3_ucs4_t const *native_text;
|
|
char *tmp;
|
|
|
|
pid3file=id3_file_open(file,ID3_FILE_MODE_READONLY);
|
|
if(!pid3file) {
|
|
DPRINTF(ERR_WARN,"Cannot open %s\n",file);
|
|
return -1;
|
|
}
|
|
|
|
pid3tag=id3_file_tag(pid3file);
|
|
|
|
if(!pid3tag) {
|
|
err=errno;
|
|
id3_file_close(pid3file);
|
|
errno=err;
|
|
DPRINTF(ERR_WARN,"Cannot get ID3 tag for %s\n",file);
|
|
return -1;
|
|
}
|
|
|
|
index=0;
|
|
while((pid3frame=id3_tag_findframe(pid3tag,"",index))) {
|
|
used=0;
|
|
utf8_text=NULL;
|
|
native_text=NULL;
|
|
have_utf8=0;
|
|
have_text=0;
|
|
|
|
if(((pid3frame->id[0] == 'T')||(strcmp(pid3frame->id,"COMM")==0)) &&
|
|
(id3_field_getnstrings(&pid3frame->fields[1])))
|
|
have_text=1;
|
|
|
|
if(have_text) {
|
|
native_text=id3_field_getstrings(&pid3frame->fields[1],0);
|
|
|
|
if(native_text) {
|
|
have_utf8=1;
|
|
utf8_text=id3_ucs4_utf8duplicate(native_text);
|
|
MEMNOTIFY(utf8_text);
|
|
|
|
if(!strcmp(pid3frame->id,"TIT2")) { /* Title */
|
|
used=1;
|
|
pmp3->title = utf8_text;
|
|
DPRINTF(ERR_DEBUG," Title: %s\n",utf8_text);
|
|
} else if(!strcmp(pid3frame->id,"TPE1")) {
|
|
used=1;
|
|
pmp3->artist = utf8_text;
|
|
DPRINTF(ERR_DEBUG," Artist: %s\n",utf8_text);
|
|
} else if(!strcmp(pid3frame->id,"TALB")) {
|
|
used=1;
|
|
pmp3->album = utf8_text;
|
|
DPRINTF(ERR_DEBUG," Album: %s\n",utf8_text);
|
|
} else if(!strcmp(pid3frame->id,"TCON")) {
|
|
used=1;
|
|
pmp3->genre = utf8_text;
|
|
DPRINTF(ERR_DEBUG," Genre: %s\n",utf8_text);
|
|
if(pmp3->genre) {
|
|
if(!strlen(pmp3->genre)) {
|
|
genre=WINAMP_GENRE_UNKNOWN;
|
|
} else if (isdigit(pmp3->genre[0])) {
|
|
genre=atoi(pmp3->genre);
|
|
} else if ((pmp3->genre[0] == '(') && (isdigit(pmp3->genre[1]))) {
|
|
genre=atoi((char*)&pmp3->genre[1]);
|
|
}
|
|
|
|
if((genre < 0) || (genre > WINAMP_GENRE_UNKNOWN))
|
|
genre=WINAMP_GENRE_UNKNOWN;
|
|
free(pmp3->genre);
|
|
pmp3->genre=strdup(scan_winamp_genre[genre]);
|
|
}
|
|
} else if(!strcmp(pid3frame->id,"COMM")) {
|
|
used=1;
|
|
pmp3->comment = utf8_text;
|
|
DPRINTF(ERR_DEBUG," Comment: %s\n",pmp3->comment);
|
|
} else if(!strcmp(pid3frame->id,"TPOS")) {
|
|
tmp=(char*)utf8_text;
|
|
strsep(&tmp,"/");
|
|
if(tmp) {
|
|
pmp3->total_discs=atoi(tmp);
|
|
}
|
|
pmp3->disc=atoi((char*)utf8_text);
|
|
DPRINTF(ERR_DEBUG," Disc %d of %d\n",pmp3->disc,pmp3->total_discs);
|
|
} else if(!strcmp(pid3frame->id,"TRCK")) {
|
|
tmp=(char*)utf8_text;
|
|
strsep(&tmp,"/");
|
|
if(tmp) {
|
|
pmp3->total_tracks=atoi(tmp);
|
|
}
|
|
pmp3->track=atoi((char*)utf8_text);
|
|
DPRINTF(ERR_DEBUG," Track %d of %d\n",pmp3->track,pmp3->total_tracks);
|
|
} else if(!strcmp(pid3frame->id,"TDRC")) {
|
|
pmp3->year = atoi(utf8_text);
|
|
DPRINTF(ERR_DEBUG," Year: %d\n",pmp3->year);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* can check for non-text tags here */
|
|
if((!used) && (have_utf8) && (utf8_text))
|
|
free(utf8_text);
|
|
|
|
index++;
|
|
}
|
|
|
|
pmp3->got_id3=1;
|
|
id3_file_close(pid3file);
|
|
DPRINTF(ERR_DEBUG,"Got id3 tag successfully\n");
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* scan_freetags
|
|
*
|
|
* Free up the tags that were dynamically allocated
|
|
*/
|
|
int scan_freetags(MP3FILE *pmp3) {
|
|
if(!pmp3->got_id3)
|
|
return 0;
|
|
|
|
MAYBEFREE(pmp3->title);
|
|
MAYBEFREE(pmp3->artist);
|
|
MAYBEFREE(pmp3->album);
|
|
MAYBEFREE(pmp3->genre);
|
|
MAYBEFREE(pmp3->comment);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* scan_getfileinfo
|
|
*
|
|
* Get information from the file headers itself -- like
|
|
* song length, bit rate, etc.
|
|
*/
|
|
int scan_getfileinfo(char *file, MP3FILE *pmp3) {
|
|
FILE *infile;
|
|
SCAN_ID3HEADER *pid3;
|
|
unsigned int size=0;
|
|
off_t fp_size=0;
|
|
off_t file_size;
|
|
unsigned char buffer[256];
|
|
int time_seconds;
|
|
|
|
int ver=0;
|
|
int layer=0;
|
|
int bitrate=0;
|
|
int samplerate=0;
|
|
|
|
if(!(infile=fopen(file,"rb"))) {
|
|
DPRINTF(ERR_WARN,"Could not open %s for reading\n",file);
|
|
return -1;
|
|
}
|
|
|
|
fread(buffer,1,sizeof(buffer),infile);
|
|
pid3=(SCAN_ID3HEADER*)buffer;
|
|
|
|
if(strncmp(pid3->id,"ID3",3)==0) {
|
|
/* found an ID3 header... */
|
|
DPRINTF(ERR_DEBUG,"Found ID3 header\n");
|
|
size = (pid3->size[0] << 21 | pid3->size[1] << 14 |
|
|
pid3->size[2] << 7 | pid3->size[3]);
|
|
fp_size=size + sizeof(SCAN_ID3HEADER);
|
|
DPRINTF(ERR_DEBUG,"Header length: %d\n",size);
|
|
}
|
|
|
|
fseek(infile,0,SEEK_END);
|
|
file_size=ftell(infile);
|
|
file_size -= fp_size;
|
|
|
|
fseek(infile,fp_size,SEEK_SET);
|
|
fread(buffer,1,sizeof(buffer),infile);
|
|
|
|
if((buffer[0] == 0xFF)&&(buffer[1] >= 224)) {
|
|
ver=(buffer[1] & 0x18) >> 3;
|
|
layer=(buffer[1] & 0x6) >> 1;
|
|
if((ver==3) && (layer==1)) { /* MPEG1, Layer 3 */
|
|
bitrate=(buffer[2] & 0xF0) >> 4;
|
|
bitrate=scan_br_table[bitrate];
|
|
samplerate=(buffer[2] & 0x0C) >> 2;
|
|
switch(samplerate) {
|
|
case 0:
|
|
samplerate=44100;
|
|
break;
|
|
case 1:
|
|
samplerate=48000;
|
|
break;
|
|
case 2:
|
|
samplerate=32000;
|
|
break;
|
|
}
|
|
pmp3->bitrate=bitrate;
|
|
pmp3->samplerate=samplerate;
|
|
} else {
|
|
/* not an mp3... */
|
|
DPRINTF(ERR_DEBUG,"File is not a MPEG-1/Layer III\n");
|
|
return -1;
|
|
}
|
|
|
|
/* guesstimate the file length */
|
|
time_seconds = ((int)(file_size * 8)) / (bitrate * 1024);
|
|
pmp3->song_length=time_seconds;
|
|
pmp3->file_size=file_size;
|
|
} else {
|
|
/* should really scan forward to next sync frame */
|
|
fclose(infile);
|
|
DPRINTF(ERR_DEBUG,"Could not find sync frame\n");
|
|
return -1;
|
|
}
|
|
|
|
|
|
fclose(infile);
|
|
return 0;
|
|
}
|