static void rfd_ftl_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
{
struct partition *part;
if (mtd->type != MTD_NORFLASH)
return;
part = kcalloc(1, sizeof(struct partition), GFP_KERNEL);
if (!part)
return;
part->mbd.mtd = mtd;
if (block_size)
part->block_size = block_size;
else {
if (!mtd->erasesize) {
printk(KERN_NOTICE PREFIX "please provide block_size");
return;
}
else
part->block_size = mtd->erasesize;
}
if (scan_header(part) == 0) {
part->mbd.size = part->sector_count;
part->mbd.blksize = SECTOR_SIZE;
part->mbd.tr = tr;
part->mbd.devnum = -1;
if (!(mtd->flags & MTD_WRITEABLE))
part->mbd.readonly = 1;
else if (part->errors) {
printk(KERN_NOTICE PREFIX "'%s': errors found, "
"setting read-only", mtd->name);
part->mbd.readonly = 1;
}
printk(KERN_INFO PREFIX "name: '%s' type: %d flags %x\n",
mtd->name, mtd->type, mtd->flags);
if (!add_mtd_blktrans_dev((void*)part))
return;
}
kfree(part);
}
int
mp3_get_tag (Private * h, char *path, struct SongDBEntry *e)
{
FILE *fd;
mp3Private *mp3_priv = (mp3Private *) h;
int length = 0;
long size = 0;
char *empty = strdup ("");
char *title = NULL, *artist = NULL, *album = NULL;
char *comment = NULL, *year = NULL, *genre = NULL;
if( h == NULL || path == NULL || e ==NULL)
return ERROR_INVALID_ARG;
{
struct id3_file *id3file;
struct id3_tag *id3tag;
id3_ucs4_t *ucs4;
id3_latin1_t *latin1;
struct id3_frame *frame;
id3file = id3_file_open ( path, ID3_FILE_MODE_READONLY);
if (id3file == NULL)
{
ERROR("get_tag: Error opening file: %s", strerror (errno));
return -1;
}
id3tag = id3_file_tag (id3file);
frame = id3_tag_findframe (id3tag, ID3_FRAME_TITLE, 0);
if (frame != NULL)
{
ucs4 =
(id3_ucs4_t *) id3_field_getstrings ((union id3_field const *)
&frame->fields[1], 0);
if (ucs4 != NULL)
{
latin1 = id3_ucs4_latin1duplicate (ucs4);
if (latin1 != NULL)
{
title = strdup (latin1);
}
}
}
frame = id3_tag_findframe (id3tag, ID3_FRAME_ARTIST, 0);
if (frame != NULL)
{
ucs4 = (id3_ucs4_t *) id3_field_getstrings (&frame->fields[1], 0);
if (ucs4 != NULL)
{
latin1 = id3_ucs4_latin1duplicate (ucs4);
if (latin1 != NULL)
{
artist = strdup (latin1);
}
}
}
frame =
id3_tag_findframe ((struct id3_tag const *) id3tag, ID3_FRAME_ALBUM, 0);
if (frame != NULL)
{
ucs4 = (id3_ucs4_t *) id3_field_getstrings (&frame->fields[1], 0);
if (ucs4 != NULL)
{
latin1 = id3_ucs4_latin1duplicate (ucs4);
if (latin1 != NULL)
{
album = strdup (latin1);
}
}
}
frame =
id3_tag_findframe ((struct id3_tag const *) id3tag, ID3_FRAME_COMMENT,
0);
if (frame != NULL)
{
ucs4 = (id3_ucs4_t *) id3_field_getstrings (&frame->fields[1], 0);
if (ucs4 != NULL)
{
latin1 = id3_ucs4_latin1duplicate (ucs4);
if (latin1 != NULL)
{
comment = strdup (latin1);
}
}
}
frame =
id3_tag_findframe ((struct id3_tag const *) id3tag, ID3_FRAME_YEAR, 0);
if (frame != NULL)
{
ucs4 = (id3_ucs4_t *) id3_field_getstrings (&frame->fields[1], 0);
if (ucs4 != NULL)
{
latin1 = id3_ucs4_latin1duplicate (ucs4);
if (latin1 != NULL)
{
year = strdup (latin1);
}
}
}
frame =
id3_tag_findframe ((struct id3_tag const *) id3tag, ID3_FRAME_GENRE, 0);
if (frame != NULL)
{
ucs4 = (id3_ucs4_t *) id3_field_getstrings (&frame->fields[1], 0);
if (ucs4 != NULL)
{
ucs4 = (id3_ucs4_t *) id3_genre_name (ucs4);
if (ucs4 != NULL)
{
latin1 = id3_ucs4_latin1duplicate (ucs4);
if (latin1 != NULL)
{
genre = strdup (latin1);
}
}
}
}
id3_file_close (id3file);
}
e->title = title;
e->artist = artist;
e->album = album;
e->comment = comment;
e->year = year;
e->genre = genre;
/* length calculation stuff */
{
struct mad_header header;
struct xing xing;
if( e->AddInfo == NULL )
{
e->AddInfo = malloc( sizeof(struct SongAddInfo) );
if( e->AddInfo == NULL)
return ERROR_NO_MEMORY;
memset( e->AddInfo, 0, sizeof( struct SongAddInfo ));
}
fd = fopen ( path, "rb");
if (fd == NULL)
{
ERROR("get_tag: Error opening file %s:%s", path, strerror (errno));
return ERROR_OPEN_ERROR;
}
fseek(fd,0,SEEK_END);
size=ftell(fd);
fseek(fd,0,SEEK_SET);
e->filesize = size;
if (scan_header (fd, &header, &xing) == -1)
{
fclose (fd);
// printf ("get_tag: Error Reading File\n");
return ERROR_READ_SEEK_ERROR;
}
switch( header.layer )
{
case MAD_LAYER_I: e->AddInfo->type = str_mpeg1_l1; break;
case MAD_LAYER_II: e->AddInfo->type = str_mpeg1_l2; break;
case MAD_LAYER_III:
if( header.flags & MAD_FLAG_MPEG_2_5_EXT )
e->AddInfo->type = str_mpeg25_l3;
else
e->AddInfo->type = str_mpeg1_l3;
break;
default: e->AddInfo->type = NULL; break;
}
e->AddInfo->n_ch = MAD_NCHANNELS(&header);
e->AddInfo->SampleRate = header.samplerate;
e->AddInfo->bitrate = header.bitrate;
e->AddInfo->err_protection = ((header.flags & MAD_FLAG_PROTECTION) >0);
e->AddInfo->copyright = ((header.flags & MAD_FLAG_COPYRIGHT) >0);
e->AddInfo->original = ((header.flags & MAD_FLAG_ORIGINAL) >0);
fseek (fd, 0, SEEK_SET);
// bitrate = 0;
if (xing.flags & XING_FRAMES)
{
mad_timer_t timer;
timer = header.duration;
mad_timer_multiply (&timer, xing.frames);
length = mad_timer_count (timer, MAD_UNITS_MILLISECONDS);
/*
if (xing.flags & XING_BYTES)
bitrate = xing.bytes * 8 / length;
*/
// printf ("XING header w/ XING_FRAMES found. length = %d\n", length);
}
else
{
if (!cfg->lengthcalc)
length = (size * 8 / (header.bitrate / 1000)); /* est. */
else
{
fseek (fd, 0, SEEK_SET);
scan_file (fd, &length, NULL);
}
}
e->time = length;
mp3_priv->length = length;
}
fclose (fd);
mp3_priv->size = size;
mp3_priv->position = 0;
return 1;
}
/*=================================================
* do_import -- Read GEDCOM file to database
* ifeed: [IN] output methods
* fp: [I/O] GEDCOM file whence to load data
*===============================================*/
static BOOLEAN
do_import (IMPORT_FEEDBACK ifeed, FILE *fp)
{
NODE node, conv;
XLAT ttm = 0;
STRING msg;
BOOLEAN emp;
INT nindi = 0, nfam = 0, neven = 0;
INT nsour = 0, nothr = 0, type, num = 0;
INT totkeys = 0, totused = 0;
char msgbuf[80];
BOOLEAN succeeded=FALSE;
STRING str,unistr=0;
ZSTR zerr=0;
TABLE metadatatab = create_table_str();
STRING gdcodeset=0;
INT warnings=0;
/* start by assuming default */
strupdate(&gdcodeset, gedcom_codeset_in);
/* rptui_init(); *//* clear ui time counter */
/* Open and validate GEDCOM file */
if ((unistr=check_file_for_unicode(fp)) && !eqstr(unistr, "UTF-8")) {
msg_error(_(qSunsupuniv), unistr);
goto end_import;
}
if (eqstr_ex(unistr, "UTF-8")) {
strupdate(&gdcodeset, "UTF-8");
}
if (!scan_header(fp, metadatatab, &zerr)) {
msg_error(zs_str(zerr));
goto end_import;
}
if ((str = valueof_str(metadatatab, "GEDC.FORM"))!= NULL) {
if (!eqstr(str, "LINEAGE-LINKED")) {
if (!ask_yes_or_no_msg(
_("This is not a lineage linked GEDCOM file.")
, _("Proceed anyway?")
))
goto end_import;
}
}
if (!unistr && (str = valueof_str(metadatatab, "CHAR"))!= NULL) {
/* if no BOM, use file's declared encoding if present */
strupdate(&gdcodeset, str);
}
/* TODO: Push this codeset question down to after the validation, where we can know if
the incoming file happened to really be all ASCII */
if (!int_codeset[0]) {
/* TODO: ask if user would like to adopt codeset of incoming file, if we found it */
if (!ask_yes_or_no_msg(
_("No current internal codeset, so no codeset conversion can be done")
, _("Proceed without codeset conversion?")
))
goto end_import;
}
/* Warn if lossy code conversion likely */
if (gdcodeset[0] && int_codeset[0]) {
if (is_lossy_conversion(gdcodeset, int_codeset)) {
ZSTR zstr=zs_new();
zs_setf(zstr, _("Lossy codeset conversion (from <%s> to <%s>) likely")
, gdcodeset, int_codeset);
if (!ask_yes_or_no_msg(
zs_str(zstr)
, _("Proceed anyway?")
))
goto end_import;
}
}
/* validate */
if (ifeed && ifeed->validating_fnc)
(*ifeed->validating_fnc)();
if (!validate_gedcom(ifeed, fp)) {
if (ifeed && ifeed->error_invalid_fnc)
(*ifeed->error_invalid_fnc)(_(qSgdnadd));
goto end_import;
}
warnings = validate_get_warning_count();
if (warnings) {
ZSTR zstr=zs_new();
zs_setf(zstr, _pl("%d warning during import",
"%d warnings during import", warnings), warnings);
if (!ask_yes_or_no_msg(zs_str(zstr), _(qSproceed))) {
goto end_import;
}
}
if (gdcodeset[0] && int_codeset[0]) {
retry_input_codeset:
ttm = transl_get_xlat(gdcodeset, int_codeset);
if (!transl_is_xlat_valid(ttm)) {
ZSTR zstr=zs_new();
char csname[64];
BOOLEAN b;
transl_release_xlat(ttm);
ttm = 0;
zs_setf(zstr, _("Cannot convert codeset (from <%s> to <%s>)")
, gdcodeset, int_codeset);
b = ask_for_string(zs_str(zstr)
, _("Enter codeset to assume (* for none)")
, csname, sizeof(csname)) && csname[0];
zs_free(&zstr);
if (!b)
goto end_import;
if (!eqstr(csname, "*")) {
strupdate(&gdcodeset, csname);
goto retry_input_codeset;
}
}
}
if((num_indis() > 0)
|| (num_fams() > 0)
|| (num_sours() > 0)
|| (num_evens() > 0)
|| (num_othrs() > 0)) gd_reuse = FALSE;
else if((gd_reuse = check_stdkeys())) {
totused = gd_itot + gd_ftot + gd_stot + gd_etot + gd_xtot;
totkeys = gd_imax + gd_fmax + gd_smax + gd_emax + gd_xmax;
if((totkeys-totused) > 0) {
INT delkeys = totkeys-totused;
snprintf(msgbuf, sizeof(msgbuf)
, _pl("Using original keys, %d deleted record will be in the database."
, "Using original keys, %d deleted records will be in the database."
, delkeys)
, delkeys
);
}
else strcpy(msgbuf, " ");
gd_reuse = ask_yes_or_no_msg(msgbuf, _(qScfoldk));
/*
TODO: why were these here ?
touchwin(uiw_win(stdout_win));
wrefresh(uiw_win(stdout_win));
*/
}
/* start loading the file */
rewind(fp);
/* test for read-only database here */
if(readonly) {
if (ifeed && ifeed->error_readonly_fnc)
(*ifeed->error_readonly_fnc)();
goto end_import;
}
/* tell user we are beginning real part of import */
if (ifeed && ifeed->beginning_import_fnc) {
if(gd_reuse)
(*ifeed->beginning_import_fnc)(_(qSdboldk));
else
(*ifeed->beginning_import_fnc)(_(qSdbnewk));
}
/* Add records to database */
node = convert_first_fp_to_node(fp, FALSE, ttm, &msg, &emp);
while (node) {
if (!(conv = node_to_node(node, &type))) {
free_nodes(node);
node = next_fp_to_node(fp, FALSE, ttm, &msg, &emp);
continue;
}
switch (type) {
case INDI_REC: num = ++nindi; break;
case FAM_REC: num = ++nfam; break;
case EVEN_REC: num = ++neven; break;
case SOUR_REC: num = ++nsour; break;
case OTHR_REC: num = ++nothr; break;
default: FATAL();
}
restore_record(conv, type, num);
if (ifeed && ifeed->added_rec_fnc)
ifeed->added_rec_fnc(nxref(conv)[1], ntag(conv), num);
free_nodes(node);
node = next_fp_to_node(fp, FALSE, ttm, &msg, &emp);
}
if (msg) {
msg_error(msg);
}
if(gd_reuse && ((totkeys - totused) > 0)) {
if (ifeed && ifeed->adding_unused_keys_fnc)
(*ifeed->adding_unused_keys_fnc)();
addmissingkeys(INDI_REC);
addmissingkeys(FAM_REC);
addmissingkeys(EVEN_REC);
addmissingkeys(SOUR_REC);
addmissingkeys(OTHR_REC);
}
succeeded = TRUE;
end_import:
validate_end_import();
zs_free(&zerr);
destroy_table(metadatatab);
strfree(&gdcodeset);
return succeeded;
}
