Media

Media is a community skill for processing and managing digital media files, covering audio transcoding, video format conversion, image optimization, metadata extraction, and batch processing for media pipeline automation.

What Is This?

Overview

Media provides tools for automated processing of audio, video, and image files through programmatic workflows. It covers audio transcoding that converts between formats like WAV, MP3, FLAC, and AAC with configurable bitrate and sample rate settings, video format conversion that transforms video files between containers and codecs with resolution and quality controls, image optimization that resizes, compresses, and converts images between formats with quality preservation, metadata extraction that reads embedded information including duration, resolution, codec details, and EXIF data from media files, and batch processing that applies consistent operations across large file collections with progress tracking. The skill enables developers to build automated media processing pipelines that integrate cleanly into existing content delivery and asset management systems.

Who Should Use This

This skill serves developers building media processing features, content managers automating asset conversion workflows, and DevOps engineers setting up media pipeline infrastructure.

Why Use It?

Problems It Solves

Manual media conversion through desktop applications does not scale for large asset libraries. Different distribution channels require media in specific formats and resolutions that need automated conversion. For example, a single source video may need to be delivered at 1080p for desktop, 720p for mobile, and 360p for low-bandwidth environments. Media metadata is stored in format-specific structures that require specialized parsers to extract. Batch processing across thousands of files requires error handling and progress tracking that manual tools lack.

Core Highlights

Audio converter transcodes between formats with configurable quality settings. Video processor converts containers, codecs, and resolutions. Image optimizer resizes and compresses with format conversion. Metadata reader extracts technical details from any supported media file.

How to Use It?

Basic Usage

import subprocess
import json as js
from pathlib import Path

class MediaProcessor:
  def get_info(
    self,
    path: str
  ) -> dict:
    cmd = [
      'ffprobe',
      '-v', 'quiet',
      '-print_format',
        'json',
      '-show_format',
      '-show_streams',
      path]
    result = subprocess\
      .run(
        cmd,
        capture_output=True,
        text=True)
    return js.loads(
      result.stdout)

  def convert_audio(
    self,
    input_path: str,
    output_path: str,
    bitrate: str
      = '192k'
  ):
    cmd = [
      'ffmpeg', '-i',
      input_path,
      '-b:a', bitrate,
      '-y', output_path]
    subprocess.run(
      cmd, check=True)

  def convert_video(
    self,
    input_path: str,
    output_path: str,
    resolution: str
      = '1920x1080'
  ):
    cmd = [
      'ffmpeg', '-i',
      input_path,
      '-s', resolution,
      '-y', output_path]
    subprocess.run(
      cmd, check=True)

Real-World Examples

class BatchPipeline:
  def __init__(
    self,
    processor:
      MediaProcessor,
    output_dir: str
  ):
    self.proc = processor
    self.out = Path(
      output_dir)
    self.out.mkdir(
      exist_ok=True)

  def process_dir(
    self,
    input_dir: str,
    extensions:
      list[str]
  ) -> dict:
    src = Path(input_dir)
    report = {
      'processed': 0,
      'failed': 0,
      'errors': []}
    for ext in extensions:
      for f in src.glob(
        f'*.{ext}'):
        try:
          out_name = (
            f.stem + '.mp4')
          self.proc\
            .convert_video(
              str(f),
              str(self.out
                / out_name))
          report[
            'processed'
          ] += 1
        except Exception\
            as e:
          report[
            'failed'] += 1
          report[
            'errors'
          ].append(
            str(e))
    return report

Advanced Tips

Use hardware-accelerated encoding with GPU codecs like NVENC when available to speed up video conversion significantly. Implement two-pass encoding for video to achieve better quality at target file sizes. Extract media metadata first to validate format compatibility before starting conversion operations. When running large batch jobs, consider processing files in parallel using a thread pool to reduce total pipeline execution time.

When to Use It?

Use Cases

Convert a library of video files to web-optimized MP4 format with consistent resolution. Transcode audio files to MP3 at a specific bitrate for podcast distribution. Extract metadata from a media collection to build a searchable asset catalog.

Related Topics

Media processing, FFmpeg, audio conversion, video transcoding, image optimization, metadata extraction, and batch processing.

Important Notes

Requirements

FFmpeg installed for audio and video processing operations. Python subprocess module for command execution. Sufficient disk space for input and output files during conversion.

Usage Recommendations

Do: validate input file formats before processing to catch unsupported files early. Use progress callbacks for long-running batch operations to monitor pipeline status. Preserve original files until conversion quality is verified.

Don't: transcode lossy formats through multiple conversion steps since each pass degrades quality. Process untrusted media files without sandboxing since FFmpeg has had parser vulnerabilities. Assume output file size without testing since codec settings dramatically affect results.

Limitations

Processing speed depends on hardware capabilities and codec complexity. Some proprietary codecs require additional licensing or library installations. Quality loss is inherent when converting between lossy formats regardless of bitrate settings.