paving the way for orientation control

api_core.py

@@ -677,6 +677,21 @@ Your caption:"""
         num_inference_steps = self.get_config_value(user_role, 'num_inference_steps', options)
         frame_rate = self.get_config_value(user_role, 'clip_framerate', options)
         
+        # Get orientation from options
+        orientation = options.get('orientation', 'LANDSCAPE')
+        
+        # Adjust width and height based on orientation if needed
+        if orientation == 'PORTRAIT' and width > height:
+            # Swap width and height for portrait orientation
+            width, height = height, width
+            logger.info(f"Orientation: {orientation}, swapped dimensions to width={width}, height={height}")
+        elif orientation == 'LANDSCAPE' and height > width:
+            # Swap height and width for landscape orientation
+            height, width = width, height
+            logger.info(f"Orientation: {orientation}, swapped dimensions to width={width}, height={height}")
+        else:
+            logger.info(f"Orientation: {orientation}, using original dimensions width={width}, height={height}")
+        
         # Log the user role and config values being used
         logger.info(f"Using config values: width={width}, height={height}, num_frames={num_frames}, steps={num_inference_steps}, fps={frame_rate} | role: {user_role}")
         
@@ -725,7 +740,7 @@ Your caption:"""
                 "double_num_frames": False,  # <- False for real-time generation
                 "fps": frame_rate,
                 "super_resolution": False,  # <- False for real-time generation
-                "grain_amount": 0,  # No film grain
+                "grain_amount": 0,  # No film grain (on low-res, low-quality generation the effects aren't worth it + it adds weight to the MP4 payload)
             }
         }
         
@@ -772,7 +787,7 @@ Your caption:"""
                             raise Exception(f"Video generation failed: HTTP {response.status} - {error_text}")
                         
                         result = await response.json()
-                        logger.info(f"[{request_id}] Successfully parsed JSON response")
+                        #logger.info(f"[{request_id}] Successfully parsed JSON response")
                         
                         if "error" in result:
                             error_msg = result['error']
@@ -793,7 +808,7 @@ Your caption:"""
                         
                         # Get data size
                         data_size = len(video_data_uri)
-                        logger.info(f"[{request_id}] Received video data: {data_size} chars")
+                        #logger.info(f"[{request_id}] Received video data: {data_size} chars")
                         
                         # Reset error count on successful call
                         endpoint.error_count = 0

build/web/flutter_bootstrap.js

@@ -39,6 +39,6 @@ _flutter.buildConfig = {"engineRevision":"382be0028d370607f76215a9be322e5514b263
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "658126929"
+    serviceWorkerVersion: "683227308"
   }
 });

build/web/flutter_service_worker.js

@@ -3,11 +3,11 @@ const MANIFEST = 'flutter-app-manifest';
 const TEMP = 'flutter-temp-cache';
 const CACHE_NAME = 'flutter-app-cache';
 
-const RESOURCES = {"flutter_bootstrap.js": "5b9f56e43ffaacf52a435800b8ff1adf",
+const RESOURCES = {"flutter_bootstrap.js": "05bd8824501c20bb663a0f9ab56f5c49",
 "version.json": "b5eaae4fc120710a3c35125322173615",
 "index.html": "cd2094e3989e3eb0424e47d7d188c298",
 "/": "cd2094e3989e3eb0424e47d7d188c298",
-"main.dart.js": "4e26b37ccf9ca902db38fe5292263609",
+"main.dart.js": "62f7660e444a6aa729a12c4639b95395",
 "flutter.js": "83d881c1dbb6d6bcd6b42e274605b69c",
 "aitube.svg": "26140ba0d153b213b122bc6ebcc17f6c",
 "favicon.png": "c8a183c516004e648a7bac7497c89b97",

build/web/index.html

@@ -156,7 +156,7 @@
   </script>
   
   <!-- Add version parameter for cache busting -->
-  <script src="flutter_bootstrap.js?v=1746632747" async></script>
+  <script src="flutter_bootstrap.js?v=1746635426" async></script>
   
   <!-- Add cache busting script -->
   <script>

lib/models/video_orientation.dart

@@ -3,10 +3,10 @@
 /// Enum representing the orientation of a video clip.
 enum VideoOrientation {
   /// Landscape orientation (horizontal, typically 16:9)
-  landscape,
+  LANDSCAPE,
   
   /// Portrait orientation (vertical, typically 9:16)
-  portrait
+  PORTRAIT
 }
 
 /// Extension methods for VideoOrientation enum
@@ -14,24 +14,34 @@ extension VideoOrientationExtension on VideoOrientation {
   /// Get the string representation of the orientation
   String get name {
     switch (this) {
-      case VideoOrientation.landscape:
-        return 'landscape';
-      case VideoOrientation.portrait:
-        return 'portrait';
+      case VideoOrientation.LANDSCAPE:
+        return 'LANDSCAPE';
+      case VideoOrientation.PORTRAIT:
+        return 'PORTRAIT';
     }
   }
   
+  /// Value for API communication
+  String get value {
+    return name;
+  }
+  
   /// Get the orientation from a string
   static VideoOrientation fromString(String? str) {
-    if (str?.toLowerCase() == 'portrait') {
-      return VideoOrientation.portrait;
+    if (str?.toUpperCase() == 'PORTRAIT') {
+      return VideoOrientation.PORTRAIT;
     }
-    return VideoOrientation.landscape; // Default to landscape
+    return VideoOrientation.LANDSCAPE; // Default to landscape
   }
   
   /// Whether this orientation is portrait
-  bool get isPortrait => this == VideoOrientation.portrait;
+  bool get isPortrait => this == VideoOrientation.PORTRAIT;
   
   /// Whether this orientation is landscape
-  bool get isLandscape => this == VideoOrientation.landscape;
+  bool get isLandscape => this == VideoOrientation.LANDSCAPE;
+}
+
+/// Helper function to determine orientation from width and height
+VideoOrientation getOrientationFromDimensions(int width, int height) {
+  return width >= height ? VideoOrientation.LANDSCAPE : VideoOrientation.PORTRAIT;
 }

lib/services/clip_queue/clip_generation_handler.dart

@@ -99,10 +99,11 @@ class ClipGenerationHandler {
         return;
       }
 
-      // Generate new video with timeout
+      // Generate new video with timeout, passing the orientation
       String videoData = await _websocketService.generateVideo(
         video,
         seed: clip.seed,
+        orientation: clip.orientation,
       ).timeout(ClipQueueConstants.generationTimeout);
 
       if (!_isDisposed) {

lib/services/clip_queue/clip_queue_manager.dart

@@ -5,6 +5,7 @@ import 'package:aitube2/config/config.dart';
 import 'package:flutter/foundation.dart';
 import 'package:collection/collection.dart';
 import '../../models/video_result.dart';
+import '../../models/video_orientation.dart';
 import '../websocket_api_service.dart';
 import '../../utils/seed.dart';
 import 'clip_states.dart';
@@ -87,8 +88,14 @@ class ClipQueueManager {
   /// Unmodifiable view of the clip history
   List<VideoClip> get clipHistory => List.unmodifiable(_clipHistory);
 
+  /// Current orientation of clips being generated
+  VideoOrientation _currentOrientation = VideoOrientation.LANDSCAPE;
+  
+  /// Get the current orientation
+  VideoOrientation get currentOrientation => _currentOrientation;
+
   /// Initialize the clip queue
-  Future<void> initialize() async {
+  Future<void> initialize({VideoOrientation? orientation}) async {
     if (_isDisposed) return;
     
     _logger.logStateChange(
@@ -100,6 +107,12 @@ class ClipQueueManager {
     );
     _clipBuffer.clear();
     
+    // Set initial orientation
+    _currentOrientation = orientation ?? getOrientationFromDimensions(
+      Configuration.instance.originalClipWidth, 
+      Configuration.instance.originalClipHeight
+    );
+    
     try {
       final bufferSize = Configuration.instance.renderQueueBufferSize;
       while (_clipBuffer.length < bufferSize) {
@@ -108,9 +121,10 @@ class ClipQueueManager {
         final newClip = VideoClip(
           prompt: "${video.title}\n${video.description}",
           seed: video.useFixedSeed && video.seed > 0 ? video.seed : generateSeed(),
+          orientation: _currentOrientation,
         );
         _clipBuffer.add(newClip);
-        ClipQueueConstants.logEvent('Added initial clip ${newClip.seed} to buffer');
+        ClipQueueConstants.logEvent('Added initial clip ${newClip.seed} to buffer with orientation: ${_currentOrientation.name}');
       }
 
       if (_isDisposed) return;
@@ -182,9 +196,10 @@ class ClipQueueManager {
       final newClip = VideoClip(
         prompt: "${video.title}\n${video.description}",
         seed: video.useFixedSeed && video.seed > 0 ? video.seed : generateSeed(),
+        orientation: _currentOrientation,
       );
       _clipBuffer.add(newClip);
-      ClipQueueConstants.logEvent('Added new clip ${newClip.seed} to maintain buffer size');
+      ClipQueueConstants.logEvent('Added new clip ${newClip.seed} with orientation ${_currentOrientation.name} to maintain buffer size');
     }
 
     // Process played clips first
@@ -301,13 +316,14 @@ class ClipQueueManager {
       _clipBuffer.remove(clip);
       _clipHistory.add(clip);
       
-      // Add a new pending clip
+      // Add a new pending clip with current orientation
       final newClip = VideoClip(
         prompt: "${video.title}\n${video.description}",
         seed: video.useFixedSeed && video.seed > 0 ? video.seed : generateSeed(),
+        orientation: _currentOrientation,
       );
       _clipBuffer.add(newClip);
-      ClipQueueConstants.logEvent('Replaced played clip ${clip.seed} with new clip ${newClip.seed}');
+      ClipQueueConstants.logEvent('Replaced played clip ${clip.seed} with new clip ${newClip.seed} using orientation ${_currentOrientation.name}');
     }
     
     // Immediately trigger buffer fill to start generating new clips
@@ -367,6 +383,32 @@ class ClipQueueManager {
     ClipQueueConstants.logEvent('Manual buffer fill requested');
     _fillBuffer();
   }
+  
+  /// Handle orientation change
+  Future<void> updateOrientation(VideoOrientation newOrientation) async {
+    if (_currentOrientation == newOrientation) {
+      ClipQueueConstants.logEvent('Orientation unchanged: ${newOrientation.name}');
+      return;
+    }
+    
+    ClipQueueConstants.logEvent('Orientation changed from ${_currentOrientation.name} to ${newOrientation.name}');
+    _currentOrientation = newOrientation;
+    
+    // Cancel any active generations
+    for (var clipSeed in _activeGenerations.toList()) {
+      _activeGenerations.remove(clipSeed);
+    }
+    
+    // Clear buffer and history
+    _clipBuffer.clear();
+    _clipHistory.clear();
+    
+    // Re-initialize the queue with the new orientation
+    await initialize(orientation: newOrientation);
+    
+    // Notify listeners
+    onQueueUpdated?.call();
+  }
 
   /// Print the current state of the queue
   void printQueueState() {

lib/services/clip_queue/video_clip.dart

@@ -2,7 +2,9 @@
 
 import 'dart:async';
 import 'package:uuid/uuid.dart';
+import 'package:flutter/foundation.dart';
 import 'clip_states.dart';
+import '../../models/video_orientation.dart';
 
 /// Represents a video clip in the queue
 class VideoClip {
@@ -18,6 +20,9 @@ class VideoClip {
   /// Current state of the clip
   ClipState state;
   
+  /// Device orientation for the clip
+  final VideoOrientation orientation;
+  
   /// Base64 encoded video data
   String? base64Data;
   
@@ -47,6 +52,7 @@ class VideoClip {
     String? id,
     required this.prompt,
     required this.seed,
+    this.orientation = VideoOrientation.LANDSCAPE,
     this.state = ClipState.generationPending,
     this.base64Data,
   }): id = id ?? const Uuid().v4(); 

lib/services/websocket_api_service.dart

@@ -15,6 +15,7 @@ import 'package:web_socket_channel/web_socket_channel.dart';
 import 'package:http/http.dart' as http;
 import '../models/search_state.dart';
 import '../models/video_result.dart';
+import '../models/video_orientation.dart';
 
 class WebSocketRequest {
   final String requestId;
@@ -1136,6 +1137,7 @@ class WebSocketApiService {
     int width = 512,
     int seed = 0,
     Duration timeout = const Duration(seconds: 12), // we keep things super tight, as normally a video only takes 2~3s to generate
+    VideoOrientation orientation = VideoOrientation.LANDSCAPE,
   }) async {
     final settings = SettingsService();
 
@@ -1155,6 +1157,7 @@ class WebSocketApiService {
             'height': Configuration.instance.originalClipHeight,
             'width': Configuration.instance.originalClipWidth,
             'num_frames': Configuration.instance.originalClipNumberOfFrames,
+            'orientation': orientation.value, // Add orientation parameter
             'seed': seed,
           },
         },

lib/widgets/video_player/buffer_manager.dart

@@ -7,6 +7,7 @@ import 'package:aitube2/services/clip_queue/video_clip.dart';
 import 'package:aitube2/services/clip_queue/clip_queue_manager.dart';
 import 'package:video_player/video_player.dart';
 import 'package:aitube2/models/video_result.dart';
+import 'package:aitube2/models/video_orientation.dart';
 
 /// Manages buffering and clip preloading for video player
 class BufferManager {
@@ -25,10 +26,16 @@ class BufferManager {
   /// Timer for debug printing
   Timer? debugTimer;
   
+  /// The video result
+  final VideoResult video;
+  
+  /// Callback when queue is updated
+  final Function() onQueueUpdated;
+  
   /// Constructor
   BufferManager({
-    required VideoResult video,
-    required Function() onQueueUpdated,
+    required this.video,
+    required this.onQueueUpdated,
     ClipQueueManager? existingQueueManager,
   }) : queueManager = existingQueueManager ?? ClipQueueManager(
          video: video,
@@ -149,6 +156,20 @@ class BufferManager {
     return null;
   }
   
+  /// Update the orientation when device rotates
+  Future<void> updateOrientation(VideoOrientation newOrientation) async {
+    if (isDisposed) return;
+    if (queueManager.currentOrientation == newOrientation) return;
+    
+    debugPrint('Updating video orientation to ${newOrientation.name}');
+    
+    // Start loading progress again as we'll be regenerating clips
+    startLoadingProgress();
+    
+    // Update the orientation in the queue manager
+    await queueManager.updateOrientation(newOrientation);
+  }
+  
   /// Dispose resources
   void dispose() {
     isDisposed = true;

lib/widgets/video_player/video_player_widget.dart

@@ -1,11 +1,15 @@
 // lib/widgets/video_player/video_player_widget.dart
 
 import 'dart:async';
+import 'dart:math' as math;
+import 'dart:io' show Platform;
 import 'package:aitube2/config/config.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/foundation.dart' show kDebugMode, kIsWeb;
+import 'package:flutter/foundation.dart';
 import 'package:video_player/video_player.dart';
 import 'package:aitube2/models/video_result.dart';
+import 'package:aitube2/models/video_orientation.dart';
 import 'package:aitube2/theme/colors.dart';
 
 // Import components
@@ -16,6 +20,13 @@ import 'ui_components.dart' as ui;
 // Conditionally import dart:html for web platform
 import '../web_utils.dart' if (dart.library.html) 'dart:html' as html;
 
+// Extension to check if target platform is mobile
+extension TargetPlatformExtension on TargetPlatform {
+  bool get isMobile => 
+      this == TargetPlatform.iOS || 
+      this == TargetPlatform.android;
+}
+
 /// A widget that plays video clips with buffering and automatic playback
 class VideoPlayerWidget extends StatefulWidget {
   /// The video to play
@@ -59,6 +70,9 @@ class _VideoPlayerWidgetState extends State<VideoPlayerWidget> with WidgetsBindi
   
   /// Whether playback was happening before going to background
   bool _wasPlayingBeforeBackground = false;
+  
+  /// Current orientation
+  VideoOrientation _currentOrientation = VideoOrientation.LANDSCAPE;
 
   @override
   void initState() {
@@ -120,6 +134,12 @@ class _VideoPlayerWidgetState extends State<VideoPlayerWidget> with WidgetsBindi
   Future<void> _initializePlayer() async {
     if (_isDisposed) return;
     
+    // Get initial orientation
+    final mediaQuery = MediaQuery.of(context);
+    _currentOrientation = mediaQuery.orientation == Orientation.landscape
+        ? VideoOrientation.LANDSCAPE
+        : VideoOrientation.PORTRAIT;
+    
     _playbackController = PlaybackController();
     _playbackController.isLoading = true;
     _playbackController.isInitialLoad = true;
@@ -138,7 +158,7 @@ class _VideoPlayerWidgetState extends State<VideoPlayerWidget> with WidgetsBindi
         },
       );
       
-      // Initialize buffer manager
+      // Initialize buffer manager with current orientation
       await _bufferManager.initialize();
     }
     
@@ -354,6 +374,46 @@ class _VideoPlayerWidgetState extends State<VideoPlayerWidget> with WidgetsBindi
   Widget build(BuildContext context) {
     return LayoutBuilder(
       builder: (context, constraints) {
+        // Determine orientation based on form factor rather than device orientation
+        // This ensures proper behavior on desktop platforms
+        VideoOrientation newOrientation;
+        
+        if (kIsWeb || !defaultTargetPlatform.isMobile) {
+          // For web and desktop platforms, use form factor (width vs height) to determine orientation
+          newOrientation = constraints.maxWidth > constraints.maxHeight 
+              ? VideoOrientation.LANDSCAPE 
+              : VideoOrientation.PORTRAIT;
+          
+          // Add a small buffer so we don't change orientation too frequently on borderline cases
+          if (newOrientation == VideoOrientation.LANDSCAPE && 
+              constraints.maxWidth / constraints.maxHeight < 1.05) {
+            newOrientation = _currentOrientation;
+          } else if (newOrientation == VideoOrientation.PORTRAIT &&
+              constraints.maxHeight / constraints.maxWidth < 1.05) {
+            newOrientation = _currentOrientation;
+          }
+        } else {
+          // For mobile platforms, use the device orientation
+          final orientation = MediaQuery.of(context).orientation;
+          newOrientation = orientation == Orientation.landscape
+              ? VideoOrientation.LANDSCAPE
+              : VideoOrientation.PORTRAIT;
+        }
+        
+        // Check if orientation changed
+        if (newOrientation != _currentOrientation) {
+          debugPrint('Orientation changed to ${newOrientation.name} (form factor: ${constraints.maxWidth}x${constraints.maxHeight})');
+          _currentOrientation = newOrientation;
+          
+          // Update buffer manager orientation (without awaiting to avoid blocking UI)
+          Future.microtask(() async {
+            if (!_isDisposed && mounted) {
+              await _bufferManager.updateOrientation(newOrientation);
+            }
+          });
+        }
+        
+        // Video player layout
         final controller = _playbackController.currentController;
         final aspectRatio = controller?.value.aspectRatio ?? 16/9;
         final playerHeight = constraints.maxWidth / aspectRatio;