peg-this 3.0.1__py3-none-any.whl → 4.0.0__py3-none-any.whl

peg_this/features/audio.py

@@ -0,0 +1,38 @@
+
+from pathlib import Path
+
+import ffmpeg
+import questionary
+from rich.console import Console
+
+from peg_this.utils.ffmpeg_utils import run_command, has_audio_stream
+
+console = Console()
+
+
+def extract_audio(file_path):
+    """Extract the audio track from a video file."""
+    if not has_audio_stream(file_path):
+        console.print("[bold red]Error: No audio stream found in the file.[/bold red]")
+        questionary.press_any_key_to_continue().ask()
+        return
+
+    audio_format = questionary.select("Select audio format:", choices=["mp3", "flac", "wav"], use_indicator=True).ask()
+    if not audio_format: return
+
+    output_file = f"{Path(file_path).stem}_audio.{audio_format}"
+    stream = ffmpeg.input(file_path).output(output_file, vn=None, acodec='libmp3lame' if audio_format == 'mp3' else audio_format, y=None)
+    
+    run_command(stream, f"Extracting audio to {audio_format.upper()}...", show_progress=True)
+    console.print(f"[bold green]Successfully extracted audio to {output_file}[/bold green]")
+    questionary.press_any_key_to_continue().ask()
+
+
+def remove_audio(file_path):
+    """Create a silent version of a video."""
+    output_file = f"{Path(file_path).stem}_no_audio{Path(file_path).suffix}"
+    stream = ffmpeg.input(file_path).output(output_file, vcodec='copy', an=None, y=None)
+    
+    run_command(stream, "Removing audio track...", show_progress=True)
+    console.print(f"[bold green]Successfully removed audio, saved to {output_file}[/bold green]")
+    questionary.press_any_key_to_continue().ask()

peg_this/features/batch.py

@@ -0,0 +1,125 @@
+
+import os
+import logging
+from pathlib import Path
+
+import ffmpeg
+import questionary
+from rich.console import Console
+
+from peg_this.utils.ffmpeg_utils import run_command, has_audio_stream
+from peg_this.utils.ui_utils import get_media_files
+
+console = Console()
+
+
+def batch_convert():
+    """Convert all media files in the directory to a specific format."""
+    media_files = get_media_files()
+    if not media_files:
+        console.print("[bold yellow]No media files found in the current directory.[/bold yellow]")
+        questionary.press_any_key_to_continue().ask()
+        return
+
+    output_format = questionary.select(
+        "Select output format for the batch conversion:",
+        choices=["mp4", "mkv", "mov", "avi", "webm", "mp3", "flac", "wav", "gif"],
+        use_indicator=True
+    ).ask()
+    if not output_format: return
+
+    quality_preset = None
+    if output_format in ["mp4", "mkv", "mov", "avi", "webm"]:
+        quality_preset = questionary.select(
+            "Select quality preset:",
+            choices=["Same as source", "High (CRF 18)", "Medium (CRF 23)", "Low (CRF 28)"],
+            use_indicator=True
+        ).ask()
+        if not quality_preset: return
+
+    confirm = questionary.confirm(
+        f"This will convert {len(media_files)} file(s) in the current directory to .{output_format}. Continue?",
+        default=False
+    ).ask()
+
+    if not confirm:
+        console.print("[bold yellow]Batch conversion cancelled.[/bold yellow]")
+        return
+
+    success_count = 0
+    fail_count = 0
+
+    for file in media_files:
+        console.rule(f"Processing: {file}")
+        file_path = os.path.abspath(file)
+        is_gif = Path(file_path).suffix.lower() == '.gif'
+        has_audio = has_audio_stream(file_path)
+
+        if (is_gif or not has_audio) and output_format in ["mp3", "flac", "wav"]:
+            console.print(f"[bold yellow]Skipping {file}: Source has no audio to convert.[/bold yellow]")
+            continue
+
+        output_file = f"{Path(file_path).stem}_batch.{output_format}"
+        input_stream = ffmpeg.input(file_path)
+        output_stream = None
+        kwargs = {'y': None}
+
+        try:
+            if output_format in ["mp4", "mkv", "mov", "avi", "webm"]:
+                if quality_preset == "Same as source":
+                    kwargs['c'] = 'copy'
+                else:
+                    crf = quality_preset.split(" ")[-1][1:-1]
+                    kwargs['c:v'] = 'libx264'
+                    kwargs['crf'] = crf
+                    kwargs['pix_fmt'] = 'yuv420p'
+                    if has_audio:
+                        kwargs['c:a'] = 'aac'
+                        kwargs['b:a'] = '192k'
+                    else:
+                        kwargs['an'] = None
+                output_stream = input_stream.output(output_file, **kwargs)
+
+            elif output_format in ["mp3", "flac", "wav"]:
+                kwargs['vn'] = None
+                kwargs['c:a'] = 'libmp3lame' if output_format == 'mp3' else output_format
+                if output_format == 'mp3':
+                    kwargs['b:a'] = '192k' # Default bitrate for batch
+                output_stream = input_stream.output(output_file, **kwargs)
+
+            elif output_format == "gif":
+                fps = "15"
+                scale = "480"
+                palette_file = f"palette_{Path(file_path).stem}.png"
+                
+                palette_gen_stream = input_stream.video.filter('fps', fps=fps).filter('scale', w=scale, h=-1, flags='lanczos').filter('palettegen')
+                run_command(palette_gen_stream.output(palette_file, y=None), f"Generating palette for {file}...")
+
+                if not os.path.exists(palette_file):
+                    console.print(f"[bold red]Failed to generate color palette for {file}.[/bold red]")
+                    fail_count += 1
+                    continue
+
+                palette_input = ffmpeg.input(palette_file)
+                video_stream = input_stream.video.filter('fps', fps=fps).filter('scale', w=scale, h=-1, flags='lanczos')
+                final_stream = ffmpeg.filter([video_stream, palette_input], 'paletteuse')
+                output_stream = final_stream.output(output_file, y=None)
+
+            if output_stream and run_command(output_stream, f"Converting {file}...", show_progress=True):
+                console.print(f"  -> [bold green]Successfully converted to {output_file}[/bold green]")
+                success_count += 1
+            else:
+                console.print(f"  -> [bold red]Failed to convert {file}.[/bold red]")
+                fail_count += 1
+
+            if output_format == "gif" and os.path.exists(f"palette_{Path(file_path).stem}.png"):
+                os.remove(f"palette_{Path(file_path).stem}.png")
+
+        except Exception as e:
+            console.print(f"[bold red]An unexpected error occurred while processing {file}: {e}[/bold red]")
+            logging.error(f"Batch convert error for file {file}: {e}")
+            fail_count += 1
+
+    console.rule("[bold green]Batch Conversion Complete[/bold green]")
+    console.print(f"Successful: {success_count} | Failed: {fail_count}")
+    questionary.press_any_key_to_continue().ask()

peg_this/features/convert.py

@@ -0,0 +1,225 @@
+
+import os
+from pathlib import Path
+
+import ffmpeg
+import questionary
+from rich.console import Console
+
+from peg_this.utils.ffmpeg_utils import run_command, has_audio_stream
+
+console = Console()
+
+
+def convert_file(file_path):
+    """Convert the file to a different format."""
+    is_gif = Path(file_path).suffix.lower() == '.gif'
+    has_audio = has_audio_stream(file_path)
+
+    output_format = questionary.select("Select the output format:", choices=["mp4", "mkv", "mov", "avi", "webm", "mp3", "flac", "wav", "gif"], use_indicator=True).ask()
+    if not output_format: return
+
+    if (is_gif or not has_audio) and output_format in ["mp3", "flac", "wav"]:
+        console.print("[bold red]Error: Source has no audio to convert.[/bold red]")
+        questionary.press_any_key_to_continue().ask()
+        return
+
+    output_file = f"{Path(file_path).stem}_converted.{output_format}"
+    
+    input_stream = ffmpeg.input(file_path)
+    output_stream = None
+    kwargs = {'y': None}
+
+    if output_format in ["mp4", "mkv", "mov", "avi", "webm"]:
+        quality = questionary.select("Select quality preset:", choices=["Same as source", "High (CRF 18)", "Medium (CRF 23)", "Low (CRF 28)"], use_indicator=True).ask()
+        if not quality: return
+
+        if quality == "Same as source":
+            kwargs['c'] = 'copy'
+        else:
+            crf = quality.split(" ")[-1][1:-1]
+            kwargs['c:v'] = 'libx264'
+            kwargs['crf'] = crf
+            kwargs['pix_fmt'] = 'yuv420p'
+            if has_audio:
+                kwargs['c:a'] = 'aac'
+                kwargs['b:a'] = '192k'
+            else:
+                kwargs['an'] = None
+        output_stream = input_stream.output(output_file, **kwargs)
+
+    elif output_format in ["mp3", "flac", "wav"]:
+        kwargs['vn'] = None
+        if output_format == 'mp3':
+            bitrate = questionary.select("Select audio bitrate:", choices=["128k", "192k", "256k", "320k"]).ask()
+            if not bitrate: return
+            kwargs['c:a'] = 'libmp3lame'
+            kwargs['b:a'] = bitrate
+        else:
+            kwargs['c:a'] = output_format
+        output_stream = input_stream.output(output_file, **kwargs)
+
+    elif output_format == "gif":
+        fps = questionary.text("Enter frame rate (e.g., 15):", default="15").ask()
+        if not fps: return
+        scale = questionary.text("Enter width in pixels (e.g., 480):", default="480").ask()
+        if not scale: return
+        
+        palette_file = f"palette_{Path(file_path).stem}.png"
+        
+        # Correctly chain filters for palette generation using explicit w/h arguments
+        palette_gen_stream = input_stream.video.filter('fps', fps=fps).filter('scale', w=scale, h=-1, flags='lanczos').filter('palettegen')
+        run_command(palette_gen_stream.output(palette_file, y=None), "Generating color palette...")
+
+        if not os.path.exists(palette_file):
+            console.print("[bold red]Failed to generate color palette for GIF.[/bold red]")
+            questionary.press_any_key_to_continue().ask()
+            return
+
+        palette_input = ffmpeg.input(palette_file)
+        video_stream = input_stream.video.filter('fps', fps=fps).filter('scale', w=scale, h=-1, flags='lanczos')
+        
+        final_stream = ffmpeg.filter([video_stream, palette_input], 'paletteuse')
+        output_stream = final_stream.output(output_file, y=None)
+
+    if output_stream and run_command(output_stream, f"Converting to {output_format}...", show_progress=True):
+        console.print(f"[bold green]Successfully converted to {output_file}[/bold green]")
+    else:
+        console.print("[bold red]Conversion failed.[/bold red]")
+
+    if output_format == "gif" and os.path.exists(f"palette_{Path(file_path).stem}.png"):
+        os.remove(f"palette_{Path(file_path).stem}.png")
+        
+    questionary.press_any_key_to_continue().ask()
+
+
+def convert_image(file_path):
+    """Convert an image to a different format."""
+    output_format = questionary.select(
+        "Select the output format:",
+        choices=["jpg", "png", "webp", "bmp", "tiff"],
+        use_indicator=True
+    ).ask()
+    if not output_format: return
+
+    output_file = f"{Path(file_path).stem}_converted.{output_format}"
+    kwargs = {'y': None}
+    
+    # For JPG and WEBP, allow quality selection
+    if output_format in ['jpg', 'webp']:
+        quality_preset = questionary.select(
+            "Select quality preset:",
+            choices=["High (95%)", "Medium (80%)", "Low (60%)"],
+            use_indicator=True
+        ).ask()
+        if not quality_preset: return
+
+        quality_map = {"High (95%)": "95", "Medium (80%)": "80", "Low (60%)": "60"}
+        quality = quality_map[quality_preset]
+
+        if output_format == 'jpg':
+            q_scale = int(31 - (int(quality) / 100.0) * 30)
+            kwargs['q:v'] = q_scale
+        elif output_format == 'webp':
+            kwargs['quality'] = quality
+
+    stream = ffmpeg.input(file_path).output(output_file, **kwargs)
+    
+    if run_command(stream, f"Converting to {output_format.upper()}..."):
+        console.print(f"[bold green]Successfully converted image to {output_file}[/bold green]")
+    else:
+        console.print("[bold red]Image conversion failed.[/bold red]")
+    
+    questionary.press_any_key_to_continue().ask()
+
+
+def resize_image(file_path):
+    """Resize an image to new dimensions."""
+    console.print("Enter new dimensions. Use [bold]-1[/bold] for one dimension to preserve aspect ratio.")
+    width = questionary.text("Enter new width (e.g., 1280 or -1):").ask()
+    if not width: return
+    height = questionary.text("Enter new height (e.g., 720 or -1):").ask()
+    if not height: return
+
+    try:
+        if int(width) == -1 and int(height) == -1:
+            console.print("[bold red]Error: Width and Height cannot both be -1.[/bold red]")
+            questionary.press_any_key_to_continue().ask()
+            return
+    except ValueError:
+        console.print("[bold red]Error: Invalid dimensions. Please enter numbers.[/bold red]")
+        questionary.press_any_key_to_continue().ask()
+        return
+
+    output_file = f"{Path(file_path).stem}_resized{Path(file_path).suffix}"
+    
+    stream = ffmpeg.input(file_path).filter('scale', w=width, h=height).output(output_file, y=None)
+    
+    if run_command(stream, "Resizing image..."):
+        console.print(f"[bold green]Successfully resized image to {output_file}[/bold green]")
+    else:
+        console.print("[bold red]Image resizing failed.[/bold red]")
+        
+    questionary.press_any_key_to_continue().ask()
+
+
+def rotate_image(file_path):
+    """Rotate an image."""
+    rotation = questionary.select(
+        "Select rotation:",
+        choices=[
+            "90 degrees clockwise",
+            "90 degrees counter-clockwise",
+            "180 degrees"
+        ],
+        use_indicator=True
+    ).ask()
+    if not rotation: return
+
+    output_file = f"{Path(file_path).stem}_rotated{Path(file_path).suffix}"
+    
+    stream = ffmpeg.input(file_path)
+    if rotation == "90 degrees clockwise":
+        stream = stream.filter('transpose', 1)
+    elif rotation == "90 degrees counter-clockwise":
+        stream = stream.filter('transpose', 2)
+    elif rotation == "180 degrees":
+        # Apply 90-degree rotation twice for 180 degrees
+        stream = stream.filter('transpose', 2).filter('transpose', 2)
+
+    output_stream = stream.output(output_file, y=None)
+    
+    if run_command(output_stream, "Rotating image..."):
+        console.print(f"[bold green]Successfully rotated image and saved to {output_file}[/bold green]")
+    else:
+        console.print("[bold red]Image rotation failed.[/bold red]")
+        
+    questionary.press_any_key_to_continue().ask()
+
+
+def flip_image(file_path):
+    """Flip an image horizontally or vertically."""
+    flip_direction = questionary.select(
+        "Select flip direction:",
+        choices=["Horizontal", "Vertical"],
+        use_indicator=True
+    ).ask()
+    if not flip_direction: return
+
+    output_file = f"{Path(file_path).stem}_flipped{Path(file_path).suffix}"
+    
+    stream = ffmpeg.input(file_path)
+    if flip_direction == "Horizontal":
+        stream = stream.filter('hflip')
+    else:
+        stream = stream.filter('vflip')
+
+    output_stream = stream.output(output_file, y=None)
+    
+    if run_command(output_stream, "Flipping image..."):
+        console.print(f"[bold green]Successfully flipped image and saved to {output_file}[/bold green]")
+    else:
+        console.print("[bold red]Image flipping failed.[/bold red]")
+        
+    questionary.press_any_key_to_continue().ask()
+

peg_this/features/crop.py

@@ -0,0 +1,178 @@
+
+import os
+from pathlib import Path
+
+import ffmpeg
+import questionary
+from rich.console import Console
+
+from peg_this.utils.ffmpeg_utils import run_command, has_audio_stream
+
+try:
+    import tkinter as tk
+    from tkinter import messagebox
+    from PIL import Image, ImageTk
+except ImportError:
+    tk = None
+
+console = Console()
+
+
+def crop_video(file_path):
+    """Visually crop a video by selecting an area."""
+    if not tk:
+        console.print("[bold red]Cannot perform visual cropping: tkinter & Pillow are not installed.[/bold red]")
+        return
+
+    preview_frame = f"preview_{Path(file_path).stem}.jpg"
+    try:
+        # Extract a frame from the middle of the video for preview
+        probe = ffmpeg.probe(file_path)
+        duration = float(probe['format']['duration'])
+        mid_point = duration / 2
+        
+        # Corrected frame extraction command with `-q:v`
+        run_command(
+            ffmpeg.input(file_path, ss=mid_point).output(preview_frame, vframes=1, **{'q:v': 2}, y=None),
+            "Extracting a frame for preview..."
+        )
+
+        if not os.path.exists(preview_frame):
+            console.print("[bold red]Could not extract a frame from the video.[/bold red]")
+            return
+
+        # --- Tkinter GUI for Cropping ---
+        root = tk.Tk()
+        root.title("Crop Video - Drag to select area, close window to confirm")
+        root.attributes("-topmost", True)
+
+        img = Image.open(preview_frame)
+        img_tk = ImageTk.PhotoImage(img)
+
+        canvas = tk.Canvas(root, width=img.width, height=img.height, cursor="cross")
+        canvas.pack()
+        canvas.create_image(0, 0, anchor=tk.NW, image=img_tk)
+
+        rect_coords = {"x1": 0, "y1": 0, "x2": 0, "y2": 0}
+        rect_id = None
+
+        def on_press(event):
+            nonlocal rect_id
+            rect_coords['x1'], rect_coords['y1'] = event.x, event.y
+            rect_id = canvas.create_rectangle(0, 0, 1, 1, outline='red', width=2)
+
+        def on_drag(event):
+            rect_coords['x2'], rect_coords['y2'] = event.x, event.y
+            canvas.coords(rect_id, rect_coords['x1'], rect_coords['y1'], rect_coords['x2'], rect_coords['y2'])
+
+        canvas.bind("<ButtonPress-1>", on_press)
+        canvas.bind("<B1-Motion>", on_drag)
+        
+        messagebox.showinfo("Instructions", "Click and drag to draw a cropping rectangle.\nClose this window when you are done.", parent=root)
+        root.mainloop()
+
+        # --- Cropping Logic ---
+        crop_w = abs(rect_coords['x2'] - rect_coords['x1'])
+        crop_h = abs(rect_coords['y2'] - rect_coords['y1'])
+        crop_x = min(rect_coords['x1'], rect_coords['x2'])
+        crop_y = min(rect_coords['y1'], rect_coords['y2'])
+
+        if crop_w < 2 or crop_h < 2: # Avoid tiny, invalid crops
+            console.print("[bold yellow]Cropping cancelled as no valid area was selected.[/bold yellow]")
+            return
+
+        console.print(f"Selected crop area: [bold]width={crop_w} height={crop_h} at (x={crop_x}, y={crop_y})[/bold]")
+
+        output_file = f"{Path(file_path).stem}_cropped{Path(file_path).suffix}"
+        
+        input_stream = ffmpeg.input(file_path)
+        video_stream = input_stream.video.filter('crop', w=crop_w, h=crop_h, x=crop_x, y=crop_y)
+        
+        kwargs = {'y': None} # Overwrite output
+        # Check for audio and copy it if it exists
+        if has_audio_stream(file_path):
+            audio_stream = input_stream.audio
+            kwargs['c:a'] = 'copy'
+            stream = ffmpeg.output(video_stream, audio_stream, output_file, **kwargs)
+        else:
+            stream = ffmpeg.output(video_stream, output_file, **kwargs)
+
+        run_command(stream, "Applying crop to video...", show_progress=True)
+        console.print(f"[bold green]Successfully cropped video and saved to {output_file}[/bold green]")
+
+    finally:
+        if os.path.exists(preview_frame):
+            os.remove(preview_frame)
+        questionary.press_any_key_to_continue().ask()
+
+
+def crop_image(file_path):
+    """Visually crop an image by selecting an area."""
+    if not tk:
+        console.print("[bold red]Cannot perform visual cropping: tkinter & Pillow are not installed.[/bold red]")
+        console.print("Please install them with: [bold]pip install tk Pillow[/bold]")
+        questionary.press_any_key_to_continue().ask()
+        return
+
+    try:
+        # --- Tkinter GUI for Cropping ---
+        root = tk.Tk()
+        root.title("Crop Image - Drag to select area, close window to confirm")
+        root.attributes("-topmost", True)
+
+        img = Image.open(file_path)
+        
+        max_width = root.winfo_screenwidth() - 100
+        max_height = root.winfo_screenheight() - 100
+        img.thumbnail((max_width, max_height), Image.Resampling.LANCZOS)
+        
+        img_tk = ImageTk.PhotoImage(img)
+
+        canvas = tk.Canvas(root, width=img.width, height=img.height, cursor="cross")
+        canvas.pack()
+        canvas.create_image(0, 0, anchor=tk.NW, image=img_tk)
+
+        rect_coords = {"x1": 0, "y1": 0, "x2": 0, "y2": 0}
+        rect_id = None
+
+        def on_press(event):
+            nonlocal rect_id
+            rect_coords['x1'], rect_coords['y1'] = event.x, event.y
+            rect_id = canvas.create_rectangle(0, 0, 1, 1, outline='red', width=2)
+
+        def on_drag(event):
+            rect_coords['x2'], rect_coords['y2'] = event.x, event.y
+            canvas.coords(rect_id, rect_coords['x1'], rect_coords['y1'], rect_coords['x2'], rect_coords['y2'])
+
+        canvas.bind("<ButtonPress-1>", on_press)
+        canvas.bind("<B1-Motion>", on_drag)
+        
+        messagebox.showinfo("Instructions", "Click and drag to draw a cropping rectangle.\nClose this window when you are done.", parent=root)
+        root.mainloop()
+
+        # --- Cropping Logic ---
+        crop_w = abs(rect_coords['x2'] - rect_coords['x1'])
+        crop_h = abs(rect_coords['y2'] - rect_coords['y1'])
+        crop_x = min(rect_coords['x1'], rect_coords['x2'])
+        crop_y = min(rect_coords['y1'], rect_coords['y2'])
+
+        if crop_w < 2 or crop_h < 2:
+            console.print("[bold yellow]Cropping cancelled as no valid area was selected.[/bold yellow]")
+            questionary.press_any_key_to_continue().ask()
+            return
+
+        console.print(f"Selected crop area: [bold]width={crop_w} height={crop_h} at (x={crop_x}, y={crop_y})[/bold]")
+
+        output_file = f"{Path(file_path).stem}_cropped{Path(file_path).suffix}"
+        
+        stream = ffmpeg.input(file_path).filter('crop', w=crop_w, h=crop_h, x=crop_x, y=crop_y).output(output_file, y=None)
+
+        if run_command(stream, "Applying crop to image..."):
+            console.print(f"[bold green]Successfully cropped image and saved to {output_file}[/bold green]")
+        else:
+            console.print("[bold red]Image cropping failed.[/bold red]")
+
+    except Exception as e:
+        console.print(f"[bold red]An error occurred during cropping: {e}[/bold red]")
+    finally:
+        questionary.press_any_key_to_continue().ask()

peg_this/features/inspect.py

@@ -0,0 +1,60 @@
+
+import os
+import logging
+
+import ffmpeg
+import questionary
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def inspect_file(file_path):
+    """Show detailed information about the selected media file using ffprobe."""
+    console.print(f"Inspecting {os.path.basename(file_path)}...")
+    try:
+        info = ffmpeg.probe(file_path)
+    except ffmpeg.Error as e:
+        console.print("[bold red]An error occurred while inspecting the file:[/bold red]")
+        console.print(e.stderr.decode('utf-8'))
+        logging.error(f"ffprobe error:{e.stderr.decode('utf-8')}")
+        questionary.press_any_key_to_continue().ask()
+        return
+
+    format_info = info.get('format', {})
+    table = Table(title=f"File Information: {os.path.basename(file_path)}", show_header=True, header_style="bold magenta")
+    table.add_column("Property", style="dim")
+    table.add_column("Value")
+
+    size_mb = float(format_info.get('size', 0)) / (1024 * 1024)
+    duration_sec = float(format_info.get('duration', 0))
+    bit_rate_kbps = float(format_info.get('bit_rate', 0)) / 1000
+
+    table.add_row("Size", f"{size_mb:.2f} MB")
+    table.add_row("Duration", f"{duration_sec:.2f} seconds")
+    table.add_row("Format", format_info.get('format_long_name', 'N/A'))
+    table.add_row("Bitrate", f"{bit_rate_kbps:.0f} kb/s")
+    console.print(table)
+
+    for stream_type in ['video', 'audio']:
+        streams = [s for s in info.get('streams', []) if s.get('codec_type') == stream_type]
+        if streams:
+            stream_table = Table(title=f"{stream_type.capitalize()} Streams", show_header=True, header_style=f"bold {'cyan' if stream_type == 'video' else 'green'}")
+            stream_table.add_column("Stream")
+            stream_table.add_column("Codec")
+            if stream_type == 'video':
+                stream_table.add_column("Resolution")
+                stream_table.add_column("Frame Rate")
+            else:
+                stream_table.add_column("Sample Rate")
+                stream_table.add_column("Channels")
+            
+            for s in streams:
+                if stream_type == 'video':
+                    stream_table.add_row(f"#{s.get('index')}", s.get('codec_name'), f"{s.get('width')}x{s.get('height')}", s.get('r_frame_rate'))
+                else:
+                    stream_table.add_row(f"#{s.get('index')}", s.get('codec_name'), f"{s.get('sample_rate')} Hz", str(s.get('channels')))
+            console.print(stream_table)
+
+    questionary.press_any_key_to_continue().ask()