import timeside.core
import timeside.server as ts
import sys
-
+import time
class ItemBaseMixin(TelemetaBaseMixin):
list.append('mp4')
return list
- def item_export(self, request, public_id, extension):
+ def item_transcode(self, item, extension):
+ for encoder in self.encoders:
+ if encoder.file_extension() == extension:
+ break
+
+ if encoder.file_extension() != extension:
+ raise Http404('Unknown export file extension: %s' % extension)
+
+ mime_type = encoder.mime_type()
+ file = item.public_id + '.' + encoder.file_extension()
+ source, source_type = item.get_source()
+ try:
+ is_transcoded_flag, c = MediaItemTranscodingFlag.objects.get_or_create(
+ item=item,
+ mime_type=mime_type,
+ defaults={'value':False})
+ except MediaItemTranscodingFlag.MultipleObjectsReturned:
+ flags = MediaItemTranscodingFlag.objects.filter(
+ item=item,
+ mime_type=mime_type)
+ value = all([f.value for f in flags])
+ is_transcoded_flag = flags[0]
+ is_transcoded_flag.value = value
+ is_transcoded_flag.save()
+ for f in flags[1:]:
+ f.delete()
+
+
+ format = item.mime_type
+ dc_metadata = dublincore.express_item(item).to_list()
+ mapping = DublinCoreToFormatMetadata(extension)
+ if not extension in mapping.unavailable_extensions:
+ metadata = mapping.get_metadata(dc_metadata)
+ else:
+ metadata = None
+
+ if mime_type in format and source_type == 'file':
+ # source > stream
+ if metadata:
+ proc = encoder(source, overwrite=True)
+ proc.set_metadata(metadata)
+ try:
+ # FIXME: should test if metadata writer is available
+ proc.write_metadata()
+ except:
+ pass
+ return (source, mime_type)
+ else:
+ media = self.cache_export.dir + os.sep + file
+ if not is_transcoded_flag.value:
+ try:
+ progress_flag = MediaItemTranscodingFlag.objects.get(
+ item=item,
+ mime_type=mime_type + '/transcoding')
+ if progress_flag.value:
+ # The media is being transcoded
+ # return None
+ return (None, None)
+
+ else:
+ # wait for the transcode to begin
+ time.sleep(1)
+ return (None, None) #self.item_transcode(item, extension)
+
+ except MediaItemTranscodingFlag.DoesNotExist:
+ pass
+ # source > encoder > stream
+ from telemeta.tasks import task_transcode
+ # Sent the transcoding task synchronously to the worker
+ task_transcode.apply_async(kwargs={'source':source,
+ 'media':media,
+ 'encoder_id':encoder.id(),
+ 'item_public_id':item.public_id,
+ 'mime_type':mime_type,
+ 'metadata':metadata})
+
+ self.cache_export.add_file(file)
+ if not os.path.exists(media):
+ return (None, None)
+ else:
+ # cache > stream
+ if not os.path.exists(media):
+ is_transcoded_flag.value = False
+ is_transcoded_flag.save()
+ return self.item_transcode(item, extension)
+
+ return (media, mime_type)
+
+ def item_export(self, request, public_id, extension, return_availability=False):
"""Export a given media item in the specified format (OGG, FLAC, ...)"""
item = MediaItem.objects.get(public_id=public_id)
# response['Content-Disposition'] = 'attachment'
# TF : I don't know why empty attachment was set
# TODO: remove if useless
+ if return_availability:
+ return True
return response
if 'webm' in extension:
# response['Content-Disposition'] = 'attachment'
# TF : I don't know why empty attachment was set,
# TODO: remove if useless
+ if return_availability:
+ data = json.dumps({'available':True})
+ return HttpResponse(data, content_type='application/json')
+ return response
+
+ (media, mime_type) = self.item_transcode(item, extension)
+ #media = None
+ if media:
+ if return_availability:
+ data = json.dumps({'available':True})
+ return HttpResponse(data, content_type='application/json')
+ response = serve_media(media, content_type=mime_type)
return response
-
- for encoder in self.encoders:
- if encoder.file_extension() == extension:
- break
-
- if encoder.file_extension() != extension:
- raise Http404('Unknown export file extension: %s' % extension)
-
- mime_type = encoder.mime_type()
- file = public_id + '.' + encoder.file_extension()
- source, source_type = item.get_source()
-
- flag = MediaItemTranscodingFlag.objects.filter(item=item, mime_type=mime_type)
- if not flag:
- flag = MediaItemTranscodingFlag(item=item, mime_type=mime_type)
- flag.value = False
- flag.save()
- else:
- flag = flag[0]
-
- format = item.mime_type
- dc_metadata = dublincore.express_item(item).to_list()
- mapping = DublinCoreToFormatMetadata(extension)
- metadata = mapping.get_metadata(dc_metadata)
-
- if mime_type in format and source_type == 'file':
- # source > stream
- if not extension in mapping.unavailable_extensions:
- proc = encoder(source, overwrite=True)
- proc.set_metadata(metadata)
- try:
- # FIXME: should test if metadata writer is available
- proc.write_metadata()
- except:
- pass
- response = serve_media(source, content_type=mime_type)
else:
- media = self.cache_export.dir + os.sep + file
- if not os.path.exists(media) or not flag.value:
- # source > encoder > stream
- if extension in mapping.unavailable_extensions:
- metadata = None
-
- decoder = timeside.core.get_processor('file_decoder')(source)
- processor = encoder(media, streaming=False,
- overwrite=True)
- if metadata:
- processor.set_metadata(metadata)
- pipe = decoder | processor
- pipe.run()
-
- self.cache_export.add_file(file)
- flag.value = True
- flag.save()
-
- response = serve_media(media, content_type=mime_type) # , buffering=False)
-
- else:
- # cache > stream
- response = serve_media(media, content_type=mime_type)
+ if return_availability:
+ data = json.dumps({'available':False})
+ return HttpResponse(data, content_type='application/json')
+
+ mess = ugettext('Transcoding in progress')
+ title = ugettext('Item') + ' : ' + public_id + ' : ' + mess
+ description = ugettext('The media transcoding is in progress. '
+ 'Please wait for the trancoding process to complete.')
+ messages.info(request, title)
+ response = render(request, 'telemeta/messages.html', {'description': description})
+ from django.utils.cache import patch_cache_control
+ #patch_cache_control(response, no_cache=True, no_store=True, must_revalidate=True)
+ return response
- return response
+ def item_export_available(self, request, public_id, extension):
+ return self.item_export(request, public_id, extension, return_availability=True)
+
def item_playlist(self, request, public_id, template, mimetype):
try:
def item_analyze(self, item):
analyses = item.analysis.all()
+ encoders_id = ['mp3_encoder']#, 'vorbis_encoder']
mime_type = ''
if analyses:
analyzers = []
analyzers_sub = []
graphers_sub = []
+ encoders_sub = []
- source, _ = item.get_source()
+ source = item.get_source()[0]
if source:
path = self.cache_data.dir + os.sep + image_file
graph = default_grapher(width=int(width), height=int(height))
graphers_sub.append({'graph': graph, 'path': path})
- pipe = pipe | graph
+ pipe |= graph
+
+ for proc_id in encoders_id:
+ encoder_cls = timeside.core.get_processor(proc_id)
+ mime_type = encoder_cls.mime_type()
+ cache_file = item.public_id + '.' + encoder_cls.file_extension()
+ media = self.cache_export.dir + os.sep + cache_file
+ encoder = encoder_cls(output=media, overwrite=True)
+ encoders_sub.append(encoder)
+ pipe |= encoder
+
pipe.run()
analyzer_id=result.id, unit=result.unit, value=unicode(value))
analysis.save()
+ for encoder in encoders_sub:
+ pass
# FIXME: parse tags on first load
# tags = decoder.tags
projects / telemeta.git / commitdiff