Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/metadata.c
Dave Bryant 24d6535b7a Allow WavPack to use new sampling rate converter 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@6888 a1c6a512-1295-4272-9138-f99709370657
2005-06-27 00:12:40 +00:00

714 lines
23 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 Dave Chapman
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "metadata.h"
#include "mp3_playback.h"
#include "mp3data.h"
#include "logf.h"
#include "atoi.h"
/* Simple file type probing by looking filename extension. */
int probe_file_format(const char *filename)
{
char *suffix;
suffix = strrchr(filename, '.');
if (suffix == NULL)
return AFMT_UNKNOWN;
suffix += 1;
if (!strcasecmp("mp1", suffix))
return AFMT_MPA_L1;
else if (!strcasecmp("mp2", suffix))
return AFMT_MPA_L2;
else if (!strcasecmp("mpa", suffix))
return AFMT_MPA_L2;
else if (!strcasecmp("mp3", suffix))
return AFMT_MPA_L3;
else if (!strcasecmp("ogg", suffix))
return AFMT_OGG_VORBIS;
else if (!strcasecmp("wav", suffix))
return AFMT_PCM_WAV;
else if (!strcasecmp("flac", suffix))
return AFMT_FLAC;
else if (!strcasecmp("mpc", suffix))
return AFMT_MPC;
else if (!strcasecmp("aac", suffix))
return AFMT_AAC;
else if (!strcasecmp("ape", suffix))
return AFMT_APE;
else if (!strcasecmp("wma", suffix))
return AFMT_WMA;
else if ((!strcasecmp("a52", suffix)) || (!strcasecmp("ac3", suffix)))
return AFMT_A52;
else if (!strcasecmp("rm", suffix))
return AFMT_REAL;
else if (!strcasecmp("wv", suffix))
return AFMT_WAVPACK;
return AFMT_UNKNOWN;
}
unsigned short a52_bitrates[]={32,40,48,56,64,80,96,
112,128,160,192,224,256,320,
384,448,512,576,640};
/* Only store frame sizes for 44.1KHz - others are simply multiples
of the bitrate */
unsigned short a52_441framesizes[]=
{69*2,70*2,87*2,88*2,104*2,105*2,121*2,122*2,
139*2,140*2,174*2,175*2,208*2,209*2,243*2,244*2,
278*2,279*2,348*2,349*2,417*2,418*2,487*2,488*2,
557*2,558*2,696*2,697*2,835*2,836*2,975*2,976*2,
1114*2,1115*2,1253*2,1254*2,1393*2,1394*2};
const long wavpack_sample_rates [] = { 6000, 8000, 9600, 11025, 12000, 16000,
22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000, 192000 };
/* Get metadata for track - return false if parsing showed problems with the
file that would prevent playback. */
static bool get_apetag_info (struct mp3entry *entry, int fd);
bool get_metadata(struct track_info* track, int fd, const char* trackname,
bool v1first) {
unsigned long totalsamples,bytespersample,channels,bitspersample,numbytes;
int bytesperframe;
unsigned char* buf;
int i,j,eof;
int rc;
/* Load codec specific track tag information. */
switch (track->id3.codectype) {
case AFMT_MPA_L1:
case AFMT_MPA_L2:
case AFMT_MPA_L3:
/* Should check the return value. */
mp3info(&track->id3, trackname, v1first);
lseek(fd, 0, SEEK_SET);
/* This is too slow to execute on some files. */
get_mp3file_info(fd, &track->mp3data);
lseek(fd, 0, SEEK_SET);
/*
logf("T:%s", track->id3.title);
logf("L:%d", track->id3.length);
logf("O:%d", track->id3.first_frame_offset);
logf("F:%d", track->id3.frequency);
*/
track->taginfo_ready = true;
break ;
case AFMT_PCM_WAV:
/* Use the trackname part of the id3 structure as a temporary buffer */
buf=track->id3.path;
lseek(fd, 0, SEEK_SET);
rc = read(fd, buf, 44);
if (rc < 44) {
return false;
}
if ((memcmp(buf,"RIFF",4)!=0) ||
(memcmp(&buf[8],"WAVEfmt",7)!=0)) {
logf("%s is not a WAV file\n",trackname);
return(false);
}
/* FIX: Correctly parse WAV header - we assume canonical
44-byte header */
bitspersample=buf[34];
channels=buf[22];
if ((bitspersample!=16) || (channels != 2)) {
logf("Unsupported WAV file - %d bitspersample, %d channels\n",
bitspersample,channels);
return(false);
}
bytespersample=((bitspersample/8)*channels);
numbytes=(buf[40]|(buf[41]<<8)|(buf[42]<<16)|(buf[43]<<24));
totalsamples=numbytes/bytespersample;
track->id3.vbr=false; /* All WAV files are CBR */
track->id3.filesize=filesize(fd);
track->id3.frequency=buf[24]|(buf[25]<<8)|(buf[26]<<16)|(buf[27]<<24);
/* Calculate track length (in ms) and estimate the bitrate (in kbit/s) */
track->id3.length=(totalsamples/track->id3.frequency)*1000;
track->id3.bitrate=(track->id3.frequency*bytespersample)/(1000/8);
lseek(fd, 0, SEEK_SET);
strncpy(track->id3.path,trackname,sizeof(track->id3.path));
track->taginfo_ready = true;
break;
case AFMT_FLAC:
/* A simple parser to read vital metadata from a FLAC file - length, frequency, bitrate etc. */
/* This code should either be moved to a seperate file, or discarded in favour of the libFLAC code */
/* The FLAC stream specification can be found at http://flac.sourceforge.net/format.html#stream */
/* Use the trackname part of the id3 structure as a temporary buffer */
buf=track->id3.path;
lseek(fd, 0, SEEK_SET);
rc = read(fd, buf, 4);
if (rc < 4) {
return false;
}
if (memcmp(buf,"fLaC",4)!=0) {
logf("%s is not a FLAC file\n",trackname);
return(false);
}
while (1) {
rc = read(fd, buf, 4);
i = (buf[1]<<16)|(buf[2]<<8)|buf[3]; /* The length of the block */
if ((buf[0]&0x7f)==0) { /* 0 is the STREAMINFO block */
rc = read(fd, buf, i); /* FIXME: Don't trust the value of i */
if (rc < 0) {
return false;
}
track->id3.vbr=true; /* All FLAC files are VBR */
track->id3.filesize=filesize(fd);
track->id3.frequency=(buf[10]<<12)|(buf[11]<<4)|((buf[12]&0xf0)>>4);
/* NOT NEEDED: bitspersample=(((buf[12]&0x01)<<4)|((buf[13]&0xf0)>>4))+1; */
/* totalsamples is a 36-bit field, but we assume <= 32 bits are used */
totalsamples=(buf[14]<<24)|(buf[15]<<16)|(buf[16]<<8)|buf[17];
/* Calculate track length (in ms) and estimate the bitrate (in kbit/s) */
track->id3.length=(totalsamples/track->id3.frequency)*1000;
track->id3.bitrate=(filesize(fd)*8)/track->id3.length;
} else if ((buf[0]&0x7f)==4) { /* 4 is the VORBIS_COMMENT block */
/* The next i bytes of the file contain the VORBIS COMMENTS - just skip them for now. */
lseek(fd, i, SEEK_CUR);
} else {
if (buf[0]&0x80) { /* If we have reached the last metadata block, abort. */
break;
} else {
lseek(fd, i, SEEK_CUR); /* Skip to next metadata block */
}
}
}
lseek(fd, 0, SEEK_SET);
strncpy(track->id3.path,trackname,sizeof(track->id3.path));
track->taginfo_ready = true;
break;
case AFMT_OGG_VORBIS:
/* A simple parser to read vital metadata from an Ogg Vorbis file */
/* An Ogg File is split into pages, each starting with the string
"OggS". Each page has a timestamp (in PCM samples) referred to as
the "granule position".
An Ogg Vorbis has the following structure:
1) Identification header (containing samplerate, numchannels, etc)
2) Comment header - containing the Vorbis Comments
3) Setup header - containing codec setup information
4) Many audio packets...
*/
/* Use the trackname part of the id3 structure as a temporary buffer */
buf=track->id3.path;
lseek(fd, 0, SEEK_SET);
rc = read(fd, buf, 58);
if (rc < 4) {
return false;
}
if ((memcmp(buf,"OggS",4)!=0) || (memcmp(&buf[29],"vorbis",6)!=0)) {
logf("%s is not an Ogg Vorbis file\n",trackname);
return(false);
}
/* Ogg stores integers in little-endian format. */
track->id3.filesize=filesize(fd);
track->id3.frequency=buf[40]|(buf[41]<<8)|(buf[42]<<16)|(buf[43]<<24);
channels=buf[39];
/* We now need to search for the last page in the file - identified by
by ('O','g','g','S',0) and retrieve totalsamples */
lseek(fd, -32*1024, SEEK_END);
eof=0;
j=0; /* The number of bytes currently in buffer */
i=0;
totalsamples=0;
while (!eof) {
rc = read(fd, &buf[j], MAX_PATH-j);
if (rc <= 0) {
eof=1;
} else {
j+=rc;
}
/* Inefficient (but simple) search */
i=0;
while (i < (j-5)) {
if (memcmp(&buf[i],"OggS",5)==0) {
if (i < (j-10)) {
totalsamples=(buf[i+6])|(buf[i+7]<<8)|(buf[i+8]<<16)|(buf[i+9]<<24);
j=0; /* We can discard the rest of the buffer */
} else {
break;
}
} else {
i++;
}
}
if (i < (j-5)) {
/* Move OggS to start of buffer */
while(i>0) buf[i--]=buf[j--];
} else {
j=0;
}
}
track->id3.length=(totalsamples/track->id3.frequency)*1000;
/* The following calculation should use datasize, not filesize (i.e. exclude comments etc) */
track->id3.bitrate=(filesize(fd)*8)/track->id3.length;
track->id3.vbr=true;
lseek(fd, 0, SEEK_SET);
strncpy(track->id3.path,trackname,sizeof(track->id3.path));
track->taginfo_ready = true;
break;
case AFMT_WAVPACK:
/* A simple parser to read basic information from a WavPack file.
* This will fail on WavPack files that don't have the WavPack header
* as the first thing (i.e. self-extracting WavPack files) or WavPack
* files that have so much extra RIFF data stored in the first block
* that they don't have samples (very rare, I would think).
*/
/* Use the trackname part of the id3 structure as a temporary buffer */
buf=track->id3.path;
lseek(fd, 0, SEEK_SET);
rc = read(fd, buf, 32);
if (rc < 32) {
return false;
}
if (memcmp (buf, "wvpk", 4) != 0 || buf [9] != 4 || buf [8] < 2) {
logf ("%s is not a WavPack file\n", trackname);
return (false);
}
track->id3.vbr = true; /* All WavPack files are VBR */
track->id3.filesize = filesize (fd);
if ((buf [20] | buf [21] | buf [22] | buf [23]) &&
(buf [12] & buf [13] & buf [14] & buf [15]) != 0xff) {
int srindx = ((buf [26] >> 7) & 1) + ((buf [27] << 1) & 14);
if (srindx == 15)
track->id3.frequency = 44100;
else
track->id3.frequency = wavpack_sample_rates [srindx];
totalsamples = (buf[15] << 24) | (buf[14] << 16) | (buf[13] << 8) | buf[12];
track->id3.length = totalsamples / (track->id3.frequency / 100) * 10;
track->id3.bitrate = filesize (fd) /
(track->id3.length / 8);
}
get_apetag_info (&track->id3, fd); /* use any apetag info we find */
lseek (fd, 0, SEEK_SET);
strncpy (track->id3.path, trackname, sizeof (track->id3.path));
track->taginfo_ready = true;
break;
case AFMT_A52:
/* Use the trackname part of the id3 structure as a temporary buffer */
buf=track->id3.path;
lseek(fd, 0, SEEK_SET);
/* We just need the first 5 bytes */
rc = read(fd, buf, 5);
if (rc < 5) {
return false;
}
if ((buf[0]!=0x0b) || (buf[1]!=0x77)) {
logf("%s is not an A52/AC3 file\n",trackname);
return false;
}
i = buf[4]&0x3e;
if (i > 36) {
logf("A52: Invalid frmsizecod: %d\n",i);
return false;
}
track->id3.bitrate=a52_bitrates[i>>1];
track->id3.vbr=false;
track->id3.filesize = filesize (fd);
switch (buf[4]&0xc0) {
case 0x00:
track->id3.frequency=48000;
bytesperframe=track->id3.bitrate*2*2;
break;
case 0x40:
track->id3.frequency=44100;
bytesperframe=a52_441framesizes[i];
break;
case 0x80:
track->id3.frequency=32000;
bytesperframe=track->id3.bitrate*3*2;
break;
default:
logf("A52: Invalid samplerate code: 0x%02x\n",buf[4]&0xc0);
return false;
break;
}
/* One A52 frame contains 6 blocks, each containing 256 samples */
totalsamples=(track->filesize/bytesperframe)*6*256;
track->id3.length=(totalsamples/track->id3.frequency)*1000;
lseek(fd, 0, SEEK_SET);
strncpy(track->id3.path,trackname,sizeof(track->id3.path));
track->taginfo_ready = true;
break;
/* If we don't know how to read the metadata, just store the filename */
default:
strncpy(track->id3.path,trackname,sizeof(track->id3.path));
track->taginfo_ready = true;
break;
}
return true;
}
/************************* APE TAG HANDLING CODE ****************************/
/*
* This is a first pass at APEv2 tag handling. I'm not sure if this should
* reside here, but I wanted to modify as little as possible since I don't
* have a feel for the complete system. It may be that APEv2 tags should be
* added to the ID3 handling code in the firmware directory. APEv2 tags are
* used in WavPack files and Musepack files by default, however they are
* also used in MP3 files sometimes (by Foobar2000). Also, WavPack files can
* also use ID3v1 tags (but not ID3v2), so it seems like some universal tag
* handler might be a reasonable approach.
*
* This code does not currently handle APEv1 tags, but I believe that this
* is not a problem because they were only used in Monkey's Audio files which
* will probably never be playable in RockBox (and certainly not by this CPU).
*/
#define APETAG_HEADER_FORMAT "8LLLL"
#define APETAG_HEADER_LENGTH 32
#define APETAG_DATA_LIMIT 4096
struct apetag_header {
char id [8];
long version, length, item_count, flags;
char res [8];
};
static struct apetag {
struct apetag_header header;
char data [APETAG_DATA_LIMIT];
} temp_apetag;
static int get_apetag_item (struct apetag *tag,
const char *item,
char *value,
int size);
static int load_apetag (int fd, struct apetag *tag);
static void UTF8ToAnsi (unsigned char *pUTF8);
/*
* This function searches the specified file for an APEv2 tag and uses any
* information found there to populate the appropriate fields in the specified
* mp3entry structure. A temporary buffer is used to hold the tag during this
* operation. For now, the actual string data that needs to be held during the
* life of the track entry is stored in the "id3v2buf" field (which should not
* be used for any file that has an APEv2 tag). This limits the total space
* for the artist, title, album, composer and genre strings to 300 characters.
*/
static bool get_apetag_info (struct mp3entry *entry, int fd)
{
int rem_space = sizeof (entry->id3v2buf), str_space;
char *temp_buffer = entry->id3v2buf;
if (rem_space <= 1 || !load_apetag (fd, &temp_apetag))
return false;
if (get_apetag_item (&temp_apetag, "year", temp_buffer, rem_space))
entry->year = atoi (temp_buffer);
if (get_apetag_item (&temp_apetag, "track", temp_buffer, rem_space))
entry->tracknum = atoi (temp_buffer);
if (get_apetag_item (&temp_apetag, "artist", temp_buffer, rem_space)) {
UTF8ToAnsi (entry->artist = temp_buffer);
str_space = strlen (temp_buffer) + 1;
temp_buffer += str_space;
rem_space -= str_space;
}
if (rem_space > 1 &&
get_apetag_item (&temp_apetag, "title", temp_buffer, rem_space)) {
UTF8ToAnsi (entry->title = temp_buffer);
str_space = strlen (temp_buffer) + 1;
temp_buffer += str_space;
rem_space -= str_space;
}
if (rem_space > 1 &&
get_apetag_item (&temp_apetag, "album", temp_buffer, rem_space)) {
UTF8ToAnsi (entry->album = temp_buffer);
str_space = strlen (temp_buffer) + 1;
temp_buffer += str_space;
rem_space -= str_space;
}
if (rem_space > 1 &&
get_apetag_item (&temp_apetag, "genre", temp_buffer, rem_space)) {
UTF8ToAnsi (entry->genre_string = temp_buffer);
str_space = strlen (temp_buffer) + 1;
temp_buffer += str_space;
rem_space -= str_space;
}
if (rem_space > 1 &&
get_apetag_item (&temp_apetag, "composer", temp_buffer, rem_space))
UTF8ToAnsi (entry->composer = temp_buffer);
return true;
}
/*
* Helper function to convert little-endian structures to easily usable native
* format using a format string (this does nothing on a little-endian machine).
*/
static void little_endian_to_native (void *data, char *format)
{
unsigned char *cp = (unsigned char *) data;
long temp;
while (*format) {
switch (*format) {
case 'L':
temp = cp [0] + ((long) cp [1] << 8) + ((long) cp [2] << 16) + ((long) cp [3] << 24);
* (long *) cp = temp;
cp += 4;
break;
case 'S':
temp = cp [0] + (cp [1] << 8);
* (short *) cp = (short) temp;
cp += 2;
break;
default:
if (*format >= '0' && *format <= '9')
cp += *format - '0';
break;
}
format++;
}
}
/*
* Attempt to obtain the named string-type item from the specified APEv2 tag.
* The tag value will be copied to "value" (including an appended terminating
* NULL) and the length of the string (including the NULL) will be returned.
* If the data will not fit in the specified "size" then it will be truncated
* early (but still terminated). If the specified item is not found then 0 is
* returned and written to the first character of "value". If "value" is
* passed in as NULL, then the specified size is ignored and the actual size
* required to store the value is returned.
*
* Note that this function does not work on binary tag data; only UTF-8
* encoded strings. However, numeric data (like ReplayGain) is usually stored
* as strings.
*
* Also, APEv2 tags may have multiple values for a given item and these will
* all be copied to "value" with NULL separators (this is why the total data
* size is returned). Of course, it is possible to ignore any additional
* values by simply using up to the first NULL.
*/
static int get_apetag_item (struct apetag *tag,
const char *item,
char *value,
int size)
{
if (value && size)
*value = 0;
if (tag->header.id [0] == 'A') {
char *p = tag->data;
char *q = p + tag->header.length - APETAG_HEADER_LENGTH;
int i;
for (i = 0; i < tag->header.item_count; ++i) {
int vsize, flags, isize;
vsize = * (long *) p; p += 4;
flags = * (long *) p; p += 4;
isize = strlen (p);
little_endian_to_native (&vsize, "L");
little_endian_to_native (&flags, "L");
if (p + isize + vsize + 1 > q)
break;
if (isize && vsize && !stricmp (item, p) && !(flags & 6)) {
if (value) {
if (vsize + 1 > size)
vsize = size - 1;
memcpy (value, p + isize + 1, vsize);
value [vsize] = 0;
}
return vsize + 1;
}
else
p += isize + vsize + 1;
}
}
return 0;
}
/*
* Attempt to load an APEv2 tag from the specified file into the specified
* structure. If the APEv2 tag will not fit into the predefined data size,
* then the tag is not loaded. A return value of TRUE indicates success.
*/
static int load_apetag (int fd, struct apetag *tag)
{
if (lseek (fd, -APETAG_HEADER_LENGTH, SEEK_END) == -1 ||
read (fd, &tag->header, APETAG_HEADER_LENGTH) != APETAG_HEADER_LENGTH ||
strncmp (tag->header.id, "APETAGEX", 8)) {
tag->header.id [0] = 0;
return false;
}
little_endian_to_native (&tag->header, APETAG_HEADER_FORMAT);
if (tag->header.version == 2000 && tag->header.item_count &&
tag->header.length > APETAG_HEADER_LENGTH &&
tag->header.length < APETAG_DATA_LIMIT) {
int data_size = tag->header.length - APETAG_HEADER_LENGTH;
if (lseek (fd, -tag->header.length, SEEK_END) == -1 ||
read (fd, tag->data, data_size) != data_size) {
tag->header.id [0] = 0;
return false;
}
else
return true;
}
tag->header.id [0] = 0;
return false;
}
/*
* This is a *VERY* boneheaded attempt to convert UTF-8 unicode character
* strings to ANSI. It simply maps the 16-bit Unicode characters that are
* less than 0x100 directly to an 8-bit value, and turns all the rest into
* question marks. This can be done "in-place" because the resulting string
* can only get smaller.
*/
static void UTF8ToAnsi (unsigned char *pUTF8)
{
unsigned char *pAnsi = pUTF8;
unsigned short widechar = 0;
int trail_bytes = 0;
while (*pUTF8) {
if (*pUTF8 & 0x80) {
if (*pUTF8 & 0x40) {
if (trail_bytes) {
trail_bytes = 0;
*pAnsi++ = widechar < 0x100 ? widechar : '?';
}
else {
char temp = *pUTF8;
while (temp & 0x80) {
trail_bytes++;
temp <<= 1;
}
widechar = temp >> trail_bytes--;
}
}
else if (trail_bytes) {
widechar = (widechar << 6) | (*pUTF8 & 0x3f);
if (!--trail_bytes)
*pAnsi++ = widechar < 0x100 ? widechar : '?';
}
}
else
*pAnsi++ = *pUTF8;
pUTF8++;
}
*pAnsi = 0;
}
Reference in a new issue View git blame Copy permalink