|
a/src/filters/rclaudio |
|
b/src/filters/rclaudio |
|
... |
|
... |
| 234 |
self.em.rclog("extractone: no mime or file name")
|
234 |
self.em.rclog("extractone: no mime or file name")
|
| 235 |
return (ok, docdata, "", rclexecm.RclExecM.eofnow)
|
235 |
return (ok, docdata, "", rclexecm.RclExecM.eofnow)
|
| 236 |
filename = params["filename:"]
|
236 |
filename = params["filename:"]
|
| 237 |
mimetype = params["mimetype:"]
|
237 |
mimetype = params["mimetype:"]
|
| 238 |
self.filename = filename
|
238 |
self.filename = filename
|
|
|
239 |
#self.em.rclog("%s" % filename)
|
| 239 |
try:
|
240 |
try:
|
| 240 |
mutf = File(filename)
|
241 |
mutf = File(filename)
|
| 241 |
except Exception as err:
|
242 |
except Exception as err:
|
| 242 |
self.em.rclog("extractone: extract failed: [%s]" % err)
|
243 |
self.em.rclog("extractone: extract failed: [%s]" % err)
|
| 243 |
return (ok, docdata, "", rclexecm.RclExecM.eofnow)
|
244 |
return (ok, docdata, "", rclexecm.RclExecM.eofnow)
|
|
... |
|
... |
| 245 |
#self._showMutaInfo(mutf)
|
246 |
#self._showMutaInfo(mutf)
|
| 246 |
|
247 |
|
| 247 |
###################
|
248 |
###################
|
| 248 |
# Extract audio parameters. Not all file types supply all or
|
249 |
# Extract audio parameters. Not all file types supply all or
|
| 249 |
# even use the same property names...
|
250 |
# even use the same property names...
|
|
|
251 |
# minf has natural str keys, and encoded values
|
| 250 |
minf = {}
|
252 |
minf = {}
|
| 251 |
for prop,dflt in [('sample_rate', 44100), ('channels', 2),
|
253 |
for prop,dflt in [('sample_rate', 44100), ('channels', 2),
|
| 252 |
('length', 0), ('bitrate', 0)]:
|
254 |
('length', 0), ('bitrate', 0)]:
|
| 253 |
try:
|
255 |
try:
|
| 254 |
minf[prop] = getattr(mutf.info, prop)
|
256 |
minf[prop] = getattr(mutf.info, prop)
|
|
... |
|
... |
| 256 |
#self.em.rclog("NO %s prop: %s" % (prop, e))
|
258 |
#self.em.rclog("NO %s prop: %s" % (prop, e))
|
| 257 |
minf[prop] = dflt
|
259 |
minf[prop] = dflt
|
| 258 |
|
260 |
|
| 259 |
if minf['bitrate'] == 0 and minf['length'] > 0:
|
261 |
if minf['bitrate'] == 0 and minf['length'] > 0:
|
| 260 |
br = int(os.path.getsize(filename)* 8 / minf['length'])
|
262 |
br = int(os.path.getsize(filename)* 8 / minf['length'])
|
| 261 |
minf['bitrate'] = str(br)
|
263 |
minf['bitrate'] = br
|
| 262 |
|
264 |
|
| 263 |
minf['duration'] = minf['length']
|
265 |
minf['duration'] = minf['length']
|
| 264 |
del minf['length']
|
266 |
del minf['length']
|
| 265 |
|
267 |
|
| 266 |
# Bits/samp is named sample_size or bits_per_sample (depend on file tp)
|
268 |
# Bits/samp is named sample_size or bits_per_sample (depend on file tp)
|
|
... |
|
... |
| 272 |
except:
|
274 |
except:
|
| 273 |
#self.em.rclog("using default bits_per_sample")
|
275 |
#self.em.rclog("using default bits_per_sample")
|
| 274 |
minf['bits_per_sample'] = 16
|
276 |
minf['bits_per_sample'] = 16
|
| 275 |
|
277 |
|
| 276 |
for tag,val in minf.items():
|
278 |
for tag,val in minf.items():
|
|
|
279 |
val = str(val)
|
|
|
280 |
if type(val) == type(u''):
|
|
|
281 |
val = val.encode('utf-8', errors='replace')
|
| 277 |
minf[tag] = str(val)
|
282 |
minf[tag] = val
|
| 278 |
|
|
|
| 279 |
#self.em.rclog("minf after audio %s\n" % minf)
|
|
|
| 280 |
|
283 |
|
| 281 |
####################
|
284 |
####################
|
| 282 |
# Metadata tags. The names vary depending on the file type. We
|
285 |
# Metadata tags. The names vary depending on the file type. We
|
| 283 |
# just have a big translation dictionary for all
|
286 |
# just have a big translation dictionary for all
|
| 284 |
for tag,val in mutf.items():
|
287 |
for tag,val in mutf.items():
|
| 285 |
#self.em.rclog("Original tag: <%s>, val <%s>" % (tag, val))
|
288 |
#self.em.rclog("Original tag: <%s>, val <%s>" % (tag, val))
|
|
... |
|
... |
| 287 |
tag = tag.upper()
|
290 |
tag = tag.upper()
|
| 288 |
if tag in tagdict:
|
291 |
if tag in tagdict:
|
| 289 |
ntag = tagdict[tag].lower()
|
292 |
ntag = tagdict[tag].lower()
|
| 290 |
#self.em.rclog("New tag: %s" % ntag)
|
293 |
#self.em.rclog("New tag: %s" % ntag)
|
| 291 |
try:
|
294 |
try:
|
| 292 |
if isinstance(val, bool):
|
295 |
if type(val) == type(u''):
|
|
|
296 |
val = val.encode('utf-8', errors='replace')
|
|
|
297 |
elif type(val) != type(b''):
|
| 293 |
val0 = str(val)
|
298 |
val = str(val)
|
| 294 |
else:
|
|
|
| 295 |
try:
|
|
|
| 296 |
val0 = val[0]
|
|
|
| 297 |
except:
|
|
|
| 298 |
val0 = val
|
|
|
| 299 |
if val0:
|
|
|
| 300 |
if type(val0) == type(u""):
|
299 |
if type(val) == type(u''):
|
| 301 |
val0 = val0.encode('utf-8', errors='replace')
|
300 |
val = val.encode('utf-8', errors='replace')
|
| 302 |
else:
|
|
|
| 303 |
val0 = str(val0)
|
|
|
| 304 |
minf[ntag] = val0
|
301 |
minf[ntag] = val
|
| 305 |
#self.em.rclog("Tag %s -> %s" % (ntag, val0))
|
302 |
#self.em.rclog("Tag %s -> %s" % (ntag, val0))
|
| 306 |
except Exception as err:
|
303 |
except Exception as err:
|
| 307 |
self.em.rclog("Error while extracting tag: %s"%err)
|
304 |
self.em.rclog("Error while extracting tag: %s"%err)
|
| 308 |
else:
|
305 |
else:
|
| 309 |
#self.em.rclog("Unprocessed tag: %s, value %s"%(tag,val))
|
306 |
#self.em.rclog("Unprocessed tag: %s, value %s"%(tag,val))
|
| 310 |
pass
|
307 |
pass
|
|
|
308 |
|
|
|
309 |
#self.em.rclog("minf after extract %s\n" % minf)
|
| 311 |
|
310 |
|
| 312 |
# TPA,TPOS,disc DISCNUMBER/TOTALDISCS
|
311 |
# TPA,TPOS,disc DISCNUMBER/TOTALDISCS
|
| 313 |
# TRCK,TRK,trkn TRACKNUMBER/TOTALTRACKS
|
312 |
# TRCK,TRK,trkn TRACKNUMBER/TOTALTRACKS
|
| 314 |
for what in ('disc', 'track'):
|
313 |
for what in ('disc', 'track'):
|
| 315 |
k = what + 'number'
|
314 |
k = what + 'number'
|
|
... |
|
... |
| 320 |
if mo:
|
319 |
if mo:
|
| 321 |
l = (mo.group(1), mo.group(2))
|
320 |
l = (mo.group(1), mo.group(2))
|
| 322 |
else:
|
321 |
else:
|
| 323 |
l = l.split(b'/')
|
322 |
l = l.split(b'/')
|
| 324 |
else:
|
323 |
else:
|
| 325 |
self.em.rclog("l is tuple: %s" %l)
|
324 |
self.em.rclog("l is tuple: %s tp1 %s tp2 %S" %
|
|
|
325 |
(l, type(l[0]), type(l[1])))
|
| 326 |
if len(l) == 2:
|
326 |
if len(l) == 2:
|
| 327 |
minf[k] = str(l[0])
|
327 |
minf[k] = l[0]
|
| 328 |
#self.em.rclog("minf[%s] = %s" % (k, minf[k]))
|
328 |
#self.em.rclog("minf[%s] = %s" % (k, minf[k]))
|
| 329 |
if l[1] != 0:
|
329 |
if l[1] != 0:
|
| 330 |
minf['total' + what + 's'] = str(l[1])
|
330 |
minf['total' + what + 's'] = l[1]
|
| 331 |
|
331 |
|
| 332 |
if 'orchestra' in minf:
|
332 |
if 'orchestra' in minf:
|
| 333 |
val = minf['orchestra']
|
333 |
val = minf['orchestra']
|
| 334 |
if val.startswith('orchestra='):
|
334 |
if val.startswith(b'orchestra='):
|
| 335 |
minf['orchestra'] = val[10:]
|
335 |
minf['orchestra'] = val[10:]
|
| 336 |
|
336 |
|
| 337 |
#self.em.rclog("minf after tags %s\n" % minf)
|
337 |
#self.em.rclog("minf after tags %s\n" % minf)
|
| 338 |
|
338 |
|
| 339 |
# Check for embedded image. We just set a flag.
|
339 |
# Check for embedded image. We just set a flag.
|
| 340 |
embdimg = self._embeddedImageFormat(mutf)
|
340 |
embdimg = self._embeddedImageFormat(mutf)
|
| 341 |
if embdimg:
|
341 |
if embdimg:
|
| 342 |
#self.em.rclog("Embedded image format: %s" % embdimg)
|
342 |
#self.em.rclog("Embedded image format: %s" % embdimg)
|
|
|
343 |
if type(embdimg) == type(u''):
|
|
|
344 |
minf["embdimg"] = embdimg.encode('ascii', errors='replace')
|
|
|
345 |
else:
|
| 343 |
minf["embdimg"] = embdimg
|
346 |
minf["embdimg"] = embdimg
|
| 344 |
|
347 |
|
| 345 |
self.em.setmimetype("text/plain")
|
348 |
self.em.setmimetype("text/plain")
|
| 346 |
self.em.setfield("charset", 'utf-8')
|
349 |
self.em.setfield("charset", 'utf-8')
|
| 347 |
|
350 |
|
| 348 |
for tag,val in minf.items():
|
351 |
for tag,val in minf.items():
|