diff options
author | Christian Grothoff <christian@grothoff.org> | 2009-12-19 12:58:07 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2009-12-19 12:58:07 +0000 |
commit | 4db7e805a2c0082b95b1cd2a735e687897adcf3b (patch) | |
tree | cd0cb07619781d035d50f3ce939f42fa4f6f040e | |
parent | 560e0aa9da06367629c80b8797e0dcdaffed7037 (diff) | |
download | libextractor-4db7e805a2c0082b95b1cd2a735e687897adcf3b.tar.gz libextractor-4db7e805a2c0082b95b1cd2a735e687897adcf3b.zip |
nsf
-rw-r--r-- | src/plugins/Makefile.am | 35 | ||||
-rw-r--r-- | src/plugins/nsf_extractor.c (renamed from src/plugins/nsfextractor.c) | 148 | ||||
-rw-r--r-- | src/plugins/nsfe_extractor.c (renamed from src/plugins/nsfeextractor.c) | 251 |
3 files changed, 146 insertions, 288 deletions
diff --git a/src/plugins/Makefile.am b/src/plugins/Makefile.am index 03dc995..9244d14 100644 --- a/src/plugins/Makefile.am +++ b/src/plugins/Makefile.am | |||
@@ -92,6 +92,8 @@ plugin_LTLIBRARIES = \ | |||
92 | libextractor_mime.la \ | 92 | libextractor_mime.la \ |
93 | libextractor_mp3.la \ | 93 | libextractor_mp3.la \ |
94 | $(mpeg) \ | 94 | $(mpeg) \ |
95 | libextractor_nsf.la \ | ||
96 | libextractor_nsfe.la \ | ||
95 | libextractor_odf.la \ | 97 | libextractor_odf.la \ |
96 | $(ogg) \ | 98 | $(ogg) \ |
97 | $(ole2) \ | 99 | $(ole2) \ |
@@ -218,6 +220,16 @@ libextractor_mpeg_la_LDFLAGS = \ | |||
218 | libextractor_mpeg_la_LIBADD = \ | 220 | libextractor_mpeg_la_LIBADD = \ |
219 | -lmpeg2 | 221 | -lmpeg2 |
220 | 222 | ||
223 | libextractor_nsf_la_SOURCES = \ | ||
224 | nsf_extractor.c | ||
225 | libextractor_nsf_la_LDFLAGS = \ | ||
226 | $(PLUGINFLAGS) | ||
227 | |||
228 | libextractor_nsfe_la_SOURCES = \ | ||
229 | nsfe_extractor.c | ||
230 | libextractor_nsfe_la_LDFLAGS = \ | ||
231 | $(PLUGINFLAGS) | ||
232 | |||
221 | libextractor_odf_la_SOURCES = \ | 233 | libextractor_odf_la_SOURCES = \ |
222 | odf_extractor.c | 234 | odf_extractor.c |
223 | libextractor_odf_la_LDFLAGS = \ | 235 | libextractor_odf_la_LDFLAGS = \ |
@@ -353,12 +365,7 @@ OLD_LIBS = \ | |||
353 | libextractor_id3v24.la \ | 365 | libextractor_id3v24.la \ |
354 | libextractor_id3v23.la \ | 366 | libextractor_id3v23.la \ |
355 | $(extrampeg) \ | 367 | $(extrampeg) \ |
356 | libextractor_nsf.la \ | 368 | $(thumbqt) |
357 | libextractor_nsfe.la \ | ||
358 | libextractor_tar.la \ | ||
359 | $(thumbqt) \ | ||
360 | libextractor_xm.la \ | ||
361 | libextractor_zip.la | ||
362 | 369 | ||
363 | 370 | ||
364 | libextractor_id3v2_la_SOURCES = \ | 371 | libextractor_id3v2_la_SOURCES = \ |
@@ -383,20 +390,6 @@ libextractor_id3v24_la_LIBADD = \ | |||
383 | $(top_builddir)/src/common/libextractor_common.la | 390 | $(top_builddir)/src/common/libextractor_common.la |
384 | 391 | ||
385 | 392 | ||
386 | libextractor_nsf_la_SOURCES = \ | ||
387 | nsfextractor.c | ||
388 | libextractor_nsf_la_LDFLAGS = \ | ||
389 | $(PLUGINFLAGS) | ||
390 | libextractor_nsf_la_LIBADD = \ | ||
391 | $(top_builddir)/src/main/libextractor.la | ||
392 | |||
393 | libextractor_nsfe_la_SOURCES = \ | ||
394 | nsfeextractor.c | ||
395 | libextractor_nsfe_la_LDFLAGS = \ | ||
396 | $(PLUGINFLAGS) | ||
397 | libextractor_nsfe_la_LIBADD = \ | ||
398 | $(top_builddir)/src/main/libextractor.la | ||
399 | |||
400 | libextractor_thumbnailqt_la_SOURCES = \ | 393 | libextractor_thumbnailqt_la_SOURCES = \ |
401 | thumbnailextractorqt.cc | 394 | thumbnailextractorqt.cc |
402 | libextractor_thumbnailqt_la_LDFLAGS = \ | 395 | libextractor_thumbnailqt_la_LDFLAGS = \ |
@@ -409,7 +402,7 @@ libextractor_thumbnailqt_la_CPPFLAGS = \ | |||
409 | $(QT_CFLAGS) $(QT_SVG_CFLAGS) | 402 | $(QT_CFLAGS) $(QT_SVG_CFLAGS) |
410 | 403 | ||
411 | 404 | ||
412 | # Fixme: is this still working ok? Doubtful! | 405 | # FIXME: is this still working ok? Doubtful! |
413 | 406 | ||
414 | install-exec-hook: | 407 | install-exec-hook: |
415 | mkdir -p $(DESTDIR)$(plugindir) &> /dev/null || true | 408 | mkdir -p $(DESTDIR)$(plugindir) &> /dev/null || true |
diff --git a/src/plugins/nsfextractor.c b/src/plugins/nsf_extractor.c index da8c98c..448b99d 100644 --- a/src/plugins/nsfextractor.c +++ b/src/plugins/nsf_extractor.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | * This file is part of libextractor. | 2 | * This file is part of libextractor. |
3 | * (C) 2006 Toni Ruottu | 3 | * (C) 2006, 2009 Toni Ruottu |
4 | * | 4 | * |
5 | * libextractor is free software; you can redistribute it and/or modify | 5 | * libextractor is free software; you can redistribute it and/or modify |
6 | * it under the terms of the GNU General Public License as published | 6 | * it under the terms of the GNU General Public License as published |
@@ -61,19 +61,7 @@ struct header | |||
61 | char chipflags; | 61 | char chipflags; |
62 | }; | 62 | }; |
63 | 63 | ||
64 | 64 | #define ADD(s,t) do { if (0 != proc (proc_cls, "nsf", t, EXTRACTOR_METAFORMAT_UTF8, "text/plain", s, strlen(s)+1)) return 1; } while (0) | |
65 | static struct EXTRACTOR_Keywords *addkword | ||
66 | (EXTRACTOR_KeywordList * oldhead, | ||
67 | const char *phrase, EXTRACTOR_KeywordType type) | ||
68 | { | ||
69 | EXTRACTOR_KeywordList *keyword; | ||
70 | |||
71 | keyword = malloc (sizeof (EXTRACTOR_KeywordList)); | ||
72 | keyword->next = oldhead; | ||
73 | keyword->keyword = strdup (phrase); | ||
74 | keyword->keywordType = type; | ||
75 | return (keyword); | ||
76 | } | ||
77 | 65 | ||
78 | 66 | ||
79 | /* "extract" keyword from a Nes Sound Format file | 67 | /* "extract" keyword from a Nes Sound Format file |
@@ -83,9 +71,12 @@ static struct EXTRACTOR_Keywords *addkword | |||
83 | * written. | 71 | * written. |
84 | * | 72 | * |
85 | */ | 73 | */ |
86 | struct EXTRACTOR_Keywords *libextractor_nsf_extract | 74 | int |
87 | (const char *filename, | 75 | EXTRACTOR_nsf_extract (const unsigned char *data, |
88 | char *data, size_t size, struct EXTRACTOR_Keywords *prev) | 76 | size_t size, |
77 | EXTRACTOR_MetaDataProcessor proc, | ||
78 | void *proc_cls, | ||
79 | const char *options) | ||
89 | { | 80 | { |
90 | char album[33]; | 81 | char album[33]; |
91 | char artist[33]; | 82 | char artist[33]; |
@@ -93,109 +84,66 @@ struct EXTRACTOR_Keywords *libextractor_nsf_extract | |||
93 | char songs[32]; | 84 | char songs[32]; |
94 | char startingsong[32]; | 85 | char startingsong[32]; |
95 | char nsfversion[32]; | 86 | char nsfversion[32]; |
96 | struct header *head; | 87 | const struct header *head; |
97 | 88 | ||
98 | /* Check header size */ | 89 | if (size < HEADER_SIZE) |
99 | 90 | return 0; | |
100 | if (size < HEADER_SIZE) | 91 | head = (const struct header *) data; |
101 | { | ||
102 | return (prev); | ||
103 | } | ||
104 | |||
105 | head = (struct header *) data; | ||
106 | |||
107 | /* Check "magic" id bytes */ | ||
108 | |||
109 | if (memcmp (head->magicid, "NESM\x1a", 5)) | 92 | if (memcmp (head->magicid, "NESM\x1a", 5)) |
110 | { | 93 | return 0; |
111 | return (prev); | 94 | ADD ("audio/x-nsf", EXTRACTOR_METATYPE_MIMETYPE); |
112 | } | 95 | snprintf (nsfversion, |
113 | 96 | sizeof(nsfversion), | |
114 | 97 | "%d", | |
115 | /* Mime-type */ | 98 | head->nsfversion); |
116 | 99 | ADD (nsfversion, EXTRACTOR_METATYPE_FORMAT_VERSION); | |
117 | prev = addkword (prev, "audio/x-nsf", EXTRACTOR_MIMETYPE); | 100 | snprintf (songs, |
118 | 101 | sizeof(songs), | |
119 | 102 | "%d", | |
120 | /* Version of NSF format */ | 103 | head->songs); |
121 | 104 | ADD (songs, EXTRACTOR_METATYPE_SONG_COUNT); | |
122 | sprintf (nsfversion, "%d", head->nsfversion); | 105 | snprintf (startingsong, |
123 | prev = addkword (prev, nsfversion, EXTRACTOR_FORMAT_VERSION); | 106 | sizeof(startingsong), |
124 | 107 | "%d", | |
125 | 108 | head->firstsong); | |
126 | /* Get song count */ | 109 | ADD (startingsong, EXTRACTOR_METATYPE_STARTING_SONG); |
127 | |||
128 | sprintf (songs, "%d", head->songs); | ||
129 | prev = addkword (prev, songs, EXTRACTOR_SONG_COUNT); | ||
130 | |||
131 | |||
132 | /* Get number of the first song to be played */ | ||
133 | |||
134 | sprintf (startingsong, "%d", head->firstsong); | ||
135 | prev = addkword (prev, startingsong, EXTRACTOR_STARTING_SONG); | ||
136 | |||
137 | |||
138 | /* name, artist, copyright fields */ | ||
139 | 110 | ||
140 | memcpy (&album, head->title, 32); | 111 | memcpy (&album, head->title, 32); |
141 | memcpy (&artist, head->artist, 32); | ||
142 | memcpy (©right, head->copyright, 32); | ||
143 | |||
144 | album[32] = '\0'; | 112 | album[32] = '\0'; |
145 | artist[32] = '\0'; | 113 | ADD (album, EXTRACTOR_METATYPE_ALBUM); |
146 | copyright[32] = '\0'; | ||
147 | |||
148 | prev = addkword (prev, album, EXTRACTOR_ALBUM); | ||
149 | prev = addkword (prev, artist, EXTRACTOR_ARTIST); | ||
150 | prev = addkword (prev, copyright, EXTRACTOR_COPYRIGHT); | ||
151 | 114 | ||
115 | memcpy (&artist, head->artist, 32); | ||
116 | artist[32] = '\0'; | ||
117 | ADD (artist, EXTRACTOR_METATYPE_ARTIST); | ||
152 | 118 | ||
153 | /* PAL or NTSC */ | 119 | memcpy (©right, head->copyright, 32); |
120 | copyright[32] = '\0'; | ||
121 | ADD (copyright, EXTRACTOR_METATYPE_COPYRIGHT); | ||
154 | 122 | ||
155 | if (head->tvflags & DUAL_FLAG) | 123 | if (head->tvflags & DUAL_FLAG) |
156 | { | 124 | { |
157 | prev = addkword (prev, "PAL/NTSC", EXTRACTOR_TELEVISION_SYSTEM); | 125 | ADD ("PAL/NTSC", EXTRACTOR_METATYPE_BROADCAST_TELEVISION_SYSTEM); |
158 | } | 126 | } |
159 | else | 127 | else |
160 | { | 128 | { |
161 | if (head->tvflags & PAL_FLAG) | 129 | if (head->tvflags & PAL_FLAG) |
162 | { | 130 | ADD ("PAL", EXTRACTOR_METATYPE_BROADCAST_TELEVISION_SYSTEM); |
163 | prev = addkword (prev, "PAL", EXTRACTOR_TELEVISION_SYSTEM); | ||
164 | } | ||
165 | else | 131 | else |
166 | { | 132 | ADD ("NTSC", EXTRACTOR_METATYPE_BROADCAST_TELEVISION_SYSTEM); |
167 | prev = addkword (prev, "NTSC", EXTRACTOR_TELEVISION_SYSTEM); | ||
168 | } | ||
169 | } | 133 | } |
170 | 134 | ||
171 | |||
172 | /* Detect Extra Sound Chips needed to play the files */ | 135 | /* Detect Extra Sound Chips needed to play the files */ |
173 | 136 | if (head->chipflags & VRCVI_FLAG) | |
174 | if (head->chipflags & VRCVI_FLAG) | 137 | ADD ("VRCVI", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
175 | { | ||
176 | prev = addkword (prev, "VRCVI", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
177 | } | ||
178 | if (head->chipflags & VRCVII_FLAG) | 138 | if (head->chipflags & VRCVII_FLAG) |
179 | { | 139 | ADD ("VRCVII", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
180 | prev = addkword (prev, "VRCVII", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
181 | } | ||
182 | if (head->chipflags & FDS_FLAG) | 140 | if (head->chipflags & FDS_FLAG) |
183 | { | 141 | ADD ("FDS Sound", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
184 | prev = addkword (prev, "FDS Sound", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
185 | } | ||
186 | if (head->chipflags & MMC5_FLAG) | 142 | if (head->chipflags & MMC5_FLAG) |
187 | { | 143 | ADD ("MMC5 audio", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
188 | prev = addkword (prev, "MMC5 audio", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
189 | } | ||
190 | if (head->chipflags & NAMCO_FLAG) | 144 | if (head->chipflags & NAMCO_FLAG) |
191 | { | 145 | ADD ("Namco 106", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
192 | prev = addkword (prev, "Namco 106", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
193 | } | ||
194 | if (head->chipflags & SUNSOFT_FLAG) | 146 | if (head->chipflags & SUNSOFT_FLAG) |
195 | { | 147 | ADD ("Sunsoft FME-07", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
196 | prev = addkword (prev, "Sunsoft FME-07", EXTRACTOR_HARDWARE_DEPENDENCY); | 148 | return 0; |
197 | } | ||
198 | |||
199 | return (prev); | ||
200 | |||
201 | } | 149 | } |
diff --git a/src/plugins/nsfeextractor.c b/src/plugins/nsfe_extractor.c index 5d21e7e..1f3d35f 100644 --- a/src/plugins/nsfeextractor.c +++ b/src/plugins/nsfe_extractor.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | * This file is part of libextractor. | 2 | * This file is part of libextractor. |
3 | * (C) 2007 Toni Ruottu | 3 | * (C) 2007, 2009 Toni Ruottu |
4 | * | 4 | * |
5 | * libextractor is free software; you can redistribute it and/or modify | 5 | * libextractor is free software; you can redistribute it and/or modify |
6 | * it under the terms of the GNU General Public License as published | 6 | * it under the terms of the GNU General Public License as published |
@@ -60,151 +60,113 @@ struct infochunk | |||
60 | static int | 60 | static int |
61 | nsfeuint (const char *data) | 61 | nsfeuint (const char *data) |
62 | { | 62 | { |
63 | int i, value = 0; | 63 | int i; |
64 | int value = 0; | ||
64 | 65 | ||
65 | for (i = 3; i > 0; i--) | 66 | for (i = 3; i > 0; i--) |
66 | { | 67 | { |
67 | value += (unsigned char) data[i]; | 68 | value += (unsigned char) data[i]; |
68 | value *= 0x100; | 69 | value *= 0x100; |
69 | } | 70 | } |
70 | |||
71 | value += (unsigned char) data[0]; | 71 | value += (unsigned char) data[0]; |
72 | 72 | return value; | |
73 | return (value); | ||
74 | } | 73 | } |
75 | 74 | ||
75 | |||
76 | static char * | 76 | static char * |
77 | nsfestring (const char *data, int size) | 77 | nsfestring (const char *data, size_t size) |
78 | { | 78 | { |
79 | char *s; | 79 | char *s; |
80 | int length; | 80 | size_t length; |
81 | |||
82 | if (size < strlen (data)) | ||
83 | { | ||
84 | length = size; | ||
85 | } | ||
86 | else | ||
87 | { | ||
88 | length = strlen (data); | ||
89 | } | ||
90 | 81 | ||
82 | length = 0; | ||
83 | while ( (length < size) && | ||
84 | (data[length] != '\0') ) | ||
85 | length++; | ||
91 | s = malloc (length + 1); | 86 | s = malloc (length + 1); |
92 | |||
93 | strncpy (s, data, length); | 87 | strncpy (s, data, length); |
94 | |||
95 | s[strlen (data)] = '\0'; | 88 | s[strlen (data)] = '\0'; |
96 | 89 | return s; | |
97 | return (s); | ||
98 | } | 90 | } |
99 | 91 | ||
100 | static struct EXTRACTOR_Keywords *addkword | 92 | #define ADD(s,t) do { if (0 != proc (proc_cls, "nsfe", t, EXTRACTOR_METAFORMAT_UTF8, "text/plain", s, strlen(s)+1)) return 1; } while (0) |
101 | (EXTRACTOR_KeywordList * oldhead, | ||
102 | const char *phrase, EXTRACTOR_KeywordType type) | ||
103 | { | ||
104 | EXTRACTOR_KeywordList *keyword; | ||
105 | 93 | ||
106 | keyword = malloc (sizeof (EXTRACTOR_KeywordList)); | 94 | #define ADDF(s,t) do { if (0 != proc (proc_cls, "nsfe", t, EXTRACTOR_METAFORMAT_UTF8, "text/plain", s, strlen(s)+1)) { free(s); return 1; } free (s); } while (0) |
107 | keyword->next = oldhead; | ||
108 | keyword->keyword = strdup (phrase); | ||
109 | keyword->keywordType = type; | ||
110 | return (keyword); | ||
111 | } | ||
112 | 95 | ||
113 | static struct EXTRACTOR_Keywords *libextractor_nsfe_info_extract | 96 | static int |
114 | (const char *data, size_t size, struct EXTRACTOR_Keywords *prev) | 97 | libextractor_nsfe_info_extract(const char *data, |
98 | size_t size, | ||
99 | EXTRACTOR_MetaDataProcessor proc, | ||
100 | void *proc_cls) | ||
115 | { | 101 | { |
116 | const struct infochunk *ichunk; | 102 | const struct infochunk *ichunk; |
117 | char songs[32]; | 103 | char songs[32]; |
118 | 104 | ||
105 | if (size < 8) | ||
106 | return 0; | ||
119 | ichunk = (const struct infochunk *) data; | 107 | ichunk = (const struct infochunk *) data; |
120 | |||
121 | if (size < 8) | ||
122 | { | ||
123 | return (prev); | ||
124 | } | ||
125 | |||
126 | |||
127 | /* PAL or NTSC */ | ||
128 | |||
129 | if (ichunk->tvflags & DUAL_FLAG) | 108 | if (ichunk->tvflags & DUAL_FLAG) |
130 | { | 109 | { |
131 | prev = addkword (prev, "PAL/NTSC", EXTRACTOR_TELEVISION_SYSTEM); | 110 | ADD ("PAL/NTSC", EXTRACTOR_METATYPE_BROADCAST_TELEVISION_SYSTEM); |
132 | } | 111 | } |
133 | else | 112 | else |
134 | { | 113 | { |
135 | if (ichunk->tvflags & PAL_FLAG) | 114 | if (ichunk->tvflags & PAL_FLAG) |
136 | { | 115 | ADD ("PAL", EXTRACTOR_METATYPE_BROADCAST_TELEVISION_SYSTEM); |
137 | prev = addkword (prev, "PAL", EXTRACTOR_TELEVISION_SYSTEM); | ||
138 | } | ||
139 | else | 116 | else |
140 | { | 117 | ADD ("NTSC", EXTRACTOR_METATYPE_BROADCAST_TELEVISION_SYSTEM); |
141 | prev = addkword (prev, "NTSC", EXTRACTOR_TELEVISION_SYSTEM); | ||
142 | } | ||
143 | } | 118 | } |
144 | 119 | ||
145 | |||
146 | /* Detect Extra Sound Chips needed to play the files */ | ||
147 | |||
148 | if (ichunk->chipflags & VRCVI_FLAG) | 120 | if (ichunk->chipflags & VRCVI_FLAG) |
149 | { | 121 | ADD ("VRCVI", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
150 | prev = addkword (prev, "VRCVI", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
151 | } | ||
152 | if (ichunk->chipflags & VRCVII_FLAG) | 122 | if (ichunk->chipflags & VRCVII_FLAG) |
153 | { | 123 | ADD ("VRCVII", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
154 | prev = addkword (prev, "VRCVII", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
155 | } | ||
156 | if (ichunk->chipflags & FDS_FLAG) | 124 | if (ichunk->chipflags & FDS_FLAG) |
157 | { | 125 | ADD ("FDS Sound", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
158 | prev = addkword (prev, "FDS Sound", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
159 | } | ||
160 | if (ichunk->chipflags & MMC5_FLAG) | 126 | if (ichunk->chipflags & MMC5_FLAG) |
161 | { | 127 | ADD ("MMC5 audio", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
162 | prev = addkword (prev, "MMC5 audio", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
163 | } | ||
164 | if (ichunk->chipflags & NAMCO_FLAG) | 128 | if (ichunk->chipflags & NAMCO_FLAG) |
165 | { | 129 | ADD ("Namco 106", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
166 | prev = addkword (prev, "Namco 106", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
167 | } | ||
168 | if (ichunk->chipflags & SUNSOFT_FLAG) | 130 | if (ichunk->chipflags & SUNSOFT_FLAG) |
169 | { | 131 | ADD ("Sunsoft FME-07", EXTRACTOR_METATYPE_TARGET_ARCHITECTURE); |
170 | prev = addkword (prev, "Sunsoft FME-07", EXTRACTOR_HARDWARE_DEPENDENCY); | ||
171 | } | ||
172 | |||
173 | if (size < 9) | 132 | if (size < 9) |
174 | { | 133 | { |
175 | prev = addkword (prev, "1", EXTRACTOR_SONG_COUNT); | 134 | ADD ("1", EXTRACTOR_METATYPE_SONG_COUNT); |
176 | return (prev); | 135 | return 0; |
177 | } | 136 | } |
178 | 137 | snprintf (songs, | |
179 | sprintf (songs, "%d", ichunk->songs); | 138 | sizeof(songs), |
180 | prev = addkword (prev, songs, EXTRACTOR_SONG_COUNT); | 139 | "%d", |
181 | 140 | ichunk->songs); | |
182 | 141 | ADD (songs, EXTRACTOR_METATYPE_SONG_COUNT); | |
183 | return (prev); | 142 | return 0; |
184 | } | 143 | } |
185 | 144 | ||
186 | 145 | ||
187 | static struct EXTRACTOR_Keywords *libextractor_nsfe_tlbl_extract | 146 | static int |
188 | (const char *data, size_t size, struct EXTRACTOR_Keywords *prev) | 147 | libextractor_nsfe_tlbl_extract(const char *data, |
148 | size_t size, | ||
149 | EXTRACTOR_MetaDataProcessor proc, | ||
150 | void *proc_cls) | ||
151 | |||
189 | { | 152 | { |
190 | char *title; | 153 | char *title; |
191 | int left, length; | 154 | ssize_t left; |
192 | 155 | size_t length; | |
193 | 156 | ||
194 | for (left = size; left > 0; left -= length) | 157 | for (left = size; left > 0; left -= length) |
195 | { | 158 | { |
196 | title = nsfestring (&data[size - left], left); | 159 | title = nsfestring (&data[size - left], left); |
197 | prev = addkword (prev, title, EXTRACTOR_TITLE); | ||
198 | length = strlen (title) + 1; | 160 | length = strlen (title) + 1; |
199 | 161 | ADDF (title, EXTRACTOR_METATYPE_TITLE); | |
200 | free (title); | ||
201 | } | 162 | } |
202 | 163 | return 0; | |
203 | return (prev); | ||
204 | } | 164 | } |
205 | 165 | ||
206 | static struct EXTRACTOR_Keywords *libextractor_nsfe_auth_extract | 166 | static int |
207 | (const char *data, size_t size, struct EXTRACTOR_Keywords *prev) | 167 | libextractor_nsfe_auth_extract (const char *data, size_t size, |
168 | EXTRACTOR_MetaDataProcessor proc, | ||
169 | void *proc_cls) | ||
208 | { | 170 | { |
209 | char *album; | 171 | char *album; |
210 | char *artist; | 172 | char *artist; |
@@ -213,48 +175,28 @@ static struct EXTRACTOR_Keywords *libextractor_nsfe_auth_extract | |||
213 | int left = size; | 175 | int left = size; |
214 | 176 | ||
215 | if (left < 1) | 177 | if (left < 1) |
216 | { | 178 | return 0; |
217 | return (prev); | ||
218 | } | ||
219 | |||
220 | album = nsfestring (&data[size - left], left); | 179 | album = nsfestring (&data[size - left], left); |
221 | prev = addkword (prev, album, EXTRACTOR_ALBUM); | ||
222 | |||
223 | left -= (strlen (album) + 1); | 180 | left -= (strlen (album) + 1); |
224 | free (album); | 181 | ADDF (album, EXTRACTOR_METATYPE_ALBUM); |
225 | 182 | if (left < 1) | |
226 | if (left < 1) | 183 | return 0; |
227 | { | ||
228 | return (prev); | ||
229 | } | ||
230 | 184 | ||
231 | artist = nsfestring (&data[size - left], left); | 185 | artist = nsfestring (&data[size - left], left); |
232 | prev = addkword (prev, artist, EXTRACTOR_ARTIST); | ||
233 | |||
234 | left -= (strlen (artist) + 1); | 186 | left -= (strlen (artist) + 1); |
235 | free (artist); | 187 | ADDF (artist, EXTRACTOR_METATYPE_ARTIST); |
236 | 188 | if (left < 1) | |
237 | if (left < 1) | 189 | return 0; |
238 | { | ||
239 | return (prev); | ||
240 | } | ||
241 | 190 | ||
242 | copyright = nsfestring (&data[size - left], left); | 191 | copyright = nsfestring (&data[size - left], left); |
243 | prev = addkword (prev, copyright, EXTRACTOR_COPYRIGHT); | ||
244 | |||
245 | left -= (strlen (copyright) + 1); | 192 | left -= (strlen (copyright) + 1); |
246 | free (copyright); | 193 | ADDF (copyright, EXTRACTOR_METATYPE_COPYRIGHT); |
247 | |||
248 | if (left < 1) | 194 | if (left < 1) |
249 | { | 195 | return 0; |
250 | return (prev); | ||
251 | } | ||
252 | 196 | ||
253 | ripper = nsfestring (&data[size - left], left); | 197 | ripper = nsfestring (&data[size - left], left); |
254 | prev = addkword (prev, ripper, EXTRACTOR_RIPPER); | 198 | ADDF (ripper, EXTRACTOR_METATYPE_RIPPER); |
255 | free (ripper); | 199 | return 0; |
256 | |||
257 | return (prev); | ||
258 | } | 200 | } |
259 | 201 | ||
260 | 202 | ||
@@ -265,70 +207,45 @@ static struct EXTRACTOR_Keywords *libextractor_nsfe_auth_extract | |||
265 | * originally written. | 207 | * originally written. |
266 | * | 208 | * |
267 | */ | 209 | */ |
268 | struct EXTRACTOR_Keywords *libextractor_nsfe_extract | 210 | int |
269 | (const char *filename, | 211 | EXTRACTOR_nsfe_extract (const char *data, |
270 | const char *data, size_t size, struct EXTRACTOR_Keywords *prev) | 212 | size_t size, |
213 | EXTRACTOR_MetaDataProcessor proc, | ||
214 | void *proc_cls, | ||
215 | const char *options) | ||
271 | { | 216 | { |
272 | const struct header *head; | 217 | const struct header *head; |
273 | int i; | 218 | int i; |
274 | char chunkid[5] = " "; | 219 | char chunkid[5] = " "; |
220 | int ret; | ||
275 | 221 | ||
276 | /* Check header size */ | 222 | if (size < HEADER_SIZE) |
277 | 223 | return 0; | |
278 | if (size < HEADER_SIZE) | ||
279 | { | ||
280 | return (prev); | ||
281 | } | ||
282 | |||
283 | head = (const struct header *) data; | 224 | head = (const struct header *) data; |
284 | 225 | if (memcmp (head->magicid, "NSFE", 4)) | |
285 | /* Check "magic" id bytes */ | 226 | return 0; |
286 | 227 | ADD ("audio/x-nsfe", EXTRACTOR_METATYPE_MIMETYPE); | |
287 | if (memcmp (head->magicid, "NSFE", 4)) | ||
288 | { | ||
289 | return (prev); | ||
290 | } | ||
291 | |||
292 | |||
293 | /* Mime-type */ | ||
294 | |||
295 | prev = addkword (prev, "audio/x-nsfe", EXTRACTOR_MIMETYPE); | ||
296 | |||
297 | i = 4; /* Jump over magic id */ | 228 | i = 4; /* Jump over magic id */ |
298 | 229 | ret = 0; | |
299 | while (i + 7 < size && strncmp (chunkid, "NEND", 4)) /* CHECK */ | 230 | while (i + 7 < size && strncmp (chunkid, "NEND", 4)) /* CHECK */ |
300 | { | 231 | { |
301 | |||
302 | unsigned int chunksize = nsfeuint (&data[i]); | 232 | unsigned int chunksize = nsfeuint (&data[i]); |
303 | 233 | ||
304 | i += 4; /* Jump over chunk size */ | 234 | i += 4; /* Jump over chunk size */ |
305 | |||
306 | memcpy (&chunkid, data + i, 4); | 235 | memcpy (&chunkid, data + i, 4); |
307 | chunkid[4] = '\0'; | 236 | chunkid[4] = '\0'; |
308 | 237 | ||
309 | i += 4; /* Jump over chunk id */ | 238 | i += 4; /* Jump over chunk id */ |
310 | |||
311 | if (!strncmp (chunkid, "INFO", 4)) | 239 | if (!strncmp (chunkid, "INFO", 4)) |
312 | { | 240 | ret = libextractor_nsfe_info_extract (data + i, chunksize, proc, proc_cls); |
313 | prev = libextractor_nsfe_info_extract (data + i, chunksize, prev); | 241 | else if (!strncmp (chunkid, "auth", 4)) |
314 | } | 242 | ret = libextractor_nsfe_auth_extract (data + i, chunksize, proc, proc_cls); |
315 | 243 | else if (!strncmp (chunkid, "tlbl", 4)) | |
316 | if (!strncmp (chunkid, "auth", 4)) | 244 | ret = libextractor_nsfe_tlbl_extract (data + i, chunksize, proc, proc_cls); |
317 | { | ||
318 | prev = libextractor_nsfe_auth_extract (data + i, chunksize, prev); | ||
319 | } | ||
320 | |||
321 | if (!strncmp (chunkid, "tlbl", 4)) | ||
322 | { | ||
323 | prev = libextractor_nsfe_tlbl_extract (data + i, chunksize, prev); | ||
324 | } | ||
325 | |||
326 | /* Ignored chunks: DATA, NEND, plst, time, fade, BANK */ | 245 | /* Ignored chunks: DATA, NEND, plst, time, fade, BANK */ |
327 | |||
328 | i += chunksize; | 246 | i += chunksize; |
329 | 247 | if (ret != 0) | |
248 | break; | ||
330 | } | 249 | } |
331 | 250 | return ret; | |
332 | return (prev); | ||
333 | |||
334 | } | 251 | } |