Various fixes

submodules/TelegramUI/Components/MediaEditor/Sources/MediaEditor.swift

@@ -866,7 +866,10 @@ public final class MediaEditor {
             time = .zero
         }
         let videoStart = self.values.videoTrimRange?.lowerBound ?? 0.0
-        let audioStart = self.values.audioTrackTrimRange?.lowerBound ?? 0.0
+        var audioStart = self.values.audioTrackTrimRange?.lowerBound ?? 0.0
+        if let offset = self.values.audioTrackOffset, offset < 0.0 {
+            audioStart -= offset
+        }
         if audioStart - videoStart > 0.0 {
             let delay = audioStart - time.seconds
             if delay > 0 {
@@ -1121,21 +1124,7 @@ public final class MediaEditor {
         }
         
         if apply {
-            let offset = offset ?? 0.0
-            let lowerBound = self.values.audioTrackTrimRange?.lowerBound ?? 0.0
-            
-            let audioTime: CMTime
-            if self.sourceIsVideo {
-                let time = self.player?.currentTime() ?? .zero
-                audioTime = self.audioTime(for: time)
-            } else {
-                audioTime = CMTime(seconds: offset + lowerBound, preferredTimescale: CMTimeScale(1000))
-            }
             self.updateAudioPlaybackRange()
-            self.audioPlayer?.seek(to: audioTime, toleranceBefore: .zero, toleranceAfter: .zero)
-            if !self.sourceIsVideo {
-                self.audioPlayer?.play()
-            }
         }
     }
     

submodules/TelegramUI/Components/MediaEditorScreen/Sources/MediaEditorScreen.swift

@@ -1351,17 +1351,23 @@ final class MediaEditorScreenComponent: Component {
                         audioOffsetUpdated: { [weak mediaEditor] offset, done in
                             if let mediaEditor {
                                 mediaEditor.setAudioTrackOffset(offset, apply: done)
+                                if isAudioOnly {
+                                    let offset = (mediaEditor.values.audioTrackOffset ?? 0.0)
+                                    let start = (mediaEditor.values.audioTrackTrimRange?.lowerBound ?? 0.0)
                                     if done {
-                                    if !isAudioOnly {
-                                        mediaEditor.play()
+                                        mediaEditor.seek(offset + start, andPlay: true)
+                                    } else {
+                                        mediaEditor.seek(offset + start, andPlay: false)
+                                        mediaEditor.stop()
                                     }
                                 } else {
-                                    if isAudioOnly {
-                                        mediaEditor.seek(offset + (mediaEditor.values.audioTrackTrimRange?.lowerBound ?? 0.0), andPlay: false)
-                                    }
+                                    if done {
+                                        mediaEditor.play()
+                                    } else {
                                         mediaEditor.stop()
                                     }
                                 }
+                            }
                         },
                         audioLongPressed: { [weak self] sourceView in
                             if let self, let controller = self.environment?.controller() as? MediaEditorScreen {

submodules/TelegramUI/Components/MediaEditorScreen/Sources/VideoScrubberComponent.swift

@@ -191,6 +191,12 @@ final class VideoScrubberComponent: Component {
         
         override init(frame: CGRect) {
             self.audioScrollView = UIScrollView()
+            if #available(iOSApplicationExtension 11.0, iOS 11.0, *) {
+                self.audioScrollView.contentInsetAdjustmentBehavior = .never
+            }
+            if #available(iOS 13.0, *) {
+                self.audioScrollView.automaticallyAdjustsScrollIndicatorInsets = false
+            }
             self.audioScrollView.bounces = false
             self.audioScrollView.decelerationRate = .fast
             self.audioScrollView.clipsToBounds = false
@@ -553,8 +559,10 @@ final class VideoScrubberComponent: Component {
                 }
                 if trimDuration > 0.0 {
                     let audioFraction = audioData.duration / trimDuration
+                    if audioFraction < 1.0 - .ulpOfOne || audioFraction > 1.0 + .ulpOfOne {
                         audioTotalWidth = ceil(totalWidth * audioFraction)
                     }
+                }
             } else {
                 self.isAudioSelected = false
             }
@@ -600,6 +608,9 @@ final class VideoScrubberComponent: Component {
             let contentSize = CGSize(width: audioTotalWidth, height: audioScrubberHeight)
             self.ignoreScrollUpdates = true
             if self.audioScrollView.contentSize != contentSize {
+                if !component.audioOnly {
+                    self.audioScrollView.contentInset = UIEdgeInsets(top: 0.0, left: scrubberSize.width, bottom: 0.0, right: scrubberSize.width)
+                }
                 self.audioScrollView.contentSize = contentSize
             }
             
@@ -790,9 +801,23 @@ final class VideoScrubberComponent: Component {
                 }
             }
             
+            var trimViewOffset: CGFloat = 0.0
+            var trimViewVisualInsets: UIEdgeInsets = .zero
+            if self.isAudioSelected {
+                if self.audioScrollView.contentOffset.x < 0.0 {
+                    trimViewOffset = -self.audioScrollView.contentOffset.x
+                    trimViewVisualInsets.right = trimViewOffset
+                } else if self.audioScrollView.contentOffset.x > self.audioScrollView.contentSize.width - self.audioScrollView.frame.width {
+                    let delta = self.audioScrollView.contentOffset.x - (self.audioScrollView.contentSize.width - self.audioScrollView.frame.width)
+                    trimViewOffset = -delta
+                    trimViewVisualInsets.left = delta
+                }
+            }
+                        
             self.trimView.isHollow = self.isAudioSelected || component.audioOnly
             let (leftHandleFrame, rightHandleFrame) = self.trimView.update(
                 totalWidth: totalWidth,
+                visualInsets: trimViewVisualInsets,
                 scrubberSize: scrubberSize,
                 duration: trimDuration,
                 startPosition: startPosition,
@@ -805,6 +830,7 @@ final class VideoScrubberComponent: Component {
             
             let (ghostLeftHandleFrame, ghostRightHandleFrame) = self.ghostTrimView.update(
                 totalWidth: totalWidth,
+                visualInsets: .zero,
                 scrubberSize: CGSize(width: scrubberSize.width, height: collapsedScrubberHeight),
                 duration: component.duration,
                 startPosition: component.startPosition,
@@ -852,7 +878,8 @@ final class VideoScrubberComponent: Component {
                 self.updateCursorPosition()
             }
             
-            videoTransition.setFrame(view: self.trimView, frame: bounds.offsetBy(dx: 0.0, dy: self.isAudioSelected ? 0.0 : originY))
+            let trimViewFrame = CGRect(origin: CGPoint(x: trimViewOffset, y: self.isAudioSelected ? 0.0 : originY), size: bounds.size)
+            videoTransition.setFrame(view: self.trimView, frame: trimViewFrame)
             
             videoTransition.setFrame(view: self.ghostTrimView, frame: bounds.offsetBy(dx: 0.0, dy: originY))
             videoTransition.setAlpha(view: self.ghostTrimView, alpha: self.isAudioSelected ? 0.75 : 0.0)
@@ -1124,6 +1151,7 @@ private class TrimView: UIView {
     
     func update(
         totalWidth: CGFloat,
+        visualInsets: UIEdgeInsets,
         scrubberSize: CGSize,
         duration: Double,
         startPosition: Double,
@@ -1144,13 +1172,15 @@ private class TrimView: UIView {
         let leftHandlePositionFraction = duration > 0.0 ? startPosition / duration : 0.0
         let leftHandlePosition = floorToScreenPixels(handleWidth / 2.0 + totalWidth * leftHandlePositionFraction)
         
-        let leftHandleFrame = CGRect(origin: CGPoint(x: leftHandlePosition - handleWidth / 2.0, y: 0.0), size: CGSize(width: handleWidth, height: scrubberSize.height))
+        var leftHandleFrame = CGRect(origin: CGPoint(x: leftHandlePosition - handleWidth / 2.0, y: 0.0), size: CGSize(width: handleWidth, height: scrubberSize.height))
+        leftHandleFrame.origin.x = max(leftHandleFrame.origin.x, visualInsets.left)
         transition.setFrame(view: self.leftHandleView, frame: leftHandleFrame)
 
         let rightHandlePositionFraction = duration > 0.0 ? endPosition / duration : 1.0
         let rightHandlePosition = floorToScreenPixels(handleWidth / 2.0 + totalWidth * rightHandlePositionFraction)
         
-        let rightHandleFrame = CGRect(origin: CGPoint(x: max(leftHandleFrame.maxX, rightHandlePosition - handleWidth / 2.0), y: 0.0), size: CGSize(width: handleWidth, height: scrubberSize.height))
+        var rightHandleFrame = CGRect(origin: CGPoint(x: max(leftHandleFrame.maxX, rightHandlePosition - handleWidth / 2.0), y: 0.0), size: CGSize(width: handleWidth, height: scrubberSize.height))
+        rightHandleFrame.origin.x = min(rightHandleFrame.origin.x, totalWidth - visualInsets.right)
         transition.setFrame(view: self.rightHandleView, frame: rightHandleFrame)
         
         let capsuleSize = CGSize(width: 2.0, height: 11.0)

submodules/TelegramUI/Components/TelegramAccountAuxiliaryMethods/Sources/TelegramAccountAuxiliaryMethods.swift

@@ -31,7 +31,18 @@ public func makeTelegramAccountAuxiliaryMethods(uploadInBackground: ((Postbox, M
                 return fetchVideoLibraryMediaResource(postbox: postbox, resource: resource, alwaysUseModernPipeline: useModernPipeline)
             }
         } else if let resource = resource as? LocalFileVideoMediaResource {
-            return fetchLocalFileVideoMediaResource(postbox: postbox, resource: resource)
+            return postbox.transaction { transaction -> Bool in
+                var useModernPipeline = true
+                let appConfig = currentAppConfiguration(transaction: transaction)
+                if let data = appConfig.data, let _ = data["ios_killswitch_disable_modern_video_pipeline"] {
+                    useModernPipeline = false
+                }
+                return useModernPipeline
+            }
+            |> castError(MediaResourceDataFetchError.self)
+            |> mapToSignal { useModernPipeline -> Signal<MediaResourceDataFetchResult, MediaResourceDataFetchError> in
+                fetchLocalFileVideoMediaResource(postbox: postbox, resource: resource, alwaysUseModernPipeline: useModernPipeline)
+            }
         } else if let resource = resource as? LocalFileGifMediaResource {
             return fetchLocalFileGifMediaResource(resource: resource)
         } else if let photoLibraryResource = resource as? PhotoLibraryMediaResource {