Made the following variables (which deal with the new image resizing code) local...

[mir.git] / source / mircoders / media / MediaHandlerImagesExtern.java

diff --git a/source/mircoders/media/MediaHandlerImagesExtern.java b/source/mircoders/media/MediaHandlerImagesExtern.java
index ac96478..c4fff5a 100755 (executable)
--- a/source/mircoders/media/MediaHandlerImagesExtern.java
+++ b/source/mircoders/media/MediaHandlerImagesExtern.java
@@ -33,8 +33,11 @@ package mircoders.media;
 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.FileOutputStream;
 import java.io.InputStream;
+import java.io.OutputStream;
 
+import mir.util.StreamCopier;
 import mir.entity.Entity;
 import mir.log.LoggerWrapper;
 import mir.media.MediaExc;
@@ -42,6 +45,7 @@ import mir.media.MediaFailure;
 import mir.media.image.ImageProcessor;
 import mir.media.image.ImageMagickImageProcessor;
 import mir.misc.StringUtil;
+import mir.util.FileRoutines;
 
 /**
  * Image handler that stores images outside of the database.
@@ -52,20 +56,26 @@ import mir.misc.StringUtil;
 
 public class MediaHandlerImagesExtern extends MediaHandlerGeneric
 {
+  private int maxSize;
   private int maxIconSize;
   private float minDescaleRatio;
   private int minDescaleReduction;
-
+  private boolean scaleImages;
+  
   public MediaHandlerImagesExtern() {
-
     logger = new LoggerWrapper("Media.Images.Extern");
-
+    maxSize = configuration.getInt("Producer.Image.MaxSize");
     maxIconSize = configuration.getInt("Producer.Image.MaxIconSize");
     minDescaleRatio = configuration.getFloat("Producer.Image.MinDescalePercentage")/100;
     minDescaleReduction = configuration.getInt("Producer.Image.MinDescaleReduction");
+    scaleImages = configuration.getBoolean("Producer.Image.ScaleImages");
   }
 
   public void produce(Entity anImageEntity, Entity mediaTypeEnt) throws MediaExc, MediaFailure {
+       String imagesOriginalDir = configuration.getString("Producer.ImagesOriginalDir.Path"); ;
+       String imagesOriginalDirRelPath = configuration.getString("Producer.ImagesOriginalDir.RelPath");;
+       String imageOriginalFilePath;
+       String imageOriginalRelPath;
     try {
       String date = anImageEntity.getFieldValue("date");
       String datePath = StringUtil.webdbDate2path(date);
@@ -75,41 +85,91 @@ public class MediaHandlerImagesExtern extends MediaHandlerGeneric
       String iconPath = getBaseIconStoragePath() + fileBasePath + ".jpg";
       String iconStoragePath = configuration.getString("Producer.StorageRoot") + iconPath;
       String imageFilePath = getBaseStoragePath() + File.separator + filePath;
-
+      
+      // yoss: get a file path where the the original image should be saved if image resizing is turned on
+      imageOriginalFilePath = imagesOriginalDir + filePath;
+      imageOriginalRelPath = imagesOriginalDirRelPath +  filePath;
+      
+      // yoss:make a new File object for the originalFile
+      File originalFile = new File(imageOriginalFilePath);   
+      logger.info("imageOriginalFilePath:" + imageOriginalFilePath);
       File imageFile = new File(imageFilePath);
+      logger.info("******************************************");
+      logger.info("imageFile exists: " + imageFile.exists());
+      logger.info("imageFile: " + imageFile.getAbsolutePath());
       File iconFile = new File(iconStoragePath);
-
+      logger.info("iconStoragePath:"+ iconStoragePath);
+      
+      
       if (!imageFile.exists()) {
-        throw new MediaExc("error in MediaHandlerImagesExtern.execute(): " + filePath + " does not exist!");
-      }
-      else {
+        throw new MediaExc("error in MediaHandlerImagesExtern.execute(): "
+            + filePath + " does not exist!");
+      } else {
         ImageProcessor processor = new ImageMagickImageProcessor(imageFile);
-
-        processor.descaleImage(maxIconSize, minDescaleRatio, minDescaleReduction);
+        processor.descaleImage(maxIconSize, minDescaleRatio,
+            minDescaleReduction);
         File dir = new File(iconFile.getParent());
-          if (dir!=null && !dir.exists()){
-            dir.mkdirs();
+        if (dir != null && !dir.exists()) {
+          dir.mkdirs();
         }
         processor.writeScaledData(iconFile, "JPEG");
 
-        anImageEntity.setFieldValue("img_height", new Integer(processor.getHeight()).toString());
-        anImageEntity.setFieldValue("img_width", new Integer(processor.getWidth()).toString());
+        // yoss: if the config is set so that images should be scaled, make the
+        // resized file.
+        if (scaleImages) {
+          logger.info("entered scaleImages");
+          ImageProcessor originalProcessor = new ImageMagickImageProcessor(
+              imageFile);
+          originalProcessor.descaleImage(maxSize, minDescaleRatio,
+              minDescaleReduction);
+          File originalDir = new File(originalFile.getParent());
+          if (originalDir != null && !originalDir.exists()) {
+            originalDir.mkdirs();
+          }
+          if (!originalFile.exists()) {
+            logger.debug("the original image file doesn't exist, copying to originalFile");
+            FileRoutines.copy(imageFile, originalFile);
+          }
+          // yoss: don't write the scaled data again if it's the same size as
+          // the file that's there right now. Image producer runs are 4 times
+          // faster this way.
+          logger.info("about to write scaled data, byte length: "
+              + originalProcessor.getScaledFileSize());
+          if (originalProcessor.getScaledFileSize() != imageFile.length()) {
+            originalProcessor.writeScaledData(imageFile, "JPEG");
+          }
+          anImageEntity.setFieldValue("original_file_path",
+              imageOriginalRelPath);
+          anImageEntity.setFieldValue("img_height", Integer
+              .toString(originalProcessor.getScaledHeight()));
+          anImageEntity.setFieldValue("img_width", Integer
+              .toString(originalProcessor.getScaledWidth()));
+
+          originalProcessor.cleanup();
+
+        } else {
+          anImageEntity.setFieldValue("img_height", new Integer(processor
+              .getHeight()).toString());
+          anImageEntity.setFieldValue("img_width", new Integer(processor
+              .getWidth()).toString());
+        }
 
-        anImageEntity.setFieldValue("icon_height", new Integer(processor.getScaledHeight()).toString());
-        anImageEntity.setFieldValue("icon_width", new Integer(processor.getScaledWidth()).toString());
+        anImageEntity.setFieldValue("icon_height", new Integer(processor
+            .getScaledHeight()).toString());
+        anImageEntity.setFieldValue("icon_width", new Integer(processor
+            .getScaledWidth()).toString());
 
         processor.cleanup();
+
         anImageEntity.setFieldValue("icon_path", iconPath);
         anImageEntity.setFieldValue("publish_path", filePath);
 
         anImageEntity.update();
 
-
       }
     }
     catch(Throwable t) {
-      logger.error("MediaHandlerImagesExtern.execute: " + t.toString());
-      t.printStackTrace(logger.asPrintWriter(LoggerWrapper.DEBUG_MESSAGE));
+      logger.error("MediaHandlerImagesExtern.execute: " + t.getMessage(), t);
       throw new MediaFailure(t.getMessage(), t);
     }
   }