only use the width for video thumbnails to keep the correct scaling

[mediagoblin.git] / mediagoblin / media_types / video / processing.py

diff --git a/mediagoblin/media_types/video/processing.py b/mediagoblin/media_types/video/processing.py
index 4d7d9921b8f100f63f0307d7ae8344bda5e54b60..ed224251acebe65bb2d9fafddbad8821a914dfe1 100644 (file)
--- a/mediagoblin/media_types/video/processing.py
+++ b/mediagoblin/media_types/video/processing.py
@@ -24,7 +24,7 @@ from mediagoblin.processing import (
     FilenameBuilder, BaseProcessingFail,
     ProgressCallback, MediaProcessor,
     ProcessingManager, request_from_args,
-    get_orig_filename, store_public,
+    get_process_filename, store_public,
     copy_original)
 from mediagoblin.tools.translate import lazy_pass_to_ugettext as _
 
@@ -122,15 +122,16 @@ class CommonVideoProcessor(MediaProcessor):
     """
     Provides a base for various video processing steps
     """
+    acceptable_files = ['original', 'best_quality', 'webm_video']
 
     def common_setup(self):
         self.video_config = mgg \
             .global_config['media_type:mediagoblin.media_types.video']
 
-        # Pull down and set up the original file
-        self.orig_filename = get_orig_filename(
-            self.entry, self.workbench)
-        self.name_builder = FilenameBuilder(self.orig_filename)
+        # Pull down and set up the processing file
+        self.process_filename = get_process_filename(
+            self.entry, self.workbench, self.acceptable_files)
+        self.name_builder = FilenameBuilder(self.process_filename)
 
         self.transcoder = transcoders.VideoTranscoder()
         self.did_transcode = False
@@ -140,14 +141,26 @@ class CommonVideoProcessor(MediaProcessor):
         if not self.did_transcode or \
            (self.video_config['keep_original'] and self.did_transcode):
             copy_original(
-                self.entry, self.orig_filename,
+                self.entry, self.process_filename,
                 self.name_builder.fill('{basename}{ext}'))
 
+    def _keep_best(self):
+        """
+        If there is no original, keep the best file that we have
+        """
+        if not self.entry.media_files.get('best_quality'):
+            # Save the best quality file if no original?
+            if not self.entry.media_files.get('original') and \
+                    self.entry.media_files.get('webm_video'):
+                self.entry.media_files['best_quality'] = self.entry \
+                    .media_files['webm_video']
+
+
     def transcode(self, medium_size=None, vp8_quality=None, vp8_threads=None,
                   vorbis_quality=None):
         progress_callback = ProgressCallback(self.entry)
         tmp_dst = os.path.join(self.workbench.dir,
-                               self.name_builder.fill('{basename}-640p.webm'))
+                               self.name_builder.fill('{basename}.medium.webm'))
 
         if not medium_size:
             medium_size = (
@@ -161,7 +174,7 @@ class CommonVideoProcessor(MediaProcessor):
             vorbis_quality = self.video_config['vorbis_quality']
 
         # Extract metadata and keep a record of it
-        metadata = self.transcoder.discover(self.orig_filename)
+        metadata = self.transcoder.discover(self.process_filename)
         store_metadata(self.entry, metadata)
 
         # Figure out whether or not we need to transcode this video or
@@ -171,8 +184,14 @@ class CommonVideoProcessor(MediaProcessor):
 
             dst_dimensions = metadata['videowidth'], metadata['videoheight']
 
+            # If there is an original and transcoded, delete the transcoded
+            # since it must be of lower quality then the original
+            if self.entry.media_files.get('original') and \
+               self.entry.media_files.get('webm_video'):
+                self.entry.media_files['webm_video'].delete()
+
         else:
-            self.transcoder.transcode(self.orig_filename, tmp_dst,
+            self.transcoder.transcode(self.process_filename, tmp_dst,
                                       vp8_quality=vp8_quality,
                                       vp8_threads=vp8_threads,
                                       vorbis_quality=vorbis_quality,
@@ -182,10 +201,12 @@ class CommonVideoProcessor(MediaProcessor):
             dst_dimensions = self.transcoder.dst_data.videowidth,\
                 self.transcoder.dst_data.videoheight
 
+            self._keep_best()
+
             # Push transcoded video to public storage
             _log.debug('Saving medium...')
-            store_public(self.entry, 'webm_640', tmp_dst,
-                         self.name_builder.fill('{basename}-640p.webm'))
+            store_public(self.entry, 'webm_video', tmp_dst,
+                         self.name_builder.fill('{basename}.medium.webm'))
             _log.debug('Saved medium')
 
             self.did_transcode = True
@@ -202,14 +223,13 @@ class CommonVideoProcessor(MediaProcessor):
                                      '{basename}.thumbnail.jpg'))
 
         if not thumb_size:
-            thumb_size = (mgg.global_config['media:thumb']['max_width'],
-                          mgg.global_config['media:thumb']['max_height'])
+            thumb_size = (mgg.global_config['media:thumb']['max_width'])
 
+        # We will only use the width so that the correct scale is kept
         transcoders.VideoThumbnailerMarkII(
-            self.orig_filename,
+            self.process_filename,
             tmp_thumb,
-            thumb_size[0],
-            thumb_size[1])
+            thumb_size[0])
 
         # Push the thumbnail to public storage
         _log.debug('Saving thumbnail...')