ID3v2_tag* load_tag(const char* file_name)
{
// Declaration
FILE* file;
ID3v2_tag* tag;
ID3v2_frame_list* frame_list;
ID3v2_header* tag_header;
// Initialization
tag = new_tag();
tag_header = get_tag_header(file_name);
if(tag_header == NULL ||
get_tag_version(tag_header) == NO_COMPATIBLE_TAG)
{
// No compatible ID3 tag in the file, or we got some problem opening the file
free_tag(tag);
return NULL;
}
// Associations
tag->tag_header = tag_header;
file = fopen(file_name, "rb");
if(file == NULL)
{
perror("Error opening file");
free_tag(tag);
return NULL;
}
tag->raw = (char*) malloc(tag->tag_header->tag_size * sizeof(char));
fseek(file, 10, SEEK_SET);
fread(tag->raw, tag->tag_header->tag_size, 1, file);
fclose(file);
int offset = 0;
while(offset < tag->tag_header->tag_size)
{
ID3v2_frame* frame;
frame = parse_frame(tag->raw, offset, get_tag_version(tag_header));
if(frame != NULL)
{
offset += frame->size + 10;
add_to_list(tag->frames, frame);
}
else
{
break;
}
}
return tag;
}
WavpackContext *WavpackCloseFile (WavpackContext *wpc)
{
if (wpc->streams) {
free_streams (wpc);
if (wpc->streams [0])
free (wpc->streams [0]);
free (wpc->streams);
}
#ifndef VER4_ONLY
if (wpc->stream3)
free_stream3 (wpc);
#endif
if (wpc->reader && wpc->reader->close && wpc->wv_in)
wpc->reader->close (wpc->wv_in);
if (wpc->reader && wpc->reader->close && wpc->wvc_in)
wpc->reader->close (wpc->wvc_in);
WavpackFreeWrapper (wpc);
if (wpc->channel_reordering)
free (wpc->channel_reordering);
#ifndef NO_TAGS
free_tag (&wpc->m_tag);
#endif
free (wpc);
return NULL;
}
// internal functions
SDL_Surface *load_embedded (const char *file)
{
if (file == NULL)
return NULL;
if (access (file, F_OK) == -1)
{
fprintf (stderr,"%s: file '%s' does not exist\n", prog, file);
return NULL;
}
if (access (file, R_OK) == -1)
{
fprintf (stderr,"%s: file '%s' cannot be read\n", prog, file);
return NULL;
}
ID3v2_tag *tag = load_tag (file);
if (tag == NULL)
{
return NULL;
}
ID3v2_frame *frame = tag_get_album_cover (tag);
if (frame == NULL)
{
free_tag (tag);
return NULL;
}
ID3v2_frame_apic_content *album_content = parse_apic_frame_content (frame);
if (album_content == NULL)
{
free_tag (tag);
return NULL;
}
SDL_Surface *sur =
load_img_sdl (album_content->data, album_content->picture_size);
free_tag (tag);
free_apic_content (album_content);
return sur;
}
void free_tags(struct ptr_array *tags)
{
int i;
for (i = 0; i < tags->count; i++) {
struct tag *t = tags->ptrs[i];
free_tag(t);
free(t);
}
free(tags->ptrs);
clear(tags);
}
void free_tag_dict( gtentry * * dict )
{
gtentry * gtw;
gtentry * gtwn;
gtw = *dict;
while( gtw != NULL ) {
gtwn = gtw->next;;
free_tag( dict, gtw );
gtw = gtwn;
}
return;
}
void collect_tags(const char *prefix)
{
struct tag t;
size_t pos = 0;
char *prev = NULL;
if (!load_tag_file())
return;
while (next_tag(tag_file, &pos, prefix, 0, &t)) {
if (!prev || strcmp(prev, t.name)) {
add_completion(t.name);
prev = t.name;
t.name = NULL;
}
free_tag(&t);
}
}
static void
free_tag_group (TagGroup *tag_group)
{
GList *l;
pluma_debug_message (DEBUG_PLUGINS, "Tag group: %s", tag_group->name);
g_return_if_fail (tag_group != NULL);
free (tag_group->name);
for (l = tag_group->tags; l != NULL; l = g_list_next (l))
{
free_tag ((Tag *) l->data);
}
g_list_free (tag_group->tags);
g_free (tag_group);
pluma_debug_message (DEBUG_PLUGINS, "END");
}
void scr_gt( void )
{
char * p;
char * pn;
char savetag;
int k;
int len;
char macname[MAC_NAME_LENGTH + 1];
condcode cc;
gtentry * wk;
gtflags tag_flags;
enum {
f_add = 1,
f_change,
f_delete,
f_off,
f_on,
f_print
} function;
garginit(); // find end of CW
/***********************************************************************/
/* isolate tagname or use previous if tagname * */
/***********************************************************************/
cc = getarg(); // Tagname
if( cc == omit ) {
// no operands
tag_name_missing_err();
return;
}
p = tok_start;
if( *p == '*' ) { // single * as tagname
if( arg_flen > 1 ) {
xx_err( err_tag_name_inv );
return;
}
savetag = '*'; // remember for possible global delete / print
if( GlobalFlags.firstpass && input_cbs->fmflags & II_research ) {
if( tag_entry != NULL ) {
out_msg(" using tagname %s %s\n", tagname, tag_entry->name );
}
}
} else {
savetag = ' '; // no global function for delete / print
init_tag_att(); // forget previous values for quick access
attname[0] = '*';
pn = tagname;
len = 0;
while( *p && is_macro_char( *p ) ) {
if( len < TAG_NAME_LENGTH ) {
*pn++ = tolower( *p++ );// copy lowercase tagname
*pn = '\0';
} else {
break;
}
len++;
}
for( k = len; k < TAG_NAME_LENGTH; k++ ) {
tagname[k] = '\0';
}
tagname[TAG_NAME_LENGTH] = '\0';
if( len < arg_flen ) {
xx_err( err_tag_name_inv );
return;
}
}
/***********************************************************************/
/* get function operand add, change, ... */
/***********************************************************************/
cc = getarg();
if( cc == omit ) {
xx_err( err_tag_func_inv );
return;
}
p = tok_start;
function = 0;
switch( tolower( *p ) ) {
case 'a':
if( !strnicmp( "ADD ", p, 4 ) ) {
function = f_add;
}
break;
case 'c' :
if( (arg_flen > 2) && (arg_flen < 7)
&& !strnicmp( "CHANGE", p, arg_flen ) ) {
function = f_change;
}
break;
case 'o' :
if( !strnicmp( "OFF", p, 3 ) ) {
function = f_off;
} else {
if( !strnicmp( "ON", p, 2 ) ) {
function = f_on;
}
}
break;
case 'd' :
if( (arg_flen > 2) && (arg_flen < 7)
&& !strnicmp( "DELETE", p, arg_flen ) ) {
function = f_delete;
}
break;
case 'p' :
if( (arg_flen > 1) && (arg_flen < 6)
&& !strnicmp( "PRINT", p, arg_flen ) ) {
function = f_print;
}
break;
default:
// nothing
break;
}
if( function == 0 ) { // no valid function specified
xx_err( err_tag_func_inv );
return;
}
cc = getarg(); // get possible next parm
/***********************************************************************/
/* for add and change get macroname */
/***********************************************************************/
if( function == f_add || function == f_change ) { // need macroname
if( cc == omit ) {
xx_err( err_tag_mac_name );
return;
}
p = tok_start;
pn = macname;
len = 0;
while( *p && is_macro_char( *p ) ) {
if( len < MAC_NAME_LENGTH ) {
*pn++ = tolower( *p++ ); // copy lowercase macroname
*pn = '\0';
} else {
break;
}
len++;
}
for( k = len; k < MAC_NAME_LENGTH; k++ ) {
macname[k] = '\0';
}
macname[MAC_NAME_LENGTH] = '\0';
tag_flags = 0;
if( function == f_add ) { // collect tag options
cc = scan_tag_options( &tag_flags );
if( cc != omit ) { // not all processed error
xx_err( err_tag_opt_inv );
}
tag_entry = add_tag( &tag_dict, tagname, macname, tag_flags ); // add to dictionary
// if tag_entry is now NULL, error (+ msg) was output in add_tag
} else { // is function change
tag_entry = change_tag( &tag_dict, tagname, macname );
}
} else {
/***********************************************************************/
/* after delete, off, on, print nothing allowed */
/***********************************************************************/
if( cc != omit ) {
xx_err( err_tag_toomany ); // nothing more allowed
}
switch( function ) {
case f_print :
if( savetag == '*' ) {
print_tag_dict( tag_dict );
} else {
print_tag_entry( find_tag( &tag_dict, tagname ) );
}
break;
case f_delete :
if( savetag == '*' ) {
free_tag_dict( &tag_dict );
} else {
free_tag( &tag_dict, find_tag( &tag_dict, tagname ) );
}
break;
case f_off :
if( savetag == '*' && tag_entry != NULL ) {// off for last defined
tag_entry->tagflags |= tag_off;
} else {
wk = find_tag( &tag_dict, tagname );
if( wk != NULL ) {
wk->tagflags |= tag_off;
}
}
break;
case f_on :
if( savetag == '*' && tag_entry != NULL ) {// on for last defined
tag_entry->tagflags |= tag_off;
} else {
wk = find_tag( &tag_dict, tagname );
if( wk != NULL ) {
wk->tagflags &= ~tag_off;
}
}
break;
default:
break;
}
}
scan_restart = scan_stop +1;
return;
}
static gboolean
parse_tag_group (TagGroup *tg, const gchar* fn, xmlDocPtr doc,
xmlNsPtr ns, xmlNodePtr cur, gboolean sort)
{
pluma_debug_message (DEBUG_PLUGINS, "Parse TagGroup: %s", tg->name);
/* We don't care what the top level element name is */
cur = cur->xmlChildrenNode;
while (cur != NULL)
{
if ((xmlStrcmp (cur->name, (const xmlChar *) "Tag")) || (cur->ns != ns))
{
g_warning ("The tag list file '%s' is of the wrong type, "
"was '%s', 'Tag' expected.", fn, cur->name);
return FALSE;
}
else
{
Tag *tag;
tag = g_new0 (Tag, 1);
/* Get Tag name */
tag->name = xmlGetProp (cur, (const xmlChar *) "name");
if (tag->name == NULL)
{
/* Error: No name */
g_warning ("The tag list file '%s' is of the wrong type, "
"Tag without name.", fn);
g_free (tag);
return FALSE;
}
else
{
/* Parse Tag */
if (parse_tag (tag, doc, ns, cur))
{
/* Prepend Tag to TagGroup */
tg->tags = g_list_prepend (tg->tags, tag);
}
else
{
/* Error parsing Tag */
g_warning ("The tag list file '%s' is of the wrong type, "
"error parsing Tag '%s' in TagGroup '%s'.",
fn, tag->name, tg->name);
free_tag (tag);
return FALSE;
}
}
}
cur = cur->next;
}
if (sort)
tg->tags = g_list_sort (tg->tags, tags_cmp);
else
tg->tags = g_list_reverse (tg->tags);
return TRUE;
}
