318 lines
13 KiB
Swift
318 lines
13 KiB
Swift
import Cocoa
|
|
import ZIPFoundation
|
|
import AVFoundation
|
|
|
|
@NSApplicationMain
|
|
class AppDelegate: NSObject, NSApplicationDelegate, NSUserInterfaceValidations {
|
|
var exporter: AVAssetExportSession?
|
|
|
|
@IBAction func showInfoAction(_ sender: Any) {
|
|
NSApplication.shared.keyWindow?.contentViewController?.performSegue(withIdentifier: "showInfo", sender: self)
|
|
}
|
|
|
|
@IBAction func showTimelapseAction(_ sender: Any) {
|
|
NSApplication.shared.keyWindow?.contentViewController?.performSegue(withIdentifier: "showTimelapse", sender: self)
|
|
}
|
|
|
|
func validateUserInterfaceItem(_ item: NSValidatedUserInterfaceItem) -> Bool {
|
|
// Show timelapse and show info buttons
|
|
if(item.tag == 67 || item.tag == 68 || item.tag == 100 || item.tag == 101 || item.tag == 102) {
|
|
return NSApplication.shared.keyWindow != nil
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func addAccessoryView(_ savePanel : NSSavePanel) {
|
|
let accessoryView = (ExportAccessoryView.fromNib()! as ExportAccessoryView)
|
|
accessoryView.setSavePanel(savePanel)
|
|
|
|
savePanel.accessoryView = accessoryView as NSView
|
|
}
|
|
|
|
func getBitmapType(_ ext : String) -> NSBitmapImageRep.FileType {
|
|
switch(ext) {
|
|
case "tiff":
|
|
return .tiff
|
|
case "bmp":
|
|
return .bmp
|
|
case "jpeg":
|
|
return .jpeg
|
|
case "png":
|
|
return .png
|
|
default:
|
|
return .png
|
|
}
|
|
}
|
|
|
|
func getPSDBlendMode(_ layer : SilicaLayer) -> PSDBlendModes {
|
|
if layer.data.blendMode == 1 {
|
|
return kPSDBlendModeMultiply
|
|
}
|
|
if layer.data.blendMode == 10 {
|
|
return kPSDBlendModeColorBurn
|
|
}
|
|
if layer.data.blendMode == 19 {
|
|
return kPSDBlendModeDarken
|
|
}
|
|
if layer.data.blendMode == 8 {
|
|
return kPSDBlendModeLinearBurn
|
|
}
|
|
if layer.data.blendMode == 4 {
|
|
return kPSDBlendModeLighten
|
|
}
|
|
if layer.data.blendMode == 2 {
|
|
return kPSDBlendModeScreen
|
|
}
|
|
if layer.data.blendMode == 13 {
|
|
//blendMode = kPSDBlendModeHardLight
|
|
}
|
|
if layer.data.blendMode == 9 {
|
|
return kPSDBlendModeColorDodge
|
|
}
|
|
if layer.data.blendMode == 3 {
|
|
//blendMode = kPSDBlendModeSubtract
|
|
}
|
|
if layer.data.blendMode == 0 && layer.data.blendMode != layer.data.extendedBlend {
|
|
if layer.data.extendedBlend == 25 {
|
|
return kPSDBlendModeDarkerColor
|
|
}
|
|
if layer.data.extendedBlend == 24 {
|
|
//blendMode = kPSDBlendModeLighterColor
|
|
}
|
|
if layer.data.extendedBlend == 21 {
|
|
//blendMode = kPSDBlendModeVividLight
|
|
}
|
|
if layer.data.extendedBlend == 22 {
|
|
//blendMode = kPSdBlendModeLinearLight
|
|
}
|
|
if layer.data.extendedBlend == 23 {
|
|
//blendMode = kPSDBlendModePinLight
|
|
}
|
|
if layer.data.extendedBlend == 20 {
|
|
//blendMode = kPSDBlendModeHardMix
|
|
}
|
|
if layer.data.extendedBlend == 26 {
|
|
//blendMode = kPSDBlendModeDivide
|
|
}
|
|
}
|
|
|
|
if layer.data.blendMode == 11 {
|
|
//blendMode = kPSDBlendModeOverlay
|
|
}
|
|
if layer.data.blendMode == 17 {
|
|
//return .softLight
|
|
}
|
|
if layer.data.blendMode == 12 {
|
|
//return .hardLight
|
|
}
|
|
if layer.data.blendMode == 6 {
|
|
//return .difference
|
|
}
|
|
if layer.data.blendMode == 5 {
|
|
//return .exclusion
|
|
}
|
|
if layer.data.blendMode == 7 {
|
|
//return .componentAdd
|
|
}
|
|
if layer.data.blendMode == 15 {
|
|
//return .hue
|
|
}
|
|
if layer.data.blendMode == 16 {
|
|
//return .saturation
|
|
}
|
|
if layer.data.blendMode == 13 {
|
|
//return .color
|
|
}
|
|
if layer.data.blendMode == 14 {
|
|
//return .luminosity
|
|
}
|
|
|
|
return kPSDBlendModeNormal
|
|
}
|
|
|
|
@IBAction func exportAction(_ sender: Any) {
|
|
let document = NSApplication.shared.keyWindow?.windowController?.document as? Document;
|
|
|
|
let savePanel = NSSavePanel()
|
|
savePanel.title = "Save"
|
|
savePanel.allowedFileTypes = ["tiff"]
|
|
savePanel.nameFieldStringValue = (document?.getIdealFilename())!
|
|
|
|
addAccessoryView(savePanel)
|
|
|
|
savePanel.begin { (result) in
|
|
if result.rawValue == NSApplication.ModalResponse.OK.rawValue {
|
|
if savePanel.allowedFileTypes![0] != "psd" {
|
|
var fileType: NSBitmapImageRep.FileType = .tiff
|
|
switch(savePanel.allowedFileTypes![0]) {
|
|
case "tiff":
|
|
fileType = .tiff;
|
|
break;
|
|
case "bmp":
|
|
fileType = .bmp;
|
|
break;
|
|
case "jpeg":
|
|
fileType = .jpeg;
|
|
break;
|
|
case "png":
|
|
fileType = .png;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
let canvas = document?.makeComposite()
|
|
let canvasTiff = canvas?.tiffRepresentation
|
|
let bitmapImage = NSBitmapImageRep(data: canvasTiff!)
|
|
let canvasPng = bitmapImage!.representation(using: fileType, properties: [:])
|
|
|
|
try? canvasPng?.write(to: savePanel.url!)
|
|
} else {
|
|
let writer = PSDWriter(documentSize: (document?.info.cgSize)!)
|
|
|
|
let cgImage = document?.makeComposite()?.cgImage(forProposedRect: nil, context: nil, hints: nil)
|
|
|
|
let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue).union(.byteOrder32Big)
|
|
|
|
let ccgContext = CGContext(data: nil, width: document!.info.width, height: document!.info.height, bitsPerComponent: 8, bytesPerRow: document!.info.width * 4, space: document!.info.colorSpace, bitmapInfo: bitmapInfo.rawValue)
|
|
|
|
ccgContext?.setFillColor(document!.info.backgroundColor)
|
|
ccgContext?.fill(document!.info.cgRect)
|
|
|
|
let context = CIContext()
|
|
|
|
writer?.addLayer(with: ccgContext?.makeImage(), andName: "Background", andOpacity: 1.0, andOffset: .zero)
|
|
|
|
var masterImage = CIImage(cgImage: cgImage!)
|
|
|
|
for layer in document!.info.layers.reversed() {
|
|
var test : CGImage? = nil
|
|
|
|
masterImage = document!.blendLayer(layer, previousImage: &test)
|
|
|
|
let finalCgImage = context.createCGImage(masterImage, from: document!.info.cgRect, format: .RGBA8, colorSpace: document!.info.colorSpace)
|
|
|
|
if(layer.mask != nil) {
|
|
writer?.addLayer(with: document!.makeBlendImage(layer), andName: layer.name + " (Mask)", andOpacity: 1.0, andOffset: .zero)
|
|
}
|
|
|
|
writer?.addLayer(with: finalCgImage, andName: layer.name, andOpacity: Float(layer.data.opacity), andOffset: .zero, andBlendMode: Int(blendMode.rawValue), andIsNonBaseLayer: layer.clipped)
|
|
}
|
|
|
|
let data = writer?.createPSDData()
|
|
try? data?.write(to: savePanel.url!)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@IBAction func exportThumbnailAction(_ sender: Any) {
|
|
let document = NSApplication.shared.keyWindow?.windowController?.document as? Document;
|
|
|
|
let savePanel = NSSavePanel()
|
|
savePanel.title = "Save Thumbnail"
|
|
savePanel.allowedFileTypes = ["public.png"]
|
|
savePanel.nameFieldStringValue = (document?.getIdealFilename())!
|
|
|
|
addAccessoryView(savePanel)
|
|
|
|
savePanel.begin { (result) in
|
|
if result.rawValue == NSApplication.ModalResponse.OK.rawValue {
|
|
let canvas = document?.makeThumbnail()
|
|
let canvasTiff = canvas?.tiffRepresentation
|
|
let bitmapImage = NSBitmapImageRep(data: canvasTiff!)
|
|
let canvasPng = bitmapImage!.representation(using: .png, properties: [:])
|
|
|
|
try? canvasPng?.write(to: savePanel.url!)
|
|
}
|
|
}
|
|
}
|
|
|
|
@IBAction func exportTimelapseAction(_ sender: Any) {
|
|
guard let originalWindow = NSApplication.shared.keyWindow else {
|
|
return
|
|
}
|
|
|
|
let document = originalWindow.windowController?.document as? Document;
|
|
|
|
let savePanel = NSSavePanel()
|
|
savePanel.title = "Save Timelapse"
|
|
savePanel.allowedFileTypes = ["public.mpeg-4"]
|
|
savePanel.nameFieldStringValue = (document?.getIdealFilename())!
|
|
|
|
savePanel.begin { (result) in
|
|
if result.rawValue == NSApplication.ModalResponse.OK.rawValue {
|
|
guard let archive = Archive(data: (document?.data)!, accessMode: Archive.AccessMode.read) else {
|
|
return
|
|
}
|
|
|
|
let directory = NSTemporaryDirectory()
|
|
|
|
let mixComposition = AVMutableComposition()
|
|
var instructions: [AVMutableVideoCompositionLayerInstruction] = []
|
|
var duration = CMTime.zero
|
|
|
|
for entry in archive.makeIterator() {
|
|
if entry.path.contains(VideoPath) {
|
|
let fileName = NSUUID().uuidString + ".mp4"
|
|
|
|
// This returns a URL? even though it is an NSURL class method
|
|
let fullURL = NSURL.fileURL(withPathComponents: [directory, fileName])!
|
|
|
|
let _ = try? archive.extract(entry, to: fullURL)
|
|
|
|
let asset = AVAsset(url: fullURL)
|
|
|
|
guard let track = mixComposition.addMutableTrack(withMediaType: .video, preferredTrackID: Int32(kCMPersistentTrackID_Invalid)) else {
|
|
return
|
|
}
|
|
|
|
try? track.insertTimeRange(CMTimeRangeMake(start: .zero, duration: asset.duration),
|
|
of: asset.tracks(withMediaType: .video)[0],
|
|
at: duration)
|
|
|
|
duration = CMTimeAdd(duration, asset.duration)
|
|
|
|
let opacityInstruction = AVMutableVideoCompositionLayerInstruction(assetTrack: track)
|
|
opacityInstruction.setOpacity(0.0, at: duration + asset.duration)
|
|
|
|
instructions.append(opacityInstruction)
|
|
}
|
|
}
|
|
|
|
let mainInstruction = AVMutableVideoCompositionInstruction()
|
|
mainInstruction.timeRange = CMTimeRangeMake(start: .zero, duration: duration)
|
|
mainInstruction.layerInstructions = instructions
|
|
|
|
let mainComposition = AVMutableVideoComposition()
|
|
mainComposition.instructions = [mainInstruction]
|
|
mainComposition.frameDuration = CMTimeMake(value: 1, timescale: 30)
|
|
mainComposition.renderSize = CGSize(width: document!.info.videoFrame.0, height: document!.info.videoFrame.1)
|
|
|
|
self.exporter = AVAssetExportSession(asset: mixComposition, presetName: AVAssetExportPresetHighestQuality)
|
|
self.exporter?.outputURL = savePanel.url!
|
|
self.exporter?.outputFileType = AVFileType.mp4
|
|
self.exporter?.videoComposition = mainComposition
|
|
|
|
let alert = NSAlert()
|
|
alert.messageText = "Exporting timelapse..."
|
|
alert.addButton(withTitle: "Cancel")
|
|
alert.beginSheetModal(for: originalWindow) { (resonse) in
|
|
self.exporter?.cancelExport()
|
|
alert.window.close()
|
|
}
|
|
|
|
self.exporter?.exportAsynchronously {
|
|
if self.exporter?.status != .cancelled {
|
|
DispatchQueue.main.sync {
|
|
alert.window.close()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|