Add custom RAW format conversion tool support

Dockerfile

@@ -95,6 +95,9 @@ ENV PHOTOVIEW_LISTEN_PORT 80
 
 ENV PHOTOVIEW_SERVE_UI 1
 ENV PHOTOVIEW_UI_PATH /ui
+ENV PHOTOVIEW_RAW_PROCESSING_EXECUTABLE="darktable-cli"
+ENV PHOTOVIEW_RAW_PROCESSING_EXECUTABLE_CHECK="--version"
+ENV PHOTOVIEW_RAW_PROCESSING_ARGS="{{ .InputPath }} {{ .OutputPath }} --core --conf plugins/imageio/format/jpeg/quality={{ .Quality }} --configdir /tmp/photoview-convert"
 
 EXPOSE 80
 

api/scanner/media_encoding/encode_photo.go

@@ -110,8 +110,8 @@ func (img *EncodeMediaData) EncodeHighRes(outputPath string) error {
 
 	// Use darktable if there is no counterpart JPEG file to use instead
 	if contentType.IsRaw() && img.CounterpartPath == nil {
-		if executable_worker.DarktableCli.IsInstalled() {
-			err := executable_worker.DarktableCli.EncodeJpeg(img.Media.Path, outputPath, 70)
+		if executable_worker.CustomRawCli.IsInstalled() {
+			err := executable_worker.CustomRawCli.EncodeJpeg(img.Media.Path, outputPath, 70)
 			if err != nil {
 				return err
 			}

api/scanner/media_encoding/executable_worker/executable_worker.go

@@ -7,52 +7,68 @@ import (
 	"os"
 	"os/exec"
 	"strings"
+	"text/template"
+	"bytes"
+
 
 	"github.com/photoview/photoview/api/utils"
 	"github.com/pkg/errors"
 	"gopkg.in/vansante/go-ffprobe.v2"
 )
 
 func InitializeExecutableWorkers() {
-	DarktableCli = newDarktableWorker()
+	CustomRawCli = newCustomRawWorker()
 	FfmpegCli = newFfmpegWorker()
 }
 
-var DarktableCli *DarktableWorker = nil
+var CustomRawCli *CustomRawWorker = nil
 var FfmpegCli *FfmpegWorker = nil
 
 type ExecutableWorker interface {
 	Path() string
 }
 
-type DarktableWorker struct {
+type FfmpegWorker struct {
 	path string
 }
 
-type FfmpegWorker struct {
+type CustomRawWorker struct {
 	path string
+	args string
 }
 
-func newDarktableWorker() *DarktableWorker {
+type RawArgs struct {
+    InputPath string
+    OutputPath string
+	Quality int
+}
+
+
+func newCustomRawWorker() *CustomRawWorker {
 	if utils.EnvDisableRawProcessing.GetBool() {
-		log.Printf("Executable worker disabled (%s=1): darktable\n", utils.EnvDisableRawProcessing.GetName())
+		log.Printf("Executable worker disabled (%s=1) \n", utils.EnvDisableRawProcessing.GetName())
 		return nil
 	}
 
-	path, err := exec.LookPath("darktable-cli")
+	var _check = utils.EnvRawProcessingCheck.GetValue()
+	var _exec = utils.EnvRawProcessing.GetValue()
+	var _args = utils.EnvRawProcessingArgs.GetValue()
+
+	path, err := exec.LookPath(_exec)
 	if err != nil {
-		log.Println("Executable worker not found: darktable")
+		log.Printf("Executable worker not found: %s",_exec)
 	} else {
-		version, err := exec.Command(path, "--version").Output()
+		version, err := exec.Command(path, _check).Output()
 		if err != nil {
-			log.Printf("Error getting version of darktable: %s\n", err)
+			log.Printf("Error getting version of %s: %s\n",_exec, err)
 			return nil
 		}
 
-		log.Printf("Found executable worker: darktable (%s)\n", strings.Split(string(version), "\n")[0])
+		log.Printf("Found executable worker: %s (%s)\n", _exec, strings.Split(string(version), "\n")[0])
 
-		return &DarktableWorker{
+		return &CustomRawWorker{
 			path: path,
+			args: _args,
 		}
 	}
 
@@ -85,30 +101,32 @@ func newFfmpegWorker() *FfmpegWorker {
 	return nil
 }
 
-func (worker *DarktableWorker) IsInstalled() bool {
+func (worker *CustomRawWorker) IsInstalled() bool {
 	return worker != nil
 }
 
 func (worker *FfmpegWorker) IsInstalled() bool {
 	return worker != nil
 }
 
-func (worker *DarktableWorker) EncodeJpeg(inputPath string, outputPath string, jpegQuality int) error {
-	tmpDir, err := ioutil.TempDir("/tmp", "photoview-darktable")
+func (worker *CustomRawWorker) EncodeJpeg(inputPath string, outputPath string, jpegQuality int) error {
+	tmpDir, err := ioutil.TempDir("/tmp", "photoview-convert")
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer os.RemoveAll(tmpDir)
 
-	args := []string{
-		inputPath,
-		outputPath,
-		"--core",
-		"--conf",
-		fmt.Sprintf("plugins/imageio/format/jpeg/quality=%d", jpegQuality),
-		"--configdir",
-		tmpDir,
-	}
+	tmpl, err := template.New("RawArgs").Parse(worker.args)
+	if err != nil { 
+		log.Fatal(err)
+    }
+	_args := RawArgs{inputPath,outputPath,jpegQuality}
+	var buf bytes.Buffer
+	err = tmpl.Execute(&buf,_args)
+	if err != nil { 
+        log.Fatal(err)
+    }
+	args := strings.Split(buf.String()," ")
 
 	cmd := exec.Command(worker.path, args...)
 

api/scanner/media_type/media_type.go

@@ -256,7 +256,7 @@ func (imgType *MediaType) IsSupported() bool {
 		return true
 	}
 
-	if executable_worker.DarktableCli.IsInstalled() && imgType.IsRaw() {
+	if executable_worker.CustomRawCli.IsInstalled() && imgType.IsRaw() {
 		return true
 	}
 

api/utils/environment_variables.go

@@ -38,6 +38,9 @@ const (
 	EnvDisableFaceRecognition EnvironmentVariable = "PHOTOVIEW_DISABLE_FACE_RECOGNITION"
 	EnvDisableVideoEncoding   EnvironmentVariable = "PHOTOVIEW_DISABLE_VIDEO_ENCODING"
 	EnvDisableRawProcessing   EnvironmentVariable = "PHOTOVIEW_DISABLE_RAW_PROCESSING"
+	EnvRawProcessing    EnvironmentVariable = "PHOTOVIEW_RAW_PROCESSING_EXECUTABLE"
+	EnvRawProcessingCheck  EnvironmentVariable = "PHOTOVIEW_RAW_PROCESSING_EXECUTABLE_CHECK"
+	EnvRawProcessingArgs  EnvironmentVariable = "PHOTOVIEW_RAW_PROCESSING_ARGS"
 )
 
 // GetName returns the name of the environment variable itself