AI-Powered Video Processing

async function analyzeVideo(videoUrl) {
  try {
    // Submit video with AI analysis enabled
    const response = await fetch('https://api.videocascade.com/v1/videos', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer vca_your_api_key',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        fileUrl: videoUrl,
        enableAiAnalysis: true,
      }),
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    console.log('Analysis started:', data.videoId);

    // Wait for analysis to complete
    const result = await waitForAnalysisCompletion(data.videoId);

    return {
      videoId: data.videoId,
      tags: result.analysis.data.tags,
      summary: result.analysis.data.summary,
      location: result.analysis.data.estimatedLocation
    };

} catch (error) {
console.error('Error analyzing video:', error);
throw error;
}
}

async function waitForAnalysisCompletion(videoId, maxAttempts = 60) {
const pollInterval = 5000; // 5 seconds

for (let attempt = 0; attempt < maxAttempts; attempt++) {
const response = await fetch(
`https://api.videocascade.com/v1/videos/${videoId}`,
{
headers: {
'Authorization': 'Bearer vca_your_api_key',
},
}
);

    const video = await response.json();

    console.log(`Analysis status: ${video.analysis?.status || 'not_started'}`);

    if (video.analysis?.status === 'completed') {
      return video;
    }

    if (video.analysis?.status === 'failed') {
      throw new Error(video.analysis.error || 'Analysis failed');
    }

    await new Promise(resolve => setTimeout(resolve, pollInterval));

}

throw new Error('Analysis timeout');
}

// Usage
const analysis = await analyzeVideo('https://example.com/video.mp4');
console.log('Tags:', analysis.tags);
console.log('Summary:', analysis.summary);
console.log('Location:', analysis.location);

import time
import requests

def analyze_video(video_url):
    """Analyze video with AI"""
    try:
        # Submit video with AI analysis enabled
        response = requests.post(
            'https://api.videocascade.com/v1/videos',
            headers={
                'Authorization': 'Bearer vca_your_api_key',
                'Content-Type': 'application/json',
            },
            json={
                'fileUrl': video_url,
                'enableAiAnalysis': True,
            }
        )

        response.raise_for_status()
        data = response.json()

        print(f"Analysis started: {data['videoId']}")

        # Wait for analysis to complete
        result = wait_for_analysis_completion(data['videoId'])

        return {
            'videoId': data['videoId'],
            'tags': result['analysis']['data']['tags'],
            'summary': result['analysis']['data']['summary'],
            'location': result['analysis']['data']['estimatedLocation']
        }

    except Exception as error:
        print(f"Error analyzing video: {error}")
        raise

def wait_for_analysis_completion(video_id, max_attempts=60):
    """Poll until analysis completes"""
    poll_interval = 5  # seconds

    for attempt in range(max_attempts):
        response = requests.get(
            f'https://api.videocascade.com/v1/videos/{video_id}',
            headers={'Authorization': 'Bearer vca_your_api_key'}
        )

        response.raise_for_status()
        video = response.json()

        status = video.get('analysis', {}).get('status', 'not_started')
        print(f"Analysis status: {status}")

        if status == 'completed':
            return video

        if status == 'failed':
            error = video.get('analysis', {}).get('error', 'Analysis failed')
            raise Exception(error)

        time.sleep(poll_interval)

    raise TimeoutError('Analysis timeout')

# Usage
analysis = analyze_video('https://example.com/video.mp4')
print(f"Tags: {analysis['tags']}")
print(f"Summary: {analysis['summary']}")
print(f"Location: {analysis['location']}")

interface AnalysisData {
  tags: string[];
  summary: string;
  estimatedLocation: string;
}

interface VideoAnalysis {
status: 'not_requested' | 'pending' | 'processing' | 'completed' | 'failed';
progress?: number;
error?: string;
data?: AnalysisData;
}

interface VideoWithAnalysis {
videoId: string;
status: string;
analysis?: VideoAnalysis;
}

interface AnalysisResult {
videoId: string;
tags: string[];
summary: string;
location: string;
}

async function analyzeVideo(videoUrl: string): Promise<AnalysisResult> {
try {
// Submit video with AI analysis enabled
const response = await fetch('https://api.videocascade.com/v1/videos', {
method: 'POST',
headers: {
'Authorization': 'Bearer vca_your_api_key',
'Content-Type': 'application/json',
},
body: JSON.stringify({
fileUrl: videoUrl,
enableAiAnalysis: true,
}),
});

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();
    console.log('Analysis started:', data.videoId);

    // Wait for analysis to complete
    const result = await waitForAnalysisCompletion(data.videoId);

    if (!result.analysis?.data) {
      throw new Error('Analysis data not available');
    }

    return {
      videoId: data.videoId,
      tags: result.analysis.data.tags,
      summary: result.analysis.data.summary,
      location: result.analysis.data.estimatedLocation
    };

} catch (error) {
console.error('Error analyzing video:', error);
throw error;
}
}

async function waitForAnalysisCompletion(
videoId: string,
maxAttempts: number = 60
): Promise<VideoWithAnalysis> {
const pollInterval = 5000; // 5 seconds

for (let attempt = 0; attempt < maxAttempts; attempt++) {
const response = await fetch(
`https://api.videocascade.com/v1/videos/${videoId}`,
{
headers: {
'Authorization': 'Bearer vca_your_api_key',
},
}
);

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const video: VideoWithAnalysis = await response.json();

    console.log(`Analysis status: ${video.analysis?.status || 'not_started'}`);

    if (video.analysis?.status === 'completed') {
      return video;
    }

    if (video.analysis?.status === 'failed') {
      throw new Error(video.analysis.error || 'Analysis failed');
    }

    await new Promise(resolve => setTimeout(resolve, pollInterval));

}

throw new Error('Analysis timeout');
}

// Usage
const analysis = await analyzeVideo('https://example.com/video.mp4');
console.log('Tags:', analysis.tags);
console.log('Summary:', analysis.summary);
console.log('Location:', analysis.location);

async function comprehensiveAnalysis(videoUrl) {
  // Submit with both AI features enabled
  const response = await fetch('https://api.videocascade.com/v1/videos', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer vca_your_api_key',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      fileUrl: videoUrl,
      enableAiAnalysis: true,      // Visual analysis
      enableTranscription: true,   // Speech-to-text
    }),
  });

  const data = await response.json();
  console.log('Processing started:', data.videoId);

  // Wait for all processing to complete
  const result = await waitForCompletion(data.videoId);

  return {
    videoId: data.videoId,
    // Visual analysis
    tags: result.analysis.data.tags,
    summary: result.analysis.data.summary,
    location: result.analysis.data.estimatedLocation,
    // Transcription
    transcript: result.transcription.data.text,
    language: result.transcription.data.language,
    // Combined insights
    insights: generateInsights(result)
  };
}

function generateInsights(video) {
  const insights = [];

  // Check if transcript mentions locations
  const locationMentions = extractLocations(video.transcription.data.text);
  if (locationMentions.length > 0) {
    insights.push({
      type: 'location_mentioned',
      data: locationMentions,
      confidence: 'high'
    });
  }

  // Check if visual location matches transcript
  if (video.analysis.data.estimatedLocation !== 'unknown') {
    insights.push({
      type: 'visual_location',
      data: video.analysis.data.estimatedLocation,
      confidence: 'medium'
    });
  }

  // Extract topics from transcript
  const topics = extractTopics(video.transcription.data.text);
  insights.push({
    type: 'topics',
    data: topics,
    source: 'transcript'
  });

  // Combine with visual tags
  const allTopics = [...new Set([...topics, ...video.analysis.data.tags])];
  insights.push({
    type: 'combined_topics',
    data: allTopics,
    sources: ['visual', 'audio']
  });

  return insights;
}

function extractLocations(text) {
  // Simple location extraction (improve with NLP library)
  const locationPatterns = /\b(in|at|from)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g;
  const matches = [...text.matchAll(locationPatterns)];
  return matches.map(m => m[2]);
}

function extractTopics(text) {
  // Simple topic extraction (improve with NLP library)
  const words = text.toLowerCase().split(/\W+/);
  const stopWords = new Set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at']);
  const wordFreq = {};

  words.forEach(word => {
    if (word.length > 4 && !stopWords.has(word)) {
      wordFreq[word] = (wordFreq[word] || 0) + 1;
    }
  });

  return Object.entries(wordFreq)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 10)
    .map(([word]) => word);
}

// Usage
const analysis = await comprehensiveAnalysis('https://example.com/video.mp4');
console.log('Visual tags:', analysis.tags);
console.log('Transcript:', analysis.transcript.substring(0, 200) + '...');
console.log('Insights:', analysis.insights);

import re
from collections import Counter

def comprehensive_analysis(video_url):
"""Perform comprehensive AI analysis""" # Submit with both AI features enabled
response = requests.post(
'https://api.videocascade.com/v1/videos',
headers={
'Authorization': 'Bearer vca_your_api_key',
'Content-Type': 'application/json',
},
json={
'fileUrl': video_url,
'enableAiAnalysis': True, # Visual analysis
'enableTranscription': True, # Speech-to-text
}
)

    response.raise_for_status()
    data = response.json()

    print(f"Processing started: {data['videoId']}")

    # Wait for all processing to complete
    result = wait_for_completion(data['videoId'])

    return {
        'videoId': data['videoId'],
        # Visual analysis
        'tags': result['analysis']['data']['tags'],
        'summary': result['analysis']['data']['summary'],
        'location': result['analysis']['data']['estimatedLocation'],
        # Transcription
        'transcript': result['transcription']['data']['text'],
        'language': result['transcription']['data']['language'],
        # Combined insights
        'insights': generate_insights(result)
    }

def generate_insights(video):
"""Generate insights from combined AI data"""
insights = []

    transcript = video['transcription']['data']['text']

    # Check if transcript mentions locations
    location_mentions = extract_locations(transcript)
    if location_mentions:
        insights.append({
            'type': 'location_mentioned',
            'data': location_mentions,
            'confidence': 'high'
        })

    # Check if visual location matches transcript
    visual_location = video['analysis']['data']['estimatedLocation']
    if visual_location != 'unknown':
        insights.append({
            'type': 'visual_location',
            'data': visual_location,
            'confidence': 'medium'
        })

    # Extract topics from transcript
    topics = extract_topics(transcript)
    insights.append({
        'type': 'topics',
        'data': topics,
        'source': 'transcript'
    })

    # Combine with visual tags
    all_topics = list(set(topics + video['analysis']['data']['tags']))
    insights.append({
        'type': 'combined_topics',
        'data': all_topics,
        'sources': ['visual', 'audio']
    })

    return insights

def extract_locations(text):
"""Extract location mentions from text"""
pattern = r'\b(in|at|from)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)\*)\b'
matches = re.findall(pattern, text)
return [match[1] for match in matches]

def extract_topics(text):
"""Extract main topics from text"""
words = re.findall(r'\w+', text.lower())
stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at'}

    filtered_words = [w for w in words if len(w) > 4 and w not in stop_words]
    word_freq = Counter(filtered_words)

    return [word for word, _ in word_freq.most_common(10)]

# Usage

analysis = comprehensive_analysis('https://example.com/video.mp4')
print(f"Visual tags: {analysis['tags']}")
print(f"Transcript: {analysis['transcript'][:200]}...")
print(f"Insights: {analysis['insights']}")

interface Insight {
  type: string;
  data: any;
  confidence?: string;
  source?: string;
  sources?: string[];
}

interface ComprehensiveAnalysisResult {
  videoId: string;
  tags: string[];
  summary: string;
  location: string;
  transcript: string;
  language: string;
  insights: Insight[];
}

async function comprehensiveAnalysis(
  videoUrl: string
): Promise<ComprehensiveAnalysisResult> {
  // Submit with both AI features enabled
  const response = await fetch('https://api.videocascade.com/v1/videos', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer vca_your_api_key',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      fileUrl: videoUrl,
      enableAiAnalysis: true,
      enableTranscription: true,
    }),
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();
  console.log('Processing started:', data.videoId);

  // Wait for all processing to complete
  const result = await waitForCompletion(data.videoId);

  return {
    videoId: data.videoId,
    tags: result.analysis.data.tags,
    summary: result.analysis.data.summary,
    location: result.analysis.data.estimatedLocation,
    transcript: result.transcription.data.text,
    language: result.transcription.data.language,
    insights: generateInsights(result)
  };
}

function generateInsights(video: any): Insight[] {
  const insights: Insight[] = [];

  // Check if transcript mentions locations
  const locationMentions = extractLocations(video.transcription.data.text);
  if (locationMentions.length > 0) {
    insights.push({
      type: 'location_mentioned',
      data: locationMentions,
      confidence: 'high'
    });
  }

  // Check if visual location matches transcript
  if (video.analysis.data.estimatedLocation !== 'unknown') {
    insights.push({
      type: 'visual_location',
      data: video.analysis.data.estimatedLocation,
      confidence: 'medium'
    });
  }

  // Extract topics from transcript
  const topics = extractTopics(video.transcription.data.text);
  insights.push({
    type: 'topics',
    data: topics,
    source: 'transcript'
  });

  // Combine with visual tags
  const allTopics = [...new Set([...topics, ...video.analysis.data.tags])];
  insights.push({
    type: 'combined_topics',
    data: allTopics,
    sources: ['visual', 'audio']
  });

  return insights;
}

function extractLocations(text: string): string[] {
  const locationPattern = /\b(in|at|from)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g;
  const matches = [...text.matchAll(locationPattern)];
  return matches.map(m => m[2]);
}

function extractTopics(text: string): string[] {
  const words = text.toLowerCase().split(/\W+/);
  const stopWords = new Set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at']);
  const wordFreq: Record<string, number> = {};

  words.forEach(word => {
    if (word.length > 4 && !stopWords.has(word)) {
      wordFreq[word] = (wordFreq[word] || 0) + 1;
    }
  });

  return Object.entries(wordFreq)
    .sort((a, b) => b[1] - a[1])
    .slice(0, 10)
    .map(([word]) => word);
}

// Usage
const analysis = await comprehensiveAnalysis('https://example.com/video.mp4');
console.log('Visual tags:', analysis.tags);
console.log('Transcript:', analysis.transcript.substring(0, 200) + '...');
console.log('Insights:', analysis.insights);

class VideoModerator {
  constructor(apiKey, moderationRules = {}) {
    this.apiKey = apiKey;
    this.rules = {
      flaggedTags: moderationRules.flaggedTags || [
        'violence', 'explicit', 'nsfw', 'inappropriate',
        'weapon', 'drug', 'alcohol', 'tobacco'
      ],
      flaggedKeywords: moderationRules.flaggedKeywords || [
        'explicit', 'violence', 'hate', 'abuse', 'illegal'
      ],
      requireManualReview: moderationRules.requireManualReview || false
    };
  }

async moderateVideo(videoUrl, userId) {
try {
// Analyze video
const response = await fetch('https://api.videocascade.com/v1/videos', {
method: 'POST',
headers: {
'Authorization': `Bearer ${this.apiKey}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
fileUrl: videoUrl,
enableAiAnalysis: true,
enableTranscription: true,
webhookUrl: `https://yourapp.com/webhooks/moderation/${userId}`
}),
});

      const data = await response.json();

      // Wait for analysis
      const video = await waitForCompletion(data.videoId);

      // Perform moderation checks
      const moderationResult = this.checkContent(video);

      // Save to database
      await this.saveModerationResult(data.videoId, userId, moderationResult);

      return moderationResult;

    } catch (error) {
      console.error('Moderation error:', error);
      throw error;
    }

}

checkContent(video) {
const flags = [];
let riskScore = 0;

    // Check visual tags
    const visualFlags = video.analysis.data.tags.filter(tag =>
      this.rules.flaggedTags.some(flagged =>
        tag.toLowerCase().includes(flagged.toLowerCase())
      )
    );

    if (visualFlags.length > 0) {
      flags.push({
        type: 'visual',
        severity: 'high',
        tags: visualFlags,
        message: `Flagged visual content: ${visualFlags.join(', ')}`
      });
      riskScore += visualFlags.length * 30;
    }

    // Check transcript for keywords
    if (video.transcription?.data?.text) {
      const transcript = video.transcription.data.text.toLowerCase();
      const keywordFlags = this.rules.flaggedKeywords.filter(keyword =>
        transcript.includes(keyword.toLowerCase())
      );

      if (keywordFlags.length > 0) {
        flags.push({
          type: 'audio',
          severity: 'medium',
          keywords: keywordFlags,
          message: `Flagged keywords in transcript: ${keywordFlags.join(', ')}`
        });
        riskScore += keywordFlags.length * 20;
      }
    }

    // Determine action
    let action = 'approved';
    if (riskScore > 80 || flags.some(f => f.severity === 'high')) {
      action = 'rejected';
    } else if (riskScore > 40 || this.rules.requireManualReview) {
      action = 'review';
    }

    return {
      videoId: video.videoId,
      action,
      riskScore,
      flags,
      summary: video.analysis.data.summary,
      tags: video.analysis.data.tags,
      timestamp: new Date().toISOString()
    };

}

async saveModerationResult(videoId, userId, result) {
// Save to database (example with PostgreSQL)
await db.query(
`INSERT INTO moderation_results
       (video_id, user_id, action, risk_score, flags, created_at)
       VALUES ($1, $2, $3, $4, $5, NOW())`,
[videoId, userId, result.action, result.riskScore, JSON.stringify(result.flags)]
);

    // Log for review if flagged
    if (result.action !== 'approved') {
      await db.query(
        `INSERT INTO review_queue (video_id, priority, created_at)
         VALUES ($1, $2, NOW())`,
        [videoId, result.riskScore > 80 ? 'high' : 'normal']
      );
    }

}
}

// Usage
const moderator = new VideoModerator('vca_your_api_key', {
flaggedTags: ['violence', 'explicit', 'weapon'],
flaggedKeywords: ['inappropriate', 'offensive'],
requireManualReview: true
});

const result = await moderator.moderateVideo(
'https://example.com/user-upload.mp4',
'user_12345'
);

console.log('Moderation result:', result.action);
console.log('Risk score:', result.riskScore);
console.log('Flags:', result.flags);

// Handle result
if (result.action === 'approved') {
await publishVideo(result.videoId);
} else if (result.action === 'review') {
await notifyModerators(result);
} else {
await notifyUser(result.videoId, 'rejected');
}

from datetime import datetime
import json

class VideoModerator:
    def __init__(self, api_key, moderation_rules=None):
        self.api_key = api_key
        self.rules = moderation_rules or {}

        self.rules.setdefault('flaggedTags', [
            'violence', 'explicit', 'nsfw', 'inappropriate',
            'weapon', 'drug', 'alcohol', 'tobacco'
        ])
        self.rules.setdefault('flaggedKeywords', [
            'explicit', 'violence', 'hate', 'abuse', 'illegal'
        ])
        self.rules.setdefault('requireManualReview', False)

    def moderate_video(self, video_url, user_id):
        """Moderate video content"""
        try:
            # Analyze video
            response = requests.post(
                'https://api.videocascade.com/v1/videos',
                headers={
                    'Authorization': f'Bearer {self.api_key}',
                    'Content-Type': 'application/json',
                },
                json={
                    'fileUrl': video_url,
                    'enableAiAnalysis': True,
                    'enableTranscription': True,
                    'webhookUrl': f"https://yourapp.com/webhooks/moderation/{user_id}"
                }
            )

            response.raise_for_status()
            data = response.json()

            # Wait for analysis
            video = wait_for_completion(data['videoId'])

            # Perform moderation checks
            moderation_result = self.check_content(video)

            # Save to database
            self.save_moderation_result(data['videoId'], user_id, moderation_result)

            return moderation_result

        except Exception as error:
            print(f"Moderation error: {error}")
            raise

    def check_content(self, video):
        """Check video content against moderation rules"""
        flags = []
        risk_score = 0

        # Check visual tags
        visual_flags = [
            tag for tag in video['analysis']['data']['tags']
            if any(flagged.lower() in tag.lower()
                   for flagged in self.rules['flaggedTags'])
        ]

        if visual_flags:
            flags.append({
                'type': 'visual',
                'severity': 'high',
                'tags': visual_flags,
                'message': f"Flagged visual content: {', '.join(visual_flags)}"
            })
            risk_score += len(visual_flags) * 30

        # Check transcript for keywords
        transcript_data = video.get('transcription', {}).get('data')
        if transcript_data and transcript_data.get('text'):
            transcript = transcript_data['text'].lower()
            keyword_flags = [
                keyword for keyword in self.rules['flaggedKeywords']
                if keyword.lower() in transcript
            ]

            if keyword_flags:
                flags.append({
                    'type': 'audio',
                    'severity': 'medium',
                    'keywords': keyword_flags,
                    'message': f"Flagged keywords: {', '.join(keyword_flags)}"
                })
                risk_score += len(keyword_flags) * 20

        # Determine action
        action = 'approved'
        if risk_score > 80 or any(f['severity'] == 'high' for f in flags):
            action = 'rejected'
        elif risk_score > 40 or self.rules['requireManualReview']:
            action = 'review'

        return {
            'videoId': video['videoId'],
            'action': action,
            'riskScore': risk_score,
            'flags': flags,
            'summary': video['analysis']['data']['summary'],
            'tags': video['analysis']['data']['tags'],
            'timestamp': datetime.utcnow().isoformat()
        }

    def save_moderation_result(self, video_id, user_id, result):
        """Save moderation result to database"""
        # Save to database (example with PostgreSQL)
        db.execute(
            """INSERT INTO moderation_results
               (video_id, user_id, action, risk_score, flags, created_at)
               VALUES (%s, %s, %s, %s, %s, NOW())""",
            (video_id, user_id, result['action'], result['riskScore'],
             json.dumps(result['flags']))
        )

        # Log for review if flagged
        if result['action'] != 'approved':
            priority = 'high' if result['riskScore'] > 80 else 'normal'
            db.execute(
                """INSERT INTO review_queue (video_id, priority, created_at)
                   VALUES (%s, %s, NOW())""",
                (video_id, priority)
            )

# Usage
moderator = VideoModerator('vca_your_api_key', {
    'flaggedTags': ['violence', 'explicit', 'weapon'],
    'flaggedKeywords': ['inappropriate', 'offensive'],
    'requireManualReview': True
})

result = moderator.moderate_video(
    'https://example.com/user-upload.mp4',
    'user_12345'
)

print(f"Moderation result: {result['action']}")
print(f"Risk score: {result['riskScore']}")
print(f"Flags: {result['flags']}")

# Handle result
if result['action'] == 'approved':
    publish_video(result['videoId'])
elif result['action'] == 'review':
    notify_moderators(result)
else:
    notify_user(result['videoId'], 'rejected')