объединить два видео в приложении ios, по-прежнему сохраняя ориентацию каждого видео?

У меня версия Swift. Мой работает отлично. Вот мой. После нескольких часов кодирования наконец-то это заработало. Извините, что публикую ответ в Swift. Надеюсь, вы найдете это полезным.

readyVideoURLs содержит все URL-адреса видео. И вы можете объединить любое количество видео с этим кодом.

И я создаю видео квадратного размера.

mainComposition.renderSize = CGSize(width: 600, height: 600)

func mergeVideos() {

        let composition = AVMutableComposition()
        let compositionTrack = composition.addMutableTrack(withMediaType: AVMediaTypeVideo, preferredTrackID: kCMPersistentTrackID_Invalid)

        var current = kCMTimeZero
        var assetArr = [AVURLAsset]()

        let mainInstruction = AVMutableVideoCompositionInstruction()

        for url in readyVideoURLs {
            assetArr.append(AVURLAsset(url: url))
            print("readyVideoURL vid url:- \(url)")

        }

        for asset in assetArr {
            do {
                try compositionTrack.insertTimeRange(CMTimeRangeMake(kCMTimeZero, asset.duration), of: asset.tracks(withMediaType: AVMediaTypeVideo)[0], at: kCMTimeZero)

            } catch let error {
                print(error.localizedDescription)
            }


            let instruction = videoCompositionInstructionForTrack(track: compositionTrack, asset: asset)
            mainInstruction.layerInstructions.append(instruction)
            mainInstruction.timeRange = CMTimeRangeMake(kCMTimeZero, CMTimeAdd(current, asset.duration))
            current = CMTimeAdd(current, asset.duration)
        }


        let mainComposition = AVMutableVideoComposition()
        mainComposition.instructions = [mainInstruction]
        mainComposition.frameDuration = CMTimeMake(1, 30)
        mainComposition.renderSize = CGSize(width: 600, height: 600)


        //add audio track
//        if let loadedAudioAsset = audioAsset {
//            let audioTrack = composition.addMutableTrack(withMediaType: AVMediaTypeAudio, preferredTrackID: 0)
//            do {
//                try audioTrack.insertTimeRange(CMTimeRangeMake(kCMTimeZero, current),
//                                               of: loadedAudioAsset.tracks(withMediaType: AVMediaTypeAudio)[0], at: kCMTimeZero)
//            } catch _ {
//                print("Failed to load Audio track")
//            }
//        }

        let finalVideoPath = NSHomeDirectory().appending("/Documents/finalDailyVideo.mp4")
        if FileManager.default.fileExists(atPath: finalVideoPath) {
            do {
                try FileManager.default.removeItem(atPath: finalVideoPath)
            } catch let error {
                print(error.localizedDescription)
            }
        }

        guard let exporter = AVAssetExportSession(asset: composition, presetName: AVAssetExportPresetHighestQuality) else { return }
        exporter.outputURL = URL(fileURLWithPath: finalVideoPath)
        exporter.outputFileType = AVFileTypeMPEG4
        exporter.shouldOptimizeForNetworkUse = true

        saveToAlbum(mergedVidUrl: URL(string:finalVideoPath)!, exporter: exporter)

    }

Сохранение в альбом

func saveToAlbum(mergedVidUrl : URL, exporter : AVAssetExportSession)  {
        exportFinalVideo(exporter: exporter) { (completed) in
            if completed {

                let assetLib = ALAssetsLibrary()
                assetLib.writeVideoAtPath(toSavedPhotosAlbum: mergedVidUrl, completionBlock: { (assetUrl, error) in
                    if error == nil {
                        DispatchQueue.main.async {
                            self.showAlert(title: "Congrats..",message: "Your daily Vlog was saved in albums", actionTitle: "Got it")
                        }
                    }

                })
            }
        }
    }

Получение завершения экспортера

func exportFinalVideo(exporter: AVAssetExportSession, completion:@escaping(Bool) -> ())  {
        exporter.exportAsynchronously() {

            if exporter.status == .exporting {
                print("EXPORTING...")

            } else if exporter.status == .completed {
                print("merged video exporting DONE")
                DispatchQueue.main.async {
                    self.dismiss(animated: true, completion: nil)
                }
                completion(true)
            } else if exporter.status == .failed {
                completion(false)
                self.showAlert(title: "Oops!", message: "Something went wrong. Video could not be created.", actionTitle: "Okay!")

            }
        }

    }

Инструкции к видеослою для ориентации

func videoCompositionInstructionForTrack(track: AVCompositionTrack, asset: AVAsset) -> AVMutableVideoCompositionLayerInstruction {
        let instruction = AVMutableVideoCompositionLayerInstruction(assetTrack: track)
        let assetTrack = asset.tracks(withMediaType: AVMediaTypeVideo)[0]

        let transform = assetTrack.preferredTransform
        let assetInfo = orientationFromTransform(transform: transform)

        var scaleToFitRatio = UIScreen.main.bounds.width / assetTrack.naturalSize.width
        if assetInfo.isPortrait {
            scaleToFitRatio = UIScreen.main.bounds.width / assetTrack.naturalSize.height
            let scaleFactor = CGAffineTransform(scaleX: scaleToFitRatio, y: scaleToFitRatio)
            instruction.setTransform(assetTrack.preferredTransform.concatenating(scaleFactor),
                                     at: kCMTimeZero)
        } else {
            let scaleFactor = CGAffineTransform(scaleX: scaleToFitRatio, y: scaleToFitRatio)
            var concat = assetTrack.preferredTransform.concatenating(scaleFactor).concatenating(CGAffineTransform(translationX: 0, y: UIScreen.main.bounds.width / 2))
            if assetInfo.orientation == .down {
                let fixUpsideDown = CGAffineTransform(rotationAngle: CGFloat(Double.pi))
                let windowBounds = UIScreen.main.bounds
                let yFix = assetTrack.naturalSize.height + windowBounds.height
                let centerFix = CGAffineTransform(translationX: assetTrack.naturalSize.width, y: yFix)
                concat = fixUpsideDown.concatenating(centerFix).concatenating(scaleFactor)
            }
            instruction.setTransform(concat, at: kCMTimeZero)
        }

        return instruction
    }

    func orientationFromTransform(transform: CGAffineTransform) -> (orientation: UIImageOrientation, isPortrait: Bool) {
        var assetOrientation = UIImageOrientation.up
        var isPortrait = false
        if transform.a == 0 && transform.b == 1.0 && transform.c == -1.0 && transform.d == 0 {
            assetOrientation = .right
            isPortrait = true
        } else if transform.a == 0 && transform.b == -1.0 && transform.c == 1.0 && transform.d == 0 {
            assetOrientation = .left
            isPortrait = true
        } else if transform.a == 1.0 && transform.b == 0 && transform.c == 0 && transform.d == 1.0 {
            assetOrientation = .up
        } else if transform.a == -1.0 && transform.b == 0 && transform.c == 0 && transform.d == -1.0 {
            assetOrientation = .down
        }
        return (assetOrientation, isPortrait)
    }