4 votes

Ajout d'une superposition à une vidéo en Swift 3

Je suis en train d'apprendre AVFoundation et j'ai un problème pour essayer d'enregistrer une vidéo avec une image superposée dans Swift 3. En utilisant AVMutableComposition Je suis en mesure d'ajouter l'image à la vidéo, mais la vidéo est agrandie et ne correspond pas à la taille portrait dans laquelle la vidéo a été prise. J'ai essayé :

  • Réglage de la taille naturelle par le biais de la AVAssetTrack .
  • Contrainte de la vidéo à la taille d'un portrait dans l'écran de l'ordinateur. AVMutableVideoComposition renderFrame .
  • Le verrouillage des nouvelles limites de la vidéo sur la largeur et la hauteur de la vidéo enregistrée.

Le code ci-dessous fonctionne, à l'exception du problème pour lequel j'ai besoin d'aide. L'image que j'essaie d'ajouter couvre la totalité de la vue portrait et comporte une bordure tout autour. De plus, l'application ne permet que le portrait.

func processVideoWithWatermark(video: AVURLAsset, watermark: UIImage, completion: @escaping (Bool) -> Void) {

    let composition = AVMutableComposition()
    let asset = AVURLAsset(url: video.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)
        compositionVideoTrack.preferredTransform = videoTrack.preferredTransform
    } 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 = videoTrack.naturalSize

    let watermark = watermark.cgImage
    let watermarklayer = CALayer()
    watermarklayer.contents = watermark
    watermarklayer.frame = CGRect(x: 0, y: 0, width: screenWidth, height: screenHeight)
    watermarklayer.opacity = 1

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

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

    let layercomposition = AVMutableVideoComposition()
    layercomposition.frameDuration = CMTimeMake(1, 30)
    layercomposition.renderSize = CGSize(width: screenWidth, height: screenHeight)
    layercomposition.renderScale = 1.0
    layercomposition.animationTool = AVVideoCompositionCoreAnimationTool(postProcessingAsVideoLayer: videolayer, in: parentlayer)

    let instruction = AVMutableVideoCompositionInstruction()
    instruction.timeRange = CMTimeRangeMake(kCMTimeZero, composition.duration)

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

    layerinstruction.setTransform(videoTrack.preferredTransform, at: kCMTimeZero)

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

    let filePath = NSTemporaryDirectory() + 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")
            print(video.url)
            self.saveVideoToUserLibrary(fileURL: movieUrl, completion: { (success, error) in
                if success {
                    completion(true)
                } else {
                    completion(false)

                }
            })

            break
        case .cancelled:
            print("cancelled")
            break
        case .exporting:
            print("exporting")
            break
        case .failed:
            print(video.url)
            print("failed: \(assetExport.error!)")
            break
        case .unknown:
            print("unknown")
            break
        case .waiting:
            print("waiting")
            break
        }
    })

}

0voto

Tiko Points 425

Si le calque vidéo doit remplir le calque parent, l'élément de votre videoLayer frame est incorrecte. Vous devez définir la taille égale à size au lieu de screenSize .

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X