Python для обработки медиа: от базовых операций до сложных проектов

from moviepy.editor import VideoFileClip

# Загрузка видео
clip = VideoFileClip("input.mp4")

# Обрезка первых 10 секунд
clip = clip.subclip(0, 10)

# Изменение размера
clip = clip.resize(width=480)

# Сохранение результата
clip.write_videofile("output.mp4")

import librosa
import matplotlib.pyplot as plt

# Загрузка аудио
y, sr = librosa.load("music.wav")

# Построение спектрограммы
plt.figure(figsize=(14, 5))
librosa.display.specshow(
librosa.amplitude_to_db(librosa.stft(y), ref=np.max),
sr=sr, 
y_axis='log', 
x_axis='time'
)
plt.title('Спектрограмма')
plt.colorbar(format='%+2.0f dB')
plt.tight_layout()

from pydub import AudioSegment

# Загрузка аудио
sound = AudioSegment.from_file("input.wav")

# Увеличение громкости на 6 дБ
louder = sound + 6

# Обрезка первых 30 секунд
first_30_seconds = sound[:30*1000]

# Экспорт в MP3
first_30_seconds.export("output.mp3", format="mp3")

from pydub import AudioSegment

# Загружаем WAV-файл
sound = AudioSegment.from_wav("input.wav")

# Конвертируем в MP3 с битрейтом 128 кбит/с
sound.export("output.mp3", format="mp3", bitrate="128k")

# Конвертируем в OGG с качеством 5
sound.export("output.ogg", format="ogg", parameters=["-q:a", "5"])

import librosa
import numpy as np

# Загрузка аудио с частотой дискретизации 22050 Гц
y, sr = librosa.load("music.mp3", sr=22050)

# Вычисление мел-спектрограммы
mel_spec = librosa.feature.melspectrogram(y=y, sr=sr)

# Вычисление MFCCs (мел-кепстральных коэффициентов)
mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)

# Вычисление среднего и стандартного отклонения MFCCs
mfcc_mean = np.mean(mfccs, axis=1)
mfcc_std = np.std(mfccs, axis=1)

print(f"Средние значения MFCC: {mfcc_mean}")
print(f"Стандартные отклонения MFCC: {mfcc_std}")

from pydub import AudioSegment
from pydub.effects import normalize, low_pass_filter, high_pass_filter

# Загрузка аудио
sound = AudioSegment.from_mp3("input.mp3")

# Нормализация громкости
normalized = normalize(sound)

# Применение фильтров верхних и нижних частот
# Отсекаем частоты ниже 300 Гц
high_passed = high_pass_filter(normalized, 300)

# Отсекаем частоты выше 3000 Гц
filtered = low_pass_filter(high_passed, 3000)

# Сохранение результата
filtered.export("filtered_output.mp3", format="mp3")

import librosa

# Загрузка аудио
y, sr = librosa.load("music.mp3")

# Определение ударов и темпа
tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
beat_times = librosa.frames_to_time(beat_frames, sr=sr)

print(f"Темп: {tempo:.2f} ударов в минуту")
print(f"Позиции ударов (первые 5): {beat_times[:5]}")

from moviepy.editor import VideoFileClip, concatenate_videoclips

# Загрузка видео
clip1 = VideoFileClip("video1.mp4")
clip2 = VideoFileClip("video2.mp4")

# Обрезка первого клипа (10-20 секунды)
clip1 = clip1.subclip(10, 20)

# Изменение скорости второго клипа (замедление в 2 раза)
clip2 = clip2.fx(vfx.speedx, 0.5)

# Изменение разрешения
clip2 = clip2.resize(width=720)

# Объединение клипов
final_clip = concatenate_videoclips([clip1, clip2])

# Сохранение результата
final_clip.write_videofile("output.mp4")

from moviepy.editor import VideoFileClip, TextClip, CompositeVideoClip
from moviepy.video.fx import fadein, fadeout

# Загрузка видео
video = VideoFileClip("input.mp4").subclip(0, 20)

# Создание текста с плавным появлением
txt = TextClip("Пример текста", fontsize=70, color='white')
txt = txt.set_position('center').set_duration(10).fx(fadein, 2)

# Создание композитного клипа (видео + текст)
final = CompositeVideoClip([video, txt])

# Добавление затухания в конце
final = final.fx(fadeout, 2)

# Сохранение результата
final.write_videofile("output_with_text.mp4")

import cv2
import numpy as np

# Открытие видеофайла
cap = cv2.VideoCapture('video.mp4')

# Инициализация детектора движения
fgbg = cv2.createBackgroundSubtractorMOG2()

# Подготовка выходного видео
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output_motion.avi', fourcc, 20.0, (640, 480))

while True:
ret, frame = cap.read()
if not ret:
break

# Применение детектора движения
fgmask = fgbg.apply(frame)

# Нахождение контуров движущихся объектов
contours, _ = cv2.findContours(fgmask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Отрисовка рамок вокруг движущихся объектов
for contour in contours:
if cv2.contourArea(contour) > 500: # Фильтрация мелких контуров
(x, y, w, h) = cv2.boundingRect(contour)
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

# Запись обработанного кадра
out.write(frame)

# Освобождение ресурсов
cap.release()
out.release()
cv2.destroyAllWindows()

import subprocess

# Определение параметров кодирования
input_file = "input.mp4"
output_file = "output.webm"
crf = 23 # Качество (lower = better)
preset = "medium" # Баланс между скоростью и сжатием

# Формирование команды FFmpeg
command = [
"ffmpeg",
"-i", input_file,
"-c:v", "libvpx-vp9", # Кодек VP9
"-crf", str(crf),
"-b:v", "0", # Используем CRF вместо битрейта
"-c:a", "libopus", # Аудиокодек Opus
"-b:a", "128k", # Битрейт аудио
output_file
]

# Выполнение команды
subprocess.run(command)

import os
from moviepy.editor import VideoFileClip, concatenate_videoclips, TextClip, CompositeVideoClip
import speech_recognition as sr
from pydub import AudioSegment
from pydub.silence import detect_nonsilent

def process_video(input_path, output_path, intro_path, outro_path, 
generate_subtitles=True, optimize_web=True):
# Загрузка основного видео
main_clip = VideoFileClip(input_path)

# Извлечение аудио для анализа
audio = main_clip.audio
audio.write_audiofile("temp_audio.wav")

# Обнаружение и обрезка тишины
sound = AudioSegment.from_file("temp_audio.wav")
non_silent_ranges = detect_nonsilent(sound, min_silence_len=1000, silence_thresh=-40)

if non_silent_ranges:
start_time = non_silent_ranges[0][0] / 1000.0 # в секундах
end_time = non_silent_ranges[-1][1] / 1000.0 # в секундах
main_clip = main_clip.subclip(start_time, end_time)

# Добавление интро и аутро
intro_clip = VideoFileClip(intro_path)
outro_clip = VideoFileClip(outro_path)

final_clip = concatenate_videoclips([intro_clip, main_clip, outro_clip])

# Генерация субтитров (упрощенная версия)
if generate_subtitles:
r = sr.Recognizer()
with sr.AudioFile("temp_audio.wav") as source:
audio_data = r.record(source)
text = r.recognize_google(audio_data, language="ru-RU")

# Создание субтитров (базовая реализация – весь текст сразу)
subtitle = TextClip(text[:50] + "...", fontsize=24, color='white', 
bg_color='black', size=main_clip.size)
subtitle = subtitle.set_position(('center', 'bottom')).set_duration(main_clip.duration)

final_clip = CompositeVideoClip([final_clip, subtitle])

# Оптимизация для веба
if optimize_web:
final_clip = final_clip.resize(width=1280)

# Экспорт результата
final_clip.write_videofile(output_path, codec='libx264', 
audio_codec='aac', bitrate="5000k")

# Очистка временных файлов
os.remove("temp_audio.wav")

return output_path

import librosa
import numpy as np
import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import TfidfVectorizer
import speech_recognition as sr
import json

def analyze_podcast(audio_path):
# Загрузка аудио
y, sr_rate = librosa.load(audio_path, sr=22050)

# Извлечение основных характеристик
tempo, _ = librosa.beat.beat_track(y=y, sr=sr_rate)
energy = np.mean(librosa.feature.rms(y=y))
zero_crossings = np.mean(librosa.feature.zero_crossing_rate(y))

# Разделение на сегменты для анализа динамики (каждые 30 секунд)
segment_length = 30 * sr_rate
segments = [y[i:i+segment_length] for i in range(0, len(y), segment_length)]

segment_energies = [np.mean(librosa.feature.rms(y=segment)) for segment in segments if len(segment) == segment_length]

# Распознавание речи для текстового анализа
recognizer = sr.Recognizer()
text_segments = []

# В реальном проекте здесь был бы код для разбиения аудио на управляемые части
# и их распознавания, но для примера мы используем упрощенный подход
with sr.AudioFile(audio_path) as source:
audio_data = recognizer.record(source)
try:
full_text = recognizer.recognize_google(audio_data, language="ru-RU")
text_segments = [full_text[i:i+500] for i in range(0, len(full_text), 500)]
except:
full_text = ""
text_segments = []

# Анализ ключевых слов
if text_segments:
vectorizer = TfidfVectorizer(max_features=20, stop_words='english')
tfidf_matrix = vectorizer.fit_transform(text_segments)
feature_names = vectorizer.get_feature_names_out()

# Получение топ-10 ключевых слов для всего подкаста
tfidf_sums = np.sum(tfidf_matrix.toarray(), axis=0)
top_indices = tfidf_sums.argsort()[-10:][::-1]
top_keywords = [feature_names[i] for i in top_indices]
else:
top_keywords = []

# Визуализация динамики энергии
plt.figure(figsize=(12, 6))
plt.plot(segment_energies)
plt.title('Динамика энергии по сегментам подкаста')
plt.xlabel('Сегмент (30 секунд)')
plt.ylabel('Средняя энергия')
plt.savefig('podcast_energy_dynamics.png')

# Формирование результата анализа
analysis_result = {
"tempo": float(tempo),
"average_energy": float(energy),
"zero_crossing_rate": float(zero_crossings),
"top_keywords": top_keywords,
"energy_dynamics": segment_energies,
"suggested_tags": top_keywords[:5]
}

with open('podcast_analysis.json', 'w') as f:
json.dump(analysis_result, f, indent=4)

return analysis_result

from moviepy.editor import ImageClip, TextClip, CompositeVideoClip, concatenate_videoclips
from moviepy.video.fx import fadein, fadeout
import requests
from PIL import Image
from io import BytesIO
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
import random

# Загрузка необходимых NLTK компонентов
nltk.download('punkt')
nltk.download('stopwords')

def generate_preview_from_article(article_text, title, duration=15):
# Извлечение ключевых слов
stop_words = set(stopwords.words('russian'))
words = word_tokenize(article_text.lower())
filtered_words = [word for word in words if word.isalnum() and word not in stop_words]

# Создание частотного распределения слов
freq_dist = nltk.FreqDist(filtered_words)
keywords = [word for word, _ in freq_dist.most_common(5)]

# Поиск и загрузка стоковых изображений (упрощено)
# В реальном проекте здесь был бы API для стоковых фото
image_urls = [
f"https://source.unsplash.com/featured/?{keyword}" for keyword in keywords
]

# Загрузка изображений
images = []
for url in image_urls:
response = requests.get(url)
img = Image.open(BytesIO(response.content))
img.save(f"temp_img_{len(images)}.jpg")
images.append(f"temp_img_{len(images)}.jpg")

# Создание видеоклипов из изображений
clips = []
for img_path in images:
# Создаем клип из изображения
img_clip = ImageClip(img_path).set_duration(duration / len(images))

# Добавляем эффекты перехода
img_clip = img_clip.fx(fadein, 0.5).fx(fadeout, 0.5)

# Масштабируем до нужного размера
img_clip = img_clip.resize(width=1280)

clips.append(img_clip)

# Добавление заголовка
title_clip = TextClip(title, fontsize=70, color='white', bg_color='black',
size=(1280, 720), method='caption').set_duration(duration)
title_clip = title_clip.fx(fadein, 1).fx(fadeout, 1)

# Комбинируем все в финальное видео
image_sequence = concatenate_videoclips(clips, method="compose")
final_clip = CompositeVideoClip([image_sequence, title_clip.set_position(('center', 'center'))])

# Добавление фоновой музыки (упрощено)
# В реальном проекте здесь был бы код для подбора подходящей музыки
# audio_clip = AudioFileClip("background_music.mp3").set_duration(duration)
# final_clip = final_clip.set_audio(audio_clip)

# Экспорт финального превью
final_clip.write_videofile("article_preview.mp4", fps=24)

return "article_preview.mp4"