Swiftで動画撮影機能を簡単に実装！手順とサンプルコード15選

// AVFoundationフレームワークをインポート
import AVFoundation

import UIKit
import AVFoundation

class VideoCaptureViewController: UIViewController, AVCaptureFileOutputRecordingDelegate {

    var captureSession: AVCaptureSession!
    var videoFileOutput: AVCaptureMovieFileOutput!

    override func viewDidLoad() {
        super.viewDidLoad()

        captureSession = AVCaptureSession()
        captureSession.sessionPreset = .hd1920x1080

        guard let videoDevice = AVCaptureDevice.default(for: .video) else { return }
        guard let videoInput = try? AVCaptureDeviceInput(device: videoDevice) else { return }
        captureSession.addInput(videoInput)

        videoFileOutput = AVCaptureMovieFileOutput()
        captureSession.addOutput(videoFileOutput)

        let previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
        previewLayer.frame = view.bounds
        view.layer.addSublayer(previewLayer)

        captureSession.startRunning()
    }

    @IBAction func startRecording(_ sender: Any) {
        let outputDirectory = FileManager.default.temporaryDirectory
        let outputFilePath = outputDirectory.appendingPathComponent(UUID().uuidString).appendingPathExtension("mov")
        videoFileOutput.startRecording(to: outputFilePath, recordingDelegate: self)
    }

    @IBAction func stopRecording(_ sender: Any) {
        videoFileOutput.stopRecording()
    }

    func fileOutput(_ output: AVCaptureFileOutput, didFinishRecordingTo outputFileURL: URL, from connections: [AVCaptureConnection], error: Error?) {
        if let error = error {
            print("録画エラー: \(error.localizedDescription)")
        } else {
            print("録画完了: \(outputFileURL)")
        }
    }
}

import UIKit
import AVFoundation

class CameraSwitchViewController: UIViewController {

    var captureSession: AVCaptureSession!
    var currentCameraPosition: AVCaptureDevice.Position = .back

    override func viewDidLoad() {
        super.viewDidLoad()
        setupCaptureSession(cameraPosition: currentCameraPosition)
    }

    func setupCaptureSession(cameraPosition: AVCaptureDevice.Position) {
        captureSession = AVCaptureSession()

        guard let videoDevice = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: cameraPosition) else { return }
        guard let videoInput = try? AVCaptureDeviceInput(device: videoDevice) else { return }
        captureSession.addInput(videoInput)

        let previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
        previewLayer.frame = view.bounds
        view.layer.addSublayer(previewLayer)

        captureSession.startRunning()
    }

    @IBAction func switchCamera(_ sender: Any) {
        captureSession.stopRunning()
        captureSession = nil
        currentCameraPosition = (currentCameraPosition == .back) ? .front : .back
        setupCaptureSession(cameraPosition: currentCameraPosition)
    }
}

import UIKit
import AVFoundation
import Photos

class SaveVideoViewController: UIViewController {

    var videoURL: URL?

    @IBAction func saveVideoToAlbum(_ sender: Any) {
        guard let url = videoURL else { return }

        // アルバムに動画を保存
        PHPhotoLibrary.shared().performChanges({
            PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: url)
        }) { (success, error) in
            DispatchQueue.main.async {
                if success {
                    print("動画をアルバムに保存しました。")
                } else {
                    print("動画の保存に失敗しました。")
                }
            }
        }
    }
}

import UIKit
import AVKit
import AVFoundation

class PlayVideoViewController: UIViewController {

    var videoURL: URL?

    @IBAction func playVideo(_ sender: Any) {
        guard let url = videoURL else { return }

        let player = AVPlayer(url: url)
        let playerViewController = AVPlayerViewController()
        playerViewController.player = player
        present(playerViewController, animated: true) {
            playerViewController.player?.play()
        }
    }
}

import UIKit
import AVFoundation

class CustomUIVideoCaptureViewController: UIViewController {

    var captureSession: AVCaptureSession!
    var previewLayer: AVCaptureVideoPreviewLayer!

    override func viewDidLoad() {
        super.viewDidLoad()

        captureSession = AVCaptureSession()

        guard let videoDevice = AVCaptureDevice.default(for: .video) else { return }
        guard let videoInput = try? AVCaptureDeviceInput(device: videoDevice) else { return }
        captureSession.addInput(videoInput)

        // カメラのプレビュー表示
        previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
        previewLayer.frame = view.bounds
        view.layer.addSublayer(previewLayer)

        // カスタムのUIを配置
        let customButton = UIButton(frame: CGRect(x: 150, y: 400, width: 70, height: 30))
        customButton.setTitle("撮影", for: .normal)
        customButton.backgroundColor = .red
        customButton.addTarget(self, action: #selector(startRecording), for: .touchUpInside)
        view.addSubview(customButton)

        captureSession.startRunning()
    }

    @objc func startRecording() {
        // ここで録画の開始などの処理を行う
    }
}

import UIKit
import AVFoundation
import CoreImage

class FilterVideoViewController: UIViewController, AVCaptureFileOutputRecordingDelegate {

    var captureSession: AVCaptureSession!
    var videoOutput: AVCaptureMovieFileOutput!
    var previewLayer: AVCaptureVideoPreviewLayer!
    var filter: CIFilter!

    override func viewDidLoad() {
        super.viewDidLoad()

        captureSession = AVCaptureSession()

        guard let videoDevice = AVCaptureDevice.default(for: .video) else { return }
        guard let videoInput = try? AVCaptureDeviceInput(device: videoDevice) else { return }
        captureSession.addInput(videoInput)

        videoOutput = AVCaptureMovieFileOutput()
        captureSession.addOutput(videoOutput)

        // カメラのプレビュー表示
        previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
        previewLayer.frame = view.bounds
        view.layer.addSublayer(previewLayer)

        // フィルターの設定
        filter = CIFilter(name: "CISepiaTone")
        previewLayer.filters = [filter]

        captureSession.startRunning()
    }

    @IBAction func startRecording(_ sender: Any) {
        let outputFilePath = NSTemporaryDirectory() + "output.mov"
        let outputURL = URL(fileURLWithPath: outputFilePath)
        videoOutput.startRecording(to: outputURL, recordingDelegate: self)
    }
}

import UIKit
import AVFoundation

class TrimVideoViewController: UIViewController {

    var videoURL: URL?

    func trimVideo(startTime: Float64, endTime: Float64) {
        guard let url = videoURL else { return }
        let asset = AVAsset(url: url)
        let timeRange = CMTimeRange(start: CMTimeMakeWithSeconds(startTime, preferredTimescale: 600), end: CMTimeMakeWithSeconds(endTime, preferredTimescale: 600))

        let exportSession = AVAssetExportSession(asset: asset, presetName: AVAssetExportPresetHighestQuality)!
        exportSession.timeRange = timeRange
        exportSession.outputURL = URL(fileURLWithPath: NSTemporaryDirectory() + "trimmed.mov")
        exportSession.outputFileType = .mov

        exportSession.exportAsynchronously {
            if exportSession.status == .completed {
                DispatchQueue.main.async {
                    print("動画をトリミングしました。")
                }
            } else if let error = exportSession.error {
                DispatchQueue.main.async {
                    print("エラー発生: \(error)")
                }
            }
        }
    }
}

import AVFoundation

func mergeVideos(clip1: URL, clip2: URL, outputURL: URL) {
    let mixComposition = AVMutableComposition()

    guard let firstAsset = AVAsset(url: clip1), let secondAsset = AVAsset(url: clip2) else { return }

    let firstTrack = mixComposition.addMutableTrack(withMediaType: .video, preferredTrackID: Int32(kCMPersistentTrackID_Invalid))
    let secondTrack = mixComposition.addMutableTrack(withMediaType: .video, preferredTrackID: Int32(kCMPersistentTrackID_Invalid))

    do {
        try firstTrack?.insertTimeRange(CMTimeRangeMake(start: CMTime.zero, duration: firstAsset.duration), of: firstAsset.tracks(withMediaType: .video)[0], at: CMTime.zero)
        try secondTrack?.insertTimeRange(CMTimeRangeMake(start: CMTime.zero, duration: secondAsset.duration), of: secondAsset.tracks(withMediaType: .video)[0], at: firstAsset.duration)
    } catch {
        print("エラー発生: \(error.localizedDescription)")
    }

    let exporter = AVAssetExportSession(asset: mixComposition, presetName: AVAssetExportPresetHighestQuality)!
    exporter.outputURL = outputURL
    exporter.outputFileType = .mov
    exporter.shouldOptimizeForNetworkUse = true

    exporter.exportAsynchronously {
        switch exporter.status {
        case .completed:
            print("動画を合成しました。")
        case .failed, .cancelled:
            print("動画の合成に失敗しました: \(String(describing: exporter.error))")
        default:
            break
        }
    }
}

import AVFoundation

func addBackgroundMusicToVideo(videoURL: URL, audioURL: URL, outputURL: URL) {
    let mixComposition = AVMutableComposition()
    guard let asset = AVAsset(url: videoURL), let audioAsset = AVAsset(url: audioURL) else { return }

    let videoTrack = mixComposition.addMutableTrack(withMediaType: .video, preferredTrackID: Int32(kCMPersistentTrackID_Invalid))
    let audioTrack = mixComposition.addMutableTrack(withMediaType: .audio, preferredTrackID: Int32(kCMPersistentTrackID_Invalid))

    do {
        try videoTrack?.insertTimeRange(CMTimeRangeMake(start: CMTime.zero, duration: asset.duration), of: asset.tracks(withMediaType: .video)[0], at: CMTime.zero)
        try audioTrack?.insertTimeRange(CMTimeRangeMake(start: CMTime.zero, duration: asset.duration), of: audioAsset.tracks(withMediaType: .audio)[0], at: CMTime.zero)
    } catch {
        print("エラー発生: \(error.localizedDescription)")
    }

    let exporter = AVAssetExportSession(asset: mixComposition, presetName: AVAssetExportPresetHighestQuality)!
    exporter.outputURL = outputURL
    exporter.outputFileType = .mov

    exporter.exportAsynchronously {
        switch exporter.status {
        case .completed:
            print("BGMを動画に追加しました。")
        case .failed, .cancelled:
            print("BGMの追加に失敗しました: \(String(describing: exporter.error))")
        default:
            break
        }
    }
}

import Foundation

func uploadVideo(videoFileURL: URL, uploadURL: URL) {
    var request = URLRequest(url: uploadURL)
    request.httpMethod = "POST"
    request.setValue("video/mp4", forHTTPHeaderField: "Content-Type")

    let task = URLSession.shared.uploadTask(with: request, fromFile: videoFileURL) { data, response, error in
        if let error = error {
            print("アップロードエラー: \(error.localizedDescription)")
            return
        }
        if let data = data, let responseText = String(data: data, encoding: .utf8) {
            print("アップロード成功: \(responseText)")
        }
    }
    task.resume()
}

import AVFoundation

func trimVideo(originalVideoURL: URL, outputURL: URL, startTime: Double, endTime: Double) {
    let asset = AVAsset(url: originalVideoURL)
    let exportSession = AVAssetExportSession(asset: asset, presetName: AVAssetExportPresetHighestQuality)!
    let timeRange = CMTimeRange(start: CMTime(seconds: startTime, preferredTimescale: 600), end: CMTime(seconds: endTime, preferredTimescale: 600))

    exportSession.outputURL = outputURL
    exportSession.outputFileType = .mov
    exportSession.timeRange = timeRange

    exportSession.exportAsynchronously {
        switch exportSession.status {
        case .completed:
            print("動画の編集が完了しました。")
        case .failed, .cancelled:
            print("動画の編集に失敗しました: \(String(describing: exportSession.error))")
        default:
            break
        }
    }
}

import UIKit

func shareVideo(videoFileURL: URL, fromViewController: UIViewController) {
    let activityViewController = UIActivityViewController(activityItems: [videoFileURL], applicationActivities: nil)
    fromViewController.present(activityViewController, animated: true, completion: nil)
}

import Foundation

func downloadVideo(downloadURL: URL, destinationURL: URL, completion: @escaping (Bool) -> Void) {
    let task = URLSession.shared.downloadTask(with: downloadURL) { temporaryURL, response, error in
        guard let temporaryURL = temporaryURL else {
            completion(false)
            return
        }
        do {
            try FileManager.default.moveItem(at: temporaryURL, to: destinationURL)
            completion(true)
        } catch {
            completion(false)
        }
    }
    task.resume()
}

import AVFoundation

class VideoCaptureManager: NSObject {
    var captureSession: AVCaptureSession?
    var movieOutput: AVCaptureMovieFileOutput?

    init(sessionPreset: AVCaptureSession.Preset) {
        super.init()
        captureSession = AVCaptureSession()
        captureSession?.sessionPreset = sessionPreset
        movieOutput = AVCaptureMovieFileOutput()

        if let captureSession = captureSession {
            if captureSession.canAddOutput(movieOutput!) {
                captureSession.addOutput(movieOutput!)
            }
        }
    }

    func setSlowMotionMode(isSlowMotion: Bool) {
        if let format = movieOutput?.availableMovieCodecTypes.first {
            if isSlowMotion {
                movieOutput?.setMaxRecordedDuration(CMTime(value: 2, timescale: 1))
                movieOutput?.setOutputSettings([AVVideoCodecKey: format,
                                                AVVideoScalingModeKey: AVVideoScalingModeResizeAspectFill], 
                                               for: movieOutput!.connection(with: .video)!)
            } else {
                movieOutput?.setMaxRecordedDuration(CMTime(value: 0, timescale: 1))
            }
        }
    }
}

import AVFoundation

extension VideoCaptureManager {

    func setResolution(isHD: Bool) {
        guard let captureSession = captureSession else { return }

        if isHD {
            if captureSession.canSetSessionPreset(.hd1920x1080) {
                captureSession.sessionPreset = .hd1920x1080
            }
        } else {
            if captureSession.canSetSessionPreset(.hd4K3840x2160) {
                captureSession.sessionPreset = .hd4K3840x2160
            }
        }
    }
}

import AVFoundation

func editVideoMetadata(inputURL: URL, outputURL: URL, title: String, description: String, completion: @escaping (Bool) -> Void) {
    let asset = AVAsset(url: inputURL)
    let exportSession = AVAssetExportSession(asset: asset, presetName: AVAssetExportPresetPassthrough)

    let titleItem = AVMutableMetadataItem()
    titleItem.keySpace = .iTunes
    titleItem.key = AVMetadataiTunesMetadataKeySongName as (NSCopying & NSObjectProtocol)
    titleItem.value = title as (NSCopying & NSObjectProtocol)

    let descriptionItem = AVMutableMetadataItem()
    descriptionItem.keySpace = .iTunes
    descriptionItem.key = AVMetadataiTunesMetadataKeyUserComment as (NSCopying & NSObjectProtocol)
    descriptionItem.value = description as (NSCopying & NSObjectProtocol)

    exportSession?.metadata = [titleItem, descriptionItem]
    exportSession?.outputURL = outputURL
    exportSession?.outputFileType = .mp4

    exportSession?.exportAsynchronously(completionHandler: {
        switch exportSession?.status {
        case .completed:
            completion(true)
        default:
            completion(false)
        }
    })
}

import AVFoundation
import CoreImage

class RealTimeFilterCapture: NSObject, AVCaptureVideoDataOutputSampleBufferDelegate {
    var captureSession: AVCaptureSession!
    var videoPreviewLayer: AVCaptureVideoPreviewLayer!
    var context: CIContext!

    func startSession() {
        captureSession = AVCaptureSession()
        captureSession.sessionPreset = .hd1920x1080

        guard let backCamera = AVCaptureDevice.default(for: .video) else { return }
        do {
            let input = try AVCaptureDeviceInput(device: backCamera)
            if captureSession.canAddInput(input) {
                captureSession.addInput(input)

                let videoOutput = AVCaptureVideoDataOutput()
                videoOutput.setSampleBufferDelegate(self, queue: DispatchQueue.main)
                if captureSession.canAddOutput(videoOutput) {
                    captureSession.addOutput(videoOutput)

                    videoPreviewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
                    videoPreviewLayer.videoGravity = .resizeAspectFill

                    context = CIContext()
                    captureSession.startRunning()
                }
            }
        } catch {
            print("Error: \(error.localizedDescription)")
        }
    }

    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }

        let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
        if let sepiaFilter = CIFilter(name: "CISepiaTone") {
            sepiaFilter.setValue(ciImage, forKey: kCIInputImageKey)
            sepiaFilter.setValue(1.0, forKey: kCIInputIntensityKey)

            if let outputImage = sepiaFilter.outputImage {
                let cgImage = context.createCGImage(outputImage, from: outputImage.extent)
                DispatchQueue.main.async {
                    self.videoPreviewLayer.contents = cgImage
                }
            }
        }
    }
}

import AVFoundation

class MultiCameraCapture: NSObject {
    var captureSession: AVCaptureSession!

    func startSession() {
        captureSession = AVCaptureSession()

        guard let frontCamera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .front),
              let backCamera = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back) else { return }

        do {
            let frontInput = try AVCaptureDeviceInput(device: frontCamera)
            let backInput = try AVCaptureDeviceInput(device: backCamera)

            if captureSession.canAddInput(frontInput) && captureSession.canAddInput(backInput) {
                captureSession.addInput(frontInput)
                captureSession.addInput(backInput)

                captureSession.startRunning()
            }
        } catch {
            print("Error: \(error.localizedDescription)")
        }
    }
}

import AVFoundation

func requestCameraPermission() {
    let status = AVCaptureDevice.authorizationStatus(for: .video)
    switch status {
    case .authorized:
        // 許可されている場合の処理
        break
    case .denied, .restricted:
        // 許可されていない場合の通知
        notifyUserPermissionDenied()
    case .notDetermined:
        AVCaptureDevice.requestAccess(for: .video) { granted in
            if !granted {
                self.notifyUserPermissionDenied()
            }
        }
    default:
        break
    }
}

func notifyUserPermissionDenied() {
    // ユーザーにカメラのアクセス権限がないことを通知する処理
}

import Photos

func saveVideoToPhotoLibrary(url: URL) {
    PHPhotoLibrary.shared().performChanges({
        PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: url)
    }) { (success, error) in
        if !success {
            if let err = error as NSError? {
                switch err.code {
                case -1: // 一般的なエラー
                    self.displayErrorMessage(message: "動画の保存に失敗しました。")
                case -5000: // 保存の権限がない
                    self.displayErrorMessage(message: "動画の保存権限がありません。")
                case -5005: // ストレージ不足
                    self.displayErrorMessage(message: "ストレージが不足しています。不要なデータを削除してください。")
                default:
                    self.displayErrorMessage(message: "不明なエラーが発生しました。")
                }
            }
        }
    }
}

func displayErrorMessage(message: String) {
    // エラーメッセージを表示する処理
}

import AVFoundation

func loadVideo(url: URL) {
    let asset = AVAsset(url: url)
    let playerItem = AVPlayerItem(asset: asset)
    playerItem.addObserver(self, forKeyPath: "status", options: .new, context: nil)
}

override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if keyPath == "status" {
        if let item = object as? AVPlayerItem {
            switch item.status {
            case .failed:
                displayErrorMessage(message: "動画の読み込みに失敗しました。サポートされているファイル形式をご確認ください。")
            default:
                break
            }
        }
    }
}

func displayErrorMessage(message: String) {
    // エラーメッセージを表示する処理
}

import UIKit
import AVFoundation

class CustomCameraViewController: UIViewController {

    var captureSession: AVCaptureSession!
    var shutterButton: UIButton!

    override func viewDidLoad() {
        super.viewDidLoad()
        setupCamera()
        setupUI()
    }

    func setupCamera() {
        // カメラのセットアップ処理
    }

    func setupUI() {
        shutterButton = UIButton(frame: CGRect(x: (view.frame.width - 80) / 2, y: view.frame.height - 100, width: 80, height: 80))
        shutterButton.layer.cornerRadius = 40
        shutterButton.backgroundColor = UIColor.red
        shutterButton.addTarget(self, action: #selector(shutterButtonPressed), for: .touchUpInside)
        view.addSubview(shutterButton)
    }

    @objc func shutterButtonPressed() {
        // シャッターボタンが押されたときの処理
    }
}

import AVFoundation

func setupVideoOutput() {
    let videoOutput = AVCaptureMovieFileOutput()

    let compressionProperties = [
        AVVideoAverageBitRateKey: 3000000, // 3Mbps
        AVVideoMaxKeyFrameIntervalKey: 30,
        AVVideoProfileLevelKey: AVVideoProfileLevelH264High40
    ]

    let videoSettings: [String: Any] = [
        AVVideoCodecKey: AVVideoCodecType.h264,
        AVVideoWidthKey: 1920,
        AVVideoHeightKey: 1080,
        AVVideoCompressionPropertiesKey: compressionProperties
    ]

    videoOutput.movieFragmentInterval = .invalid
    videoOutput.setOutputSettings(videoSettings, for: videoOutput.connection(with: .video)!)

    // 上記設定を使用して、動画出力をセットアップします
}