int
mp_set_custom_content_at_pos(id3_tag* tag, char* field, id3_content* new_content, int pos)
{
id3v2_tag *v2;
if(!tag || !field || strlen(field) != 4) return MP_EERROR;
if(tag->version == 1)
{
if(mp_convert_to_v2(tag))
return MP_EERROR;
}
else if(tag->version == -1) return MP_EVERSION;
v2 = (id3v2_tag*)tag->tag;
if(!v2->frame_list)
{
v2->frame_list = XMALLOCD0(id3v2_frame_list,
"mp_set_custom_content_at_pos:v2->frame_list");
id3_add_frame(v2->frame_list, field, new_content->data, new_content->length);
}
else
{
id3v2_frame *frame;
if((frame = id3_lookup_frame(v2->frame_list, field, pos)))
{
if(new_content)
{
long len, len_sync;
/* make sync safe */
len = new_content->length;
len_sync = id3_sync(new_content->data, len);
xfree(frame->data);
frame->data = xmallocd(new_content->length,
"mp_set_custom_content_at_pos:frame->data");
memcpy(frame->data, new_content->data, new_content->length);
frame->status_flag = 0;
if(len != len_sync) frame->format_flag = 64;
else frame->format_flag = 0;
frame->data_size = len_sync;
}
else id3_remove_frame(v2->frame_list, frame);
}
else if(pos == 0) id3_add_frame(v2->frame_list, field, new_content->data, new_content->length);
else return MP_EFNF;
}
return 0;
}
id3_tag_list*
mp_get_tag_list_from_fd(int fd)
{
id3_tag_list *tag_list = NULL;
id3_tag_list *tag_list2 = NULL;
id3v2_tag *v2tag = NULL;
id3v1_tag *v1tag = NULL;
id3_tag *tag = NULL;
v2tag = id3v2_get_tag(fd);
if(v2tag)
{
tag = XMALLOCD0(id3_tag, "mp_get_tag_list_from_fd:tag");
if(v2tag->header->version_minor == 3 || v2tag->header->version_minor == 4)
tag->version = 2;
else
tag->version = -1;
tag->tag = v2tag;
tag_list = XMALLOCD(id3_tag_list, "mp_get_tag_list_from_fd:tag_list");
tag_list->tag = tag;
tag_list->next = NULL;
tag_list->first = tag_list;
}
v1tag = id3v1_get_tag(fd);
if(v1tag)
{
tag = XMALLOCD(id3_tag, "mp_get_tag_list_from_fd:tag");
tag->version = 1;
tag->tag = v1tag;
if(tag_list)
{
tag_list2 = XMALLOCD(id3_tag_list, "mp_get_tag_list_from_fd:tag_list2");
tag_list2->tag = tag;
tag_list2->next = NULL;
tag_list2->first = tag_list;
tag_list->next = tag_list2;
}
else
{
tag_list = XMALLOCD(id3_tag_list, "mp_get_tag_list_from_fd:tag_list");
tag_list->tag = tag;
tag_list->next = NULL;
tag_list->first = tag_list;
}
}
return tag_list;
}
id3_tag*
mp_alloc_tag_with_version(int v)
{
id3_tag* ret;
if(v != 1 && v != 2) return NULL;
ret = XMALLOCD(id3_tag, "mp_alloc_tag_with_version:ret");
ret->version = v;
if(v == 1)
{
ret->tag = XMALLOCD0(id3v1_tag, "mp_alloc_tag_with_version:ret->tag");
((id3v1_tag*)ret->tag)->genre = 0xFF;
}
else
{
id3v2_tag *v2;
/* XXX */
ret->tag = XMALLOCD0(id3v2_tag, "mp_alloc_tag_with_version:ret->tag");
v2 = (id3v2_tag*)ret->tag;
v2->header = XMALLOCD0(id3v2_header, "mp_alloc_tag_with_version:v2->header");
//if ID3VERSION == "2.4"
v2->header->version_minor = 4;
//else
v2->header->version_minor = 3;
//endif
v2->header->version_revision = 0;
v2->header->unsyncronization = 1;
v2->header->has_extended_header = 0;
v2->header->is_experimental = 1;
v2->header->has_footer = 0;
v2->header->flags = 0;
v2->header->total_tag_size = 0;
v2->header->extended_header = NULL;
v2->frame_list = NULL;
}
return ret;
}
int
mpt_scan(char* file) {
char cwd[NAME_MAX+1];
spod_path_splited* sp;
struct stat stats;
res = XMALLOCD0(results, "ignore");
if(stat(file, &stats) == -1)
{
printf("Could not get stats for %s\n", file);
perror(file);
exit(1);
}
printf("Going to check recursivly %s\n", file);
if(access(file, F_OK | R_OK))
{
perror(file);
return -1;
}
stats.st_mode &= S_IFMT;
if((stats.st_mode & S_IFREG) == S_IFREG)
{
puts("Target is a regular file. Doing expr. and perish.");
sp = spod_split_path(file);
do_expr(sp->head, sp->tail);
exit(0);
}
if(access(file, F_OK | X_OK))
{
perror(file);
return -1;
}
/* go for it */
desc_dir(file, 0);
//xprint_malloc_stat();
return 0;
failed:
return 1;
}
static id3v2_tag*
id3v2_get_tag(int fd,int *cancle)
{
if(1<=*cancle)
return NULL;
unsigned char *c;
id3v2_header *header;
id3v2_frame_list *frame_list;
id3v2_frame *frame;
id3v2_tag *tag = NULL;
int i;
if(lseek(fd, 0L, SEEK_SET) == -1) return NULL;
c = (unsigned char*)xmallocd0(1024, "id3v2_get_tag:c");
if(read(fd, c, 10) < 10) goto exit_on_error;
c[10] = 0;
if(strncmp(c, "ID3", 3)) goto exit_on_error;
header = XMALLOCD0(id3v2_header, "id3v2_get_tag:header");
header->version_minor = c[3];
header->version_revision = c[4];
header->flags = c[5];
header->unsyncronization = (c[5] & 128) >> 7;
//[email protected]
if( 2!=header->version_minor )
{
header->has_extended_header = (c[5] & 64) >> 6;
header->is_experimental = (c[5] & 32) >> 5;
header->has_footer = (c[5] & 16) >> 4;
}
static id3v2_tag*
id3v2_get_tag(int fd)
{
unsigned char *c;
id3v2_header *header;
id3v2_frame_list *frame_list;
id3v2_frame *frame;
id3v2_tag *tag = NULL;
int i;
if(lseek(fd, 0L, SEEK_SET) == -1) return NULL;
c = (unsigned char*)xmallocd0(1024, "id3v2_get_tag:c");
if(read(fd, c, 10) < 10) goto exit_on_error;
c[10] = 0;
if(strncmp(c, "ID3", 3)) goto exit_on_error;
header = XMALLOCD0(id3v2_header, "id3v2_get_tag:header");
header->version_minor = c[3];
header->version_revision = c[4];
header->flags = c[5];
header->unsyncronization = (c[5] & 128) >> 7;
header->has_extended_header = (c[5] & 64) >> 6;
header->is_experimental = (c[5] & 32) >> 5;
header->has_footer = (c[5] & 16) >> 4;
header->total_tag_size = id3_unsync32(c, 6) + 10;
if(header->has_footer) header->total_tag_size += 10;
tag = XMALLOCD0(id3v2_tag, "id3v2_get_tag:tag");
/* check if version is supported */
if(c[3] != 3 && c[3] != 4)
{
xfree(c);
tag->header = header;
tag->frame_list = NULL;
return tag;
}
frame_list = XMALLOCD0(id3v2_frame_list, "id3v2_get_tag:frame_list");
frame_list->start = frame_list;
/* assigning header and frame list to tag */
tag->header = header;
tag->frame_list = frame_list;
if(header->has_extended_header)
{
id3v2_extended_header *xt_header = XMALLOCD0(id3v2_extended_header,
"id3v2_get_tag:id3v2_extended_header");
header->extended_header = xt_header;
read(fd, c, 4); /* get length of extended header */
xt_header->size = id3_unsync32(c, 0);
read(fd, c, 1); /* get number of flags */
xt_header->no_flag_bytes = (c[0] > 0) ? c[0] : 1;
read(fd, c, xt_header->no_flag_bytes); /* get flag bytes */
xt_header->is_update = (c[0] & 64) >> 6;
xt_header->crc_data_present = (c[0] & 32) >> 5;
xt_header->restrictions = (c[0] & 16) >> 4;
/* Flag data */
if(xt_header->is_update) read(fd, c, 1); /* Data length ind. is 0 -skip */
if(xt_header->crc_data_present) {
read(fd, c, 1); /* data length - shoud be 5 */
if(*c != 5) goto exit_on_error; /* else things might
break badly */
xt_header->crc_data_length = *c;
xt_header->crc_data = xmallocd0(*c, "id3v2_get_tag:xt_header->crc_data");
read(fd, xt_header->crc_data, *c);
}
if(xt_header->restrictions) {
read(fd, c, 1); /* data length - shoud be 1 */
if(*c != 1) goto exit_on_error;
xt_header->restrictions_data_length = *c;
xt_header->restrictions_data = xmallocd0(*c,
"id3v2_get_tag:xt_header->restrictions_data");
read(fd, xt_header->restrictions_data, *c);
}
}
static id3v1_tag*
id3v1_get_tag(int fd)
{
id3v1_tag *tag;
char *c;
tag = XMALLOCD0(id3v1_tag, "id3v1_get_tag:tag");
c = (char *)xmallocd(3, "id3v1_get_tag:c");
if(lseek(fd, -128L, SEEK_END) == -1) goto exit_on_error;
if(read(fd, c, 3) < 3) goto exit_on_error;
if(strncmp(c, "TAG", 3) != 0) goto exit_on_error;
tag->title = (char *)xmallocd(31, "id3v1_get_tag:tag->title");
if(read(fd, tag->title, 30) < 30) goto exit_on_error;
if(tag->title[0] == 0 || id3_is_only_space(tag->title, 30)) {
xfree(tag->title);
tag->title = NULL;
} else tag->title[30] = 0;
tag->artist = (char*)xmallocd(31, "id3v1_get_tag:tag->artist");
if(read(fd, tag->artist, 30) < 30) goto exit_on_error;
if(tag->artist[0] == 0 || id3_is_only_space(tag->artist, 30)) {
xfree(tag->artist);
tag->artist = NULL;
} else tag->artist[30] = 0;
tag->album = (char*)xmallocd(31, "id3v1_get_tag:tag->album");
if(read(fd, tag->album, 30) < 30) goto exit_on_error;
if(tag->album[0] == 0 || id3_is_only_space(tag->album, 30)) {
xfree(tag->album);
tag->album = NULL;
} else tag->album[30] = 0;
tag->year = (char*)xmallocd(5, "id3v1_get_tag:tag->year");
if(read(fd, tag->year, 4) < 4) goto exit_on_error;
if(tag->year[0] == 0 || id3_is_only_space(tag->year, 4)) {
xfree(tag->year);
tag->year = NULL;
} else tag->year[4] = 0;
tag->comment = (char*)xmallocd(31, "id3v1_get_tag:tag->comment");
if(read(fd, tag->comment, 30) < 30) goto exit_on_error;
tag->comment[30] = 0;
if(read(fd, &(tag->genre), 1) < 1) goto exit_on_error;
/* Looking for v1.1 track info */
if(tag->comment && tag->comment[28] == 0 && tag->comment[29] != 0)
{
tag->track = tag->comment[29];
tag->comment[29] = 0;
}
else
{
tag->track = 0;
}
/* Set comment to NULL if not set - this happens at this point because */
/* there maybe a track info anyway */
if(tag->comment[0] == 0 || id3_is_only_space(tag->comment, 28)) {
xfree(tag->comment);
tag->comment = NULL;
}
xfree(c);
return tag;
exit_on_error:
xfree(c);
id3v1_free_tag(tag);
return NULL;
}
int
mp_convert_to_v1(id3_tag *tag)
{
id3v1_tag *v1;
id3_tag* tmp;
id3_content* content;
id3_text_content* tc;
id3_comment_content* cc;
char* c;
int j, k = 0;
if(tag->version == 1) return 0;
else if(tag->version == -1) return MP_EVERSION;
v1 = XMALLOCD0(id3v1_tag, "mp_convert_to_v1:v1");
content = mp_get_content(tag, MP_ARTIST);
tc = mp_parse_artist(content);
v1->artist = tc->text;
xfree(tc);
mp_free_content(content);
content = mp_get_content(tag, MP_TITLE);
tc = mp_parse_title(content);
v1->title = tc->text;
xfree(tc);
mp_free_content(content);
content = mp_get_content(tag, MP_ALBUM);
tc = mp_parse_album(content);
v1->album = tc->text;
xfree(tc);
mp_free_content(content);
content = mp_get_content(tag, MP_YEAR);
tc = mp_parse_year(content);
v1->year = tc->text;
xfree(tc);
mp_free_content(content);
content = mp_get_content(tag, MP_COMMENT);
cc = mp_parse_comment(content);
v1->comment = cc->text;
xfree(cc->language);
xfree(cc->short_descr);
xfree(cc);
mp_free_content(content);
content = mp_get_content(tag, MP_TRACK);
tc = mp_parse_track(content);
c = tc->text;
if(c)
{
#ifdef HAVE_STRTOL
errno = 0;
j = strtol(c, (char **)NULL, 10);
if(errno != ERANGE) v1->track = j;
else v1->track = 0;
#else
v1->track = atoi(c);
#endif
}
else v1->track = 0;
xfree(c);
mp_free_text_content(tc);
mp_free_content(content);
content = mp_get_content(tag, MP_GENRE);
tc = mp_parse_genre(content);
c = tc->text;
for(j = 0; c, j < GLL; j++) {
if(!strcmp(genre_list[j], c))
{
v1->genre = j;
k = 1;
}
}
if(!c) v1->genre = 0xFF;
xfree(c);
mp_free_text_content(tc);
mp_free_content(content);
id3v1_truncate_tag(v1);
id3v2_free_tag(tag->tag);
tag->version = 1;
tag->tag = v1;
return 0;
}
