AVAssetExportSession

Question

के साथ पूर्ण स्क्रीन में वीडियो निर्यात करना मैं एक वीडियो (रिकॉर्डिंग के बाद) में कुछ एनिमेशन करने की कोशिश कर रहा हूं और फिर इसे निर्यात करता हूं। लेकिन किसी एनीमेशन से पहले मुझे अभिविन्यास के साथ समस्या थी जो परिदृश्य बन गया (बिना निर्यात के यह चित्र था) और इसे हल नहीं किया गया है, लेकिन अब मुझे इसे पूर्ण स्क्रीन बनाने में समस्या है। Iphone 6,7 प्लस इसकी पूर्ण स्क्रीन कैसे आईपैड यह नहीं है।

func export(_ url : URL) { 
    let composition = AVMutableComposition() 
    let asset = AVURLAsset(url: url, options: nil) 

    let track = asset.tracks(withMediaType : AVMediaTypeVideo) 
    let videoTrack:AVAssetTrack = track[0] as AVAssetTrack 
    let timerange = CMTimeRangeMake(kCMTimeZero, asset.duration) 

    let compositionVideoTrack:AVMutableCompositionTrack = composition.addMutableTrack(withMediaType: AVMediaTypeVideo, preferredTrackID: CMPersistentTrackID()) 

    do { 
     try compositionVideoTrack.insertTimeRange(timerange, of: videoTrack, at: kCMTimeZero) 
    } catch { 
     print(error) 
    } 

    let compositionAudioTrack:AVMutableCompositionTrack = composition.addMutableTrack(withMediaType: AVMediaTypeAudio, preferredTrackID: CMPersistentTrackID()) 

    for audioTrack in asset.tracks(withMediaType: AVMediaTypeAudio) { 
     do { 
      try compositionAudioTrack.insertTimeRange(audioTrack.timeRange, of: audioTrack, at: kCMTimeZero) 
     } catch { 
      print(error) 
     } 

    } 

    let size = self.view.bounds.size 

    let videolayer = CALayer() 
    videolayer.frame = CGRect(x: 0, y: 0, width: size.width, height: size.height) 

    let parentlayer = CALayer() 
    parentlayer.frame = CGRect(x: 0, y: 0, width: size.width, height: size.height) 
    parentlayer.addSublayer(videolayer) 

    let layercomposition = AVMutableVideoComposition() 
    layercomposition.frameDuration = CMTimeMake(1, 30) 
    layercomposition.renderSize = self.view.bounds.size 
    layercomposition.animationTool = AVVideoCompositionCoreAnimationTool(postProcessingAsVideoLayer: videolayer, in: parentlayer) 

    let instruction = AVMutableVideoCompositionInstruction() 

    instruction.timeRange = CMTimeRangeMake(kCMTimeZero, asset.duration) 

    let videotrack = composition.tracks(withMediaType: AVMediaTypeVideo)[0] as AVAssetTrack 
    let layerinstruction = AVMutableVideoCompositionLayerInstruction(assetTrack: videotrack) 


    let ratio = size.height/videoTrack.naturalSize.width 

    composition.naturalSize = videoTrack.naturalSize 

    layerinstruction.setTransform(videoTrack.preferredTransform.scaledBy(x: 0.645 , y: ratio).translatedBy(x: self.view.bounds.height, y: 0), at: kCMTimeZero) 

    instruction.layerInstructions = [layerinstruction] 
    layercomposition.instructions = [instruction] 

    let filePath = self.fileName() 
    let movieUrl = URL(fileURLWithPath: filePath) 

    guard let assetExport = AVAssetExportSession(asset: composition, presetName:AVAssetExportPresetHighestQuality) else {return} 
    assetExport.videoComposition = layercomposition 
    assetExport.outputFileType = AVFileTypeMPEG4 
    assetExport.outputURL = movieUrl 
    assetExport.exportAsynchronously(completionHandler: { 
     switch assetExport.status { 
     case .completed: 
      print("success") 
      let player = AVPlayer(url: movieUrl) 
      let playerViewController = AVPlayerViewController() 
      playerViewController.player = player 
      self.present(playerViewController, animated: true) { 
       playerViewController.player!.play() 
      } 
      break 
     case .cancelled: 
      print("cancelled") 
      break 
     case .exporting: 
      print("exporting") 
      break 
     case .failed: 
      print("failed: \(String(describing: assetExport.error))") 
      break 
     case .unknown: 
      print("unknown") 
      break 
     case .waiting: 
      print("waiting") 
      break 
     } 
    }) 
} 

Answer 1

क्या मेरी समस्या पैमाने कारक और अनुवाद राशि बदल रहा था तय:

यहाँ मेरी विधि है। यहां नीचे दिया गया कोड है:

let size = self.view.bounds.size 
    let trackTransform = videoTrack.preferredTransform 
    let xScale = size.height/videoTrack.naturalSize.width 
    let yScale = size.width/videoTrack.naturalSize.height 


    let exportTransform = videoTrack.preferredTransform.translatedBy(x: trackTransform.ty * -1 , y: 0).scaledBy(x: xScale , y: yScale)