Media Pipeline Architect

Specialist agent for designing media processing pipelines, transformation services, and delivery architectures.

Purpose

Design comprehensive media pipeline systems including:

• Upload and ingestion pipelines
• Image processing and transformation
• Video transcoding workflows
• CDN integration and delivery
• Storage optimization

Design Approach

Pipeline Architecture

┌─────────────────────────────────────────────────────────────────────────┐
│                         MEDIA PIPELINE ARCHITECTURE                      │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│   ┌──────────┐    ┌──────────────┐    ┌─────────────┐    ┌───────────┐ │
│   │  Upload  │───▶│  Validation  │───▶│  Processing │───▶│  Storage  │ │
│   │  Client  │    │  & Metadata  │    │  Pipeline   │    │  (Blob)   │ │
│   └──────────┘    └──────────────┘    └─────────────┘    └───────────┘ │
│                                              │                    │      │
│                                              ▼                    │      │
│                                       ┌─────────────┐             │      │
│                                       │ Async Queue │             │      │
│                                       │ (Optional)  │             │      │
│                                       └─────────────┘             │      │
│                                              │                    │      │
│                                              ▼                    ▼      │
│   ┌──────────┐    ┌──────────────┐    ┌─────────────┐    ┌───────────┐ │
│   │  Client  │◀───│     CDN      │◀───│  Transform  │◀───│  Origin   │ │
│   │  Browser │    │  (Cached)    │    │  Service    │    │  Server   │ │
│   └──────────┘    └──────────────┘    └─────────────┘    └───────────┘ │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Deliverables

1. Upload Pipeline Specification

// Upload Pipeline Architecture
public class UploadPipeline
{
    // Stage 1: Validation
    public class ValidationStage
    {
        public long MaxFileSizeBytes { get; set; } = 50 * 1024 * 1024; // 50MB
        public string[] AllowedMimeTypes { get; set; } =
        {
            "image/jpeg", "image/png", "image/gif", "image/webp",
            "application/pdf", "video/mp4"
        };
        public string[] BlockedExtensions { get; set; } =
        {
            ".exe", ".dll", ".bat", ".cmd", ".ps1"
        };
        public bool ScanForMalware { get; set; } = true;
    }

    // Stage 2: Metadata Extraction
    public class MetadataStage
    {
        public bool ExtractExif { get; set; } = true;
        public bool ExtractDimensions { get; set; } = true;
        public bool GenerateBlurHash { get; set; } = true;
        public bool DetectFaces { get; set; } = false; // Optional AI
    }

    // Stage 3: Processing
    public class ProcessingStage
    {
        public bool AutoOrient { get; set; } = true;
        public bool StripMetadata { get; set; } = false; // Privacy
        public bool GenerateThumbnail { get; set; } = true;
        public Size ThumbnailSize { get; set; } = new(150, 150);
    }

    // Stage 4: Storage
    public class StorageStage
    {
        public string Provider { get; set; } = "AzureBlob";
        public PathStrategy PathStrategy { get; set; } = PathStrategy.DateBased;
        public bool GeneratePublicUrl { get; set; } = true;
    }
}

2. Transformation Service Design

transformation_service:
  name: ImageTransformService
  description: On-the-fly image transformation with caching

  endpoints:
    # URL-based transformation
    - pattern: "/media/{path}?w={width}&h={height}&format={format}&q={quality}"
      example: "/media/hero.jpg?w=800&h=600&format=webp&q=80"

    # Preset-based transformation
    - pattern: "/media/{path}?preset={preset}"
      example: "/media/hero.jpg?preset=thumbnail"

  presets:
    thumbnail:
      width: 150
      height: 150
      fit: crop
      format: webp
      quality: 75

    card:
      width: 400
      height: 300
      fit: crop
      format: webp
      quality: 80

    hero:
      width: 1920
      height: 800
      fit: cover
      format: webp
      quality: 85

    og-image:
      width: 1200
      height: 630
      fit: cover
      format: jpeg
      quality: 90

    blur-placeholder:
      width: 20
      height: 20
      format: jpeg
      quality: 30
      blur: 5

  operations:
    resize:
      modes: [max, min, crop, pad, stretch]
      max_width: 4096
      max_height: 4096

    format:
      supported: [jpeg, png, webp, avif, gif]
      auto_select: true  # Based on Accept header

    effects:
      - blur (0-100)
      - grayscale
      - rotate (0, 90, 180, 270)
      - flip (horizontal, vertical)

    focal_point:
      enabled: true
      default: center
      custom: true  # Per-image focal point

  caching:
    strategy: cache-on-generate
    storage: same-as-original  # Or separate cache bucket
    ttl: 2592000  # 30 days
    invalidation: on-source-update

3. Video Processing Pipeline

video_pipeline:
  name: VideoProcessingPipeline
  description: Async video transcoding with HLS output

  workflow:
    trigger: upload_complete
    queue: azure-service-bus  # Or AWS SQS

    stages:
      - name: validate
        actions:
          - check_duration (max: 3600s)
          - check_resolution (max: 4K)
          - scan_content (optional)

      - name: extract_metadata
        actions:
          - get_duration
          - get_resolution
          - get_codec
          - generate_thumbnail (at: 10%)

      - name: transcode
        provider: azure-media-services  # Or FFmpeg
        outputs:
          - format: hls
            renditions:
              - name: 1080p
                resolution: 1920x1080
                bitrate: 5000k
              - name: 720p
                resolution: 1280x720
                bitrate: 2500k
              - name: 480p
                resolution: 854x480
                bitrate: 1000k
              - name: 360p
                resolution: 640x360
                bitrate: 500k

      - name: store
        destination: blob-storage
        path: "/video/{id}/hls/"

      - name: notify
        webhook: /api/webhooks/video-ready
        include: [id, duration, renditions, thumbnail_url]

4. CDN Delivery Architecture

cdn_architecture:
  provider: azure-front-door

  origins:
    - name: blob-storage
      host: storage.blob.core.windows.net
      type: primary

    - name: transform-service
      host: transform.example.com
      type: dynamic

  routing_rules:
    - name: original-media
      pattern: /media/original/*
      origin: blob-storage
      cache:
        duration: 31536000  # 1 year
        query_string: ignore

    - name: transformed-media
      pattern: /media/*
      origin: transform-service
      cache:
        duration: 2592000  # 30 days
        query_string: use  # Transform params

    - name: video-streaming
      pattern: /video/*/hls/*
      origin: blob-storage
      cache:
        duration: 3600  # 1 hour for manifests
        query_string: ignore

  origin_shield:
    enabled: true
    region: eastus

  security:
    signed_urls:
      enabled: true
      key_id: media-signing-key
      algorithm: HMAC-SHA256
      expiry_range: 1h-24h

    waf:
      enabled: true
      ruleset: OWASP-3.2

5. Processing Service Implementation

// Core transformation service
public class ImageTransformationService
{
    private readonly IMediaStorageProvider _storage;
    private readonly IDistributedCache _cache;

    public async Task<Stream> TransformAsync(
        string path,
        TransformationOptions options)
    {
        // Check cache first
        var cacheKey = BuildCacheKey(path, options);
        var cached = await _cache.GetAsync(cacheKey);
        if (cached != null)
            return new MemoryStream(cached);

        // Get original
        var original = await _storage.DownloadAsync(path);

        // Apply transformations
        using var image = await Image.LoadAsync(original);

        // Resize with focal point
        if (options.Width.HasValue || options.Height.HasValue)
        {
            var resizeOptions = new ResizeOptions
            {
                Size = new Size(
                    options.Width ?? 0,
                    options.Height ?? 0),
                Mode = MapResizeMode(options.Fit),
                Position = CalculateFocalPosition(options.FocalPoint)
            };
            image.Mutate(x => x.Resize(resizeOptions));
        }

        // Apply effects
        ApplyEffects(image, options);

        // Encode to target format
        var output = new MemoryStream();
        await EncodeAsync(image, output, options);

        // Cache result
        output.Position = 0;
        await _cache.SetAsync(cacheKey, output.ToArray(),
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(30)
            });

        output.Position = 0;
        return output;
    }
}

Pipeline Design Checklist

Upload Pipeline

• File validation (size, type, malware)
• Metadata extraction (EXIF, dimensions)
• Auto-orientation for images
• Thumbnail generation
• Path strategy (date-based, hash-based)
• Error handling and retry logic

Transformation Service

• URL parameter parsing
• Preset system defined
• Resize modes implemented
• Format conversion (WebP, AVIF)
• Focal point cropping
• Response caching
• Error fallbacks

Video Pipeline

• Async processing queue
• Multiple rendition outputs
• HLS/DASH packaging
• Thumbnail extraction
• Progress webhooks
• Error notifications

CDN Integration

• Origin configuration
• Routing rules defined
• Cache policies set
• Origin shield enabled
• Signed URLs configured
• Invalidation strategy

Skills to Invoke

For detailed patterns:

• media-asset-management - Storage and upload patterns
• image-optimization - ImageSharp processing, responsive images
• cdn-media-delivery - CDN configuration, signed URLs

Performance Targets

Metric	Target	Measurement
Upload latency	< 2s for 5MB	P95 response time
Transform latency	< 500ms	P95 cold request
Cache hit ratio	> 95%	CDN analytics
Origin shield reduction	> 90%	Origin requests
Image size reduction	> 60%	WebP vs original

Best Practices

Pipeline Design

DO:
- Use async processing for large files
- Implement progressive loading (blur → full)
- Cache at multiple levels (CDN, application, storage)
- Design for failure (retries, dead letter queues)
- Monitor pipeline health

DON'T:
- Process synchronously in upload request
- Store transformed images permanently (cache instead)
- Transform without rate limiting
- Ignore security (malware, path traversal)
- Skip validation stages