์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐ŸŽฌ FFmpeg๋กœ ๋งŒ๋“œ๋Š” ๋™์˜์ƒ ์ž๋™ ํŽธ์ง‘ ๋ฐ ์ธ์ฝ”๋”ฉ ์™„์ „์ •๋ณต ๊ฐ€์ด๋“œ

๐ŸŽฌ FFmpeg๋กœ ๋งŒ๋“œ๋Š” ๋™์˜์ƒ ์ž๋™ ํŽธ์ง‘ ๋ฐ ์ธ์ฝ”๋”ฉ ์™„์ „์ •๋ณต ๊ฐ€์ด๋“œ

์ดˆ๋ณด์ž๋„ ๋”ฐ๋ผํ•  ์ˆ˜ ์žˆ๋Š” ์‹ค์ „ ์†Œ์Šค์ฝ”๋“œ์™€ ํ™œ์šฉ ๋…ธํ•˜์šฐ ๋Œ€๊ณต๊ฐœ ใ…‹ใ…‹ใ…‹

์š”์ฆ˜ ์œ ํŠœ๋ธŒ๋‚˜ ํ‹ฑํ†ก ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์˜์ƒ ์ฝ˜ํ…์ธ  ์ œ์ž‘์ด ๋Œ€์„ธ์ž–์•„์š”? ๊ทผ๋ฐ ๋งค๋ฒˆ ์ˆ˜๋™์œผ๋กœ ์˜์ƒ ํŽธ์ง‘ํ•˜๊ณ  ์ธ์ฝ”๋”ฉํ•˜๋Š” ๊ฑฐ ์ง„์งœ ๊ฐœ๊ท€์ฐฎ์ฃ  ใ…‹ใ…‹ใ…‹ ํŠนํžˆ ๋Œ€๋Ÿ‰์˜ ์˜์ƒ์„ ์ฒ˜๋ฆฌํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ์—” ๋”๋”์šฑ์š”! ๐Ÿ˜ซ

๊ทธ๋ž˜์„œ ์˜ค๋Š˜์€ FFmpeg์ด๋ผ๋Š” ๊ฐ•๋ ฅํ•œ ์˜คํ”ˆ์†Œ์Šค ๋„๊ตฌ๋ฅผ ํ™œ์šฉํ•ด์„œ ๋™์˜์ƒ ํŽธ์ง‘๊ณผ ์ธ์ฝ”๋”ฉ์„ ์ž๋™ํ™”ํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์™„์ „ ํŒŒํ—ค์ณ๋ณผ๊ฒŒ์š”. ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์ง€์‹์ด ์ข€ ์žˆ์œผ๋ฉด ๋” ์ข‹์ง€๋งŒ, ์ดˆ๋ณด์ž๋„ ์ถฉ๋ถ„ํžˆ ๋”ฐ๋ผ์˜ฌ ์ˆ˜ ์žˆ๊ฒŒ ์„ค๋ช…ํ•  ํ…Œ๋‹ˆ๊นŒ ๊ฑฑ์ • ๋…ธ๋…ธ~ ๐Ÿš€

์›๋ณธ ์˜์ƒ video.mp4 1920x1080 500MB FF FFmpeg ์ž๋™ ์ฒ˜๋ฆฌ ํŽธ์ง‘ + ์ธ์ฝ”๋”ฉ ์ตœ์ ํ™” ์ตœ์ข… ๊ฒฐ๊ณผ๋ฌผ output.mp4 1280x720 50MB (90% ๊ฐ์†Œ) ์ž๋ฅด๊ธฐ / ํŠธ๋ฆฌ๋ฐ ํ•ด์ƒ๋„ ๋ณ€๊ฒฝ ํฌ๋งท ๋ณ€ํ™˜ ์ž๋ง‰ ์‚ฝ์ž… ์›Œํ„ฐ๋งˆํฌ ์ถ”๊ฐ€ ์˜ค๋””์˜ค ๋ฏน์‹ฑ ํ•„ํ„ฐ ํšจ๊ณผ ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ

๐ŸŽฏ FFmpeg์ด ๋ญ”๋ฐ? ์™œ ์ด๊ฑธ ์จ์•ผ ํ•˜๋Š”๋ฐ?

FFmpeg์€ ์˜คํ”ˆ์†Œ์Šค ๋ฉ€ํ‹ฐ๋ฏธ๋””์–ด ํ”„๋ ˆ์ž„์›Œํฌ์ธ๋ฐ์š”, ์†”์งํžˆ ๋งํ•˜๋ฉด ์˜์ƒ/์˜ค๋””์˜ค ์ฒ˜๋ฆฌ๊ณ„์˜ ์Šค์œ„์Šค ์•„๋ฏธ ๋‚˜์ดํ”„๋ผ๊ณ  ๋ณด๋ฉด ๋ฉ๋‹ˆ๋‹ค ใ…‹ใ…‹ใ…‹ ๊ฑฐ์˜ ๋ชจ๋“  ํฌ๋งท์„ ์ง€์›ํ•˜๊ณ , ๋ช…๋ น์–ด ํ•œ ์ค„๋กœ ์—„์ฒญ๋‚œ ์ž‘์—…์„ ํ•  ์ˆ˜ ์žˆ์–ด์š”. ๐Ÿ”ฅ

Adobe Premiere๋‚˜ Final Cut Pro ๊ฐ™์€ ๋น„์‹ผ ํ”„๋กœ๊ทธ๋žจ ์—†์ด๋„ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์œผ๋กœ ์˜์ƒ ํŽธ์ง‘์„ ์ž๋™ํ™”ํ•  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒŒ ์ตœ๊ณ  ์žฅ์ ์ด์ฃ . ํŠนํžˆ ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์˜์ƒ ํŽธ์ง‘ ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•˜๋Š” ๋ถ„๋“คํ•œํ…Œ๋Š” ์™„์ „ ํ•„์ˆ˜ํ…œ์ด์—์š”!

๐Ÿ’ก FFmpeg์˜ ํ•ต์‹ฌ ์žฅ์  1. ๋ฌด๋ฃŒ ์˜คํ”ˆ์†Œ์Šค: ๋ผ์ด์„ ์Šค ๋น„์šฉ ์ œ๋กœ! ์ƒ์—…์  ์šฉ๋„๋กœ๋„ ์ž์œ ๋กญ๊ฒŒ ์‚ฌ์šฉ ๊ฐ€๋Šฅ
2. ํฌ๋กœ์Šค ํ”Œ๋žซํผ: Windows, macOS, Linux ๋ชจ๋‘ ์ง€์›
3. ๊ฐ•๋ ฅํ•œ ์„ฑ๋Šฅ: ํ•˜๋“œ์›จ์–ด ๊ฐ€์†(GPU) ์ง€์›์œผ๋กœ ์ดˆ๊ณ ์† ์ฒ˜๋ฆฌ
4. ๋ฐฉ๋Œ€ํ•œ ํฌ๋งท ์ง€์›: MP4, AVI, MOV, MKV, WebM ๋“ฑ ๊ฑฐ์˜ ๋ชจ๋“  ํฌ๋งท
5. ์ž๋™ํ™” ์ตœ์ ํ™”: ์Šคํฌ๋ฆฝํŠธ๋กœ ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ

โš™๏ธ FFmpeg ์„ค์น˜ํ•˜๊ธฐ (OS๋ณ„ ์™„์ „์ •๋ณต)

๋ณธ๊ฒฉ์ ์œผ๋กœ ์‹œ์ž‘ํ•˜๊ธฐ ์ „์— FFmpeg์„ ์„ค์น˜ํ•ด์•ผ๊ฒ ์ฃ ? OS๋ณ„๋กœ ๋ฐฉ๋ฒ•์ด ์กฐ๊ธˆ์”ฉ ๋‹ค๋ฅธ๋ฐ, ํ•˜๋‚˜์”ฉ ์•Œ๋ ค๋“œ๋ฆด๊ฒŒ์š”!

1 Windows ์„ค์น˜

๊ฐ€์žฅ ๊ฐ„๋‹จํ•œ ๋ฐฉ๋ฒ•์€ ๊ณต์‹ ์‚ฌ์ดํŠธ(ffmpeg.org)์—์„œ ๋นŒ๋“œ๋œ ๋ฐ”์ด๋„ˆ๋ฆฌ๋ฅผ ๋‹ค์šด๋ฐ›๋Š” ๊ฑฐ์˜ˆ์š”. ๊ทผ๋ฐ ์†”์งํžˆ ์ด๊ฒƒ๋„ ๊ท€์ฐฎ์œผ๋ฉด Chocolatey ํŒจํ‚ค์ง€ ๋งค๋‹ˆ์ € ์“ฐ๋Š” ๊ฒŒ ๊ฐœ๊ฟ€ ใ…‹ใ…‹ใ…‹
# Chocolatey๋กœ ์„ค์น˜ (๊ด€๋ฆฌ์ž ๊ถŒํ•œ PowerShell)
choco install ffmpeg

# ์„ค์น˜ ํ™•์ธ
ffmpeg -version
2 macOS ์„ค์น˜

๋งฅ ์œ ์ €๋ผ๋ฉด Homebrew๊ฐ€ ๋‹ต์ด์ฃ ! ํ„ฐ๋ฏธ๋„ ์—ด๊ณ  ๋ช…๋ น์–ด ํ•œ ์ค„์ด๋ฉด ๋~
# Homebrew๋กœ ์„ค์น˜
brew install ffmpeg

# ์ถ”๊ฐ€ ์ฝ”๋ฑ ํฌํ•จ ์„ค์น˜ (๊ถŒ์žฅ)
brew install ffmpeg --with-fdk-aac --with-ffplay --with-freetype --with-libass --with-libvorbis --with-libvpx --with-opus --with-x265
3 Linux ์„ค์น˜

๋ฆฌ๋ˆ…์Šค๋Š” ๋ฐฐํฌํŒ๋งˆ๋‹ค ํŒจํ‚ค์ง€ ๋งค๋‹ˆ์ €๊ฐ€ ๋‹ค๋ฅด์ง€๋งŒ, ๋Œ€๋ถ€๋ถ„ ๊ธฐ๋ณธ ์ €์žฅ์†Œ์— ํฌํ•จ๋˜์–ด ์žˆ์–ด์š”.
# Ubuntu/Debian
sudo apt update
sudo apt install ffmpeg

# CentOS/RHEL
sudo yum install ffmpeg

# Arch Linux
sudo pacman -S ffmpeg
๐Ÿ” ์„ค์น˜ ํ™•์ธ ํŒ: ์„ค์น˜ ํ›„ ํ„ฐ๋ฏธ๋„์—์„œ ffmpeg -version ๋ช…๋ น์–ด๋ฅผ ์‹คํ–‰ํ–ˆ์„ ๋•Œ ๋ฒ„์ „ ์ •๋ณด๊ฐ€ ์ฃผ๋ฅด๋ฅต ๋‚˜์˜ค๋ฉด ์„ฑ๊ณต! ๋งŒ์•ฝ "command not found" ์—๋Ÿฌ๊ฐ€ ๋‚˜๋ฉด ํ™˜๊ฒฝ๋ณ€์ˆ˜(PATH) ์„ค์ •์„ ํ™•์ธํ•ด๋ณด์„ธ์š”.

๐ŸŽฌ ๊ธฐ๋ณธ ๋ช…๋ น์–ด ๋งˆ์Šคํ„ฐํ•˜๊ธฐ

FFmpeg์˜ ๊ธฐ๋ณธ ๋ฌธ๋ฒ•์€ ์ด๋ ‡๊ฒŒ ์ƒ๊ฒผ์–ด์š”:
ffmpeg [์ž…๋ ฅ ์˜ต์…˜] -i ์ž…๋ ฅํŒŒ์ผ [์ถœ๋ ฅ ์˜ต์…˜] ์ถœ๋ ฅํŒŒ์ผ

๊ฐ„๋‹จํ•˜์ฃ ? ๊ทผ๋ฐ ์˜ต์…˜์ด ์ง„์งœ ๊ฐœ๋งŽ์•„์„œ ์ฒ˜์Œ์—” ์ข€ ํ—ท๊ฐˆ๋ฆด ์ˆ˜ ์žˆ์–ด์š” ใ…‹ใ…‹ใ…‹ ์ž์ฃผ ์“ฐ๋Š” ๊ฒƒ๋“ค๋ถ€ํ„ฐ ํ•˜๋‚˜์”ฉ ์•Œ์•„๋ณผ๊ฒŒ์š”!

๐Ÿ“น ํฌ๋งท ๋ณ€ํ™˜ (๊ฐ€์žฅ ๊ธฐ๋ณธ)

# MP4๋ฅผ AVI๋กœ ๋ณ€ํ™˜
ffmpeg -i input.mp4 output.avi

# MOV๋ฅผ WebM์œผ๋กœ ๋ณ€ํ™˜
ffmpeg -i input.mov output.webm

# ์—ฌ๋Ÿฌ ํŒŒ์ผ ํ•œ๋ฒˆ์— ๋ณ€ํ™˜ (๋ฐฐ์น˜ ์ฒ˜๋ฆฌ)
for file in *.mp4; do ffmpeg -i "$file" "${file%.mp4}.avi"; done
๐Ÿ’ฐ ์‹ค์ „ ํ™œ์šฉ: ํด๋ผ์ด์–ธํŠธ๊ฐ€ ๋‹ค์–‘ํ•œ ํฌ๋งท์œผ๋กœ ์˜์ƒ์„ ์š”์ฒญํ•  ๋•Œ ์ž๋™ํ™” ์Šคํฌ๋ฆฝํŠธ๋กœ ํ•œ๋ฐฉ์— ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ! ์žฌ๋Šฅ๋„ท์—์„œ ์˜์ƒ ๋ณ€ํ™˜ ์„œ๋น„์Šค ์ œ๊ณตํ•  ๋•Œ ์™„์ „ ์œ ์šฉํ•ด์š”.

โœ‚๏ธ ์˜์ƒ ์ž๋ฅด๊ธฐ (ํŠธ๋ฆฌ๋ฐ)

# ์‹œ์ž‘ ์‹œ๊ฐ„๋ถ€ํ„ฐ ํŠน์ • ๊ธธ์ด๋งŒํผ ์ž๋ฅด๊ธฐ
ffmpeg -i input.mp4 -ss 00:00:10 -t 00:00:30 output.mp4
# 10์ดˆ๋ถ€ํ„ฐ 30์ดˆ ๊ธธ์ด๋งŒํผ ์ถ”์ถœ

# ํŠน์ • ๊ตฌ๊ฐ„ ์ถ”์ถœ (์‹œ์ž‘~๋)
ffmpeg -i input.mp4 -ss 00:01:00 -to 00:02:30 output.mp4
# 1๋ถ„๋ถ€ํ„ฐ 2๋ถ„ 30์ดˆ๊นŒ์ง€ ์ถ”์ถœ

# ๊ณ ์† ์ฒ˜๋ฆฌ (์žฌ์ธ์ฝ”๋”ฉ ์—†์ด)
ffmpeg -ss 00:00:10 -i input.mp4 -t 00:00:30 -c copy output.mp4
โšก ์„ฑ๋Šฅ ํŒ: -ss ์˜ต์…˜์„ -i ์•ž์— ๋‘๋ฉด ์ž…๋ ฅ ํŒŒ์ผ์„ ๋น ๋ฅด๊ฒŒ ํƒ์ƒ‰(seek)ํ•  ์ˆ˜ ์žˆ์–ด์š”. ๋’ค์— ๋‘๋ฉด ์ •ํ™•๋„๋Š” ๋†’์ง€๋งŒ ๋А๋ ค์š”. -c copy๋Š” ์žฌ์ธ์ฝ”๋”ฉ ์—†์ด ์ŠคํŠธ๋ฆผ์„ ๋ณต์‚ฌ๋งŒ ํ•˜๋‹ˆ๊นŒ ์ดˆ๊ณ ์† ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ! ๋‹จ, ํ‚คํ”„๋ ˆ์ž„ ์œ„์น˜์— ๋”ฐ๋ผ ์ •ํ™•๋„๊ฐ€ ๋–จ์–ด์งˆ ์ˆ˜ ์žˆ์–ด์š”.

๐Ÿ“ ํ•ด์ƒ๋„ ๋ณ€๊ฒฝ ๋ฐ ๋ฆฌ์‚ฌ์ด์ง•

# ํŠน์ • ํ•ด์ƒ๋„๋กœ ๋ณ€๊ฒฝ
ffmpeg -i input.mp4 -vf scale=1280:720 output.mp4

# ๊ฐ€๋กœ ๊ณ ์ •, ์„ธ๋กœ ๋น„์œจ ์œ ์ง€
ffmpeg -i input.mp4 -vf scale=1920:-1 output.mp4

# ์„ธ๋กœ ๊ณ ์ •, ๊ฐ€๋กœ ๋น„์œจ ์œ ์ง€
ffmpeg -i input.mp4 -vf scale=-1:1080 output.mp4

# ๋น„์œจ ์œ ์ง€ํ•˜๋ฉฐ ์ตœ๋Œ€ ํฌ๊ธฐ ์ œํ•œ
ffmpeg -i input.mp4 -vf "scale='min(1920,iw)':'min(1080,ih)':force_original_aspect_ratio=decrease" output.mp4
๐ŸŽจ ์Šค์ผ€์ผ๋ง ์•Œ๊ณ ๋ฆฌ์ฆ˜: ๊ธฐ๋ณธ์ ์œผ๋กœ bicubic ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์‚ฌ์šฉํ•˜๋Š”๋ฐ, -sws_flags lanczos ์˜ต์…˜์„ ์ถ”๊ฐ€ํ•˜๋ฉด ๋” ๊ณ ํ’ˆ์งˆ ๋ฆฌ์‚ฌ์ด์ง•์ด ๊ฐ€๋Šฅํ•ด์š”. ๋Œ€์‹  ์ฒ˜๋ฆฌ ์‹œ๊ฐ„์€ ์ข€ ๋” ๊ฑธ๋ฆฌ์ฃ  ใ…‹ใ…‹

๐ŸŽต ์˜ค๋””์˜ค ์ถ”์ถœ ๋ฐ ๋ณ€ํ™˜

# ์˜์ƒ์—์„œ ์˜ค๋””์˜ค๋งŒ ์ถ”์ถœ
ffmpeg -i input.mp4 -vn -acodec copy output.aac

# MP3๋กœ ๋ณ€ํ™˜ํ•˜๋ฉฐ ๋น„ํŠธ๋ ˆ์ดํŠธ ์ง€์ •
ffmpeg -i input.mp4 -vn -ab 320k output.mp3

# ์˜ค๋””์˜ค ์—†๋Š” ์˜์ƒ ๋งŒ๋“ค๊ธฐ
ffmpeg -i input.mp4 -an output.mp4

# ์˜ค๋””์˜ค ๋ณผ๋ฅจ ์กฐ์ ˆ
ffmpeg -i input.mp4 -af "volume=2.0" output.mp4  # 2๋ฐฐ ์ฆํญ
ffmpeg -i input.mp4 -af "volume=0.5" output.mp4  # 50% ๊ฐ์†Œ

๐Ÿš€ ๊ณ ๊ธ‰ ํŽธ์ง‘ ๊ธฐ๋Šฅ (์ง„์งœ ๊ฟ€ํŒ๋“ค)

์ด์ œ๋ถ€ํ„ฐ๊ฐ€ ์ง„์งœ ์žฌ๋ฐŒ๋Š” ๋ถ€๋ถ„์ด์—์š”! FFmpeg์˜ ํ•„ํ„ฐ ์‹œ์Šคํ…œ์„ ํ™œ์šฉํ•˜๋ฉด ํ”„๋ฆฌ๋ฏธ์–ด ํ”„๋กœ ๋ชป์ง€์•Š์€ ํŽธ์ง‘์ด ๊ฐ€๋Šฅํ•˜๊ฑฐ๋“ ์š” ใ…‹ใ…‹ใ…‹

๐ŸŽจ ์›Œํ„ฐ๋งˆํฌ ์ถ”๊ฐ€ํ•˜๊ธฐ

# ์ด๋ฏธ์ง€ ์›Œํ„ฐ๋งˆํฌ ์ถ”๊ฐ€ (์šฐ์ธก ์ƒ๋‹จ)
ffmpeg -i input.mp4 -i watermark.png -filter_complex "overlay=W-w-10:10" output.mp4

# ์ขŒ์ธก ํ•˜๋‹จ์— ๋ฐฐ์น˜
ffmpeg -i input.mp4 -i watermark.png -filter_complex "overlay=10:H-h-10" output.mp4

# ์ค‘์•™ ๋ฐฐ์น˜
ffmpeg -i input.mp4 -i watermark.png -filter_complex "overlay=(W-w)/2:(H-h)/2" output.mp4

# ํˆฌ๋ช…๋„ ์กฐ์ ˆ
ffmpeg -i input.mp4 -i watermark.png -filter_complex "[1:v]format=rgba,colorchannelmixer=aa=0.5[logo];[0:v][logo]overlay=W-w-10:10" output.mp4
โš ๏ธ ์ฃผ์˜์‚ฌํ•ญ: ์›Œํ„ฐ๋งˆํฌ ์ด๋ฏธ์ง€๋Š” PNG ํฌ๋งท(ํˆฌ๋ช… ๋ฐฐ๊ฒฝ)์„ ๊ถŒ์žฅํ•ด์š”. JPG๋Š” ๋ฐฐ๊ฒฝ์ด ๋ถˆํˆฌ๋ช…ํ•ด์„œ ์˜์ƒ์„ ๊ฐ€๋ฆด ์ˆ˜ ์žˆ๊ฑฐ๋“ ์š”. ๊ทธ๋ฆฌ๊ณ  ์›Œํ„ฐ๋งˆํฌ ํฌ๊ธฐ๊ฐ€ ๋„ˆ๋ฌด ํฌ๋ฉด ์ธ์ฝ”๋”ฉ ์†๋„๊ฐ€ ๋А๋ ค์งˆ ์ˆ˜ ์žˆ์œผ๋‹ˆ ์ ์ ˆํ•œ ํฌ๊ธฐ๋กœ ์กฐ์ ˆํ•˜์„ธ์š”!

๐Ÿ“ ์ž๋ง‰ ์‚ฝ์ž…ํ•˜๊ธฐ

# SRT ์ž๋ง‰ ํŒŒ์ผ ์‚ฝ์ž… (ํ•˜๋“œ์„œ๋ธŒ)
ffmpeg -i input.mp4 -vf "subtitles=subtitle.srt" output.mp4

# ์ž๋ง‰ ์Šคํƒ€์ผ ์ปค์Šคํ„ฐ๋งˆ์ด์ง•
ffmpeg -i input.mp4 -vf "subtitles=subtitle.srt:force_style='FontName=Arial,FontSize=24,PrimaryColour=&H00FFFF'" output.mp4

# ASS ์ž๋ง‰ ์‚ฌ์šฉ (๋” ๋งŽ์€ ์Šคํƒ€์ผ ์˜ต์…˜)
ffmpeg -i input.mp4 -vf "ass=subtitle.ass" output.mp4

# ์†Œํ”„ํŠธ์„œ๋ธŒ (์ž๋ง‰ ์ŠคํŠธ๋ฆผ์œผ๋กœ ์ถ”๊ฐ€)
ffmpeg -i input.mp4 -i subtitle.srt -c copy -c:s mov_text output.mp4
๐ŸŽฌ ํ”„๋กœ ํŒ: ํ•˜๋“œ์„œ๋ธŒ๋Š” ์˜์ƒ์— ์ž๋ง‰์„ ์ง์ ‘ ๋ Œ๋”๋งํ•˜๋Š” ๊ฑฐ๋ผ ๋ชจ๋“  ํ”Œ๋ ˆ์ด์–ด์—์„œ ๋ณด์ด์ง€๋งŒ ์ˆ˜์ • ๋ถˆ๊ฐ€๋Šฅํ•ด์š”. ์†Œํ”„ํŠธ์„œ๋ธŒ๋Š” ์ž๋ง‰์„ ๋ณ„๋„ ์ŠคํŠธ๋ฆผ์œผ๋กœ ๋„ฃ์–ด์„œ ์ผœ๊ณ  ๋Œ ์ˆ˜ ์žˆ์ง€๋งŒ, ํ”Œ๋ ˆ์ด์–ด ์ง€์›์ด ํ•„์š”ํ•˜์ฃ . ์šฉ๋„์— ๋งž๊ฒŒ ์„ ํƒํ•˜์„ธ์š”!

๐ŸŽž๏ธ ์—ฌ๋Ÿฌ ์˜์ƒ ์ด์–ด๋ถ™์ด๊ธฐ (Concatenation)

# ๋ฐฉ๋ฒ• 1: ํŒŒ์ผ ๋ฆฌ์ŠคํŠธ ์‚ฌ์šฉ (๊ถŒ์žฅ)
# filelist.txt ํŒŒ์ผ ์ƒ์„ฑ
file 'video1.mp4'
file 'video2.mp4'
file 'video3.mp4'

ffmpeg -f concat -safe 0 -i filelist.txt -c copy output.mp4

# ๋ฐฉ๋ฒ• 2: concat ํ•„ํ„ฐ ์‚ฌ์šฉ (์žฌ์ธ์ฝ”๋”ฉ ํ•„์š”)
ffmpeg -i video1.mp4 -i video2.mp4 -i video3.mp4 -filter_complex "[0:v][0:a][1:v][1:a][2:v][2:a]concat=n=3:v=1:a=1[outv][outa]" -map "[outv]" -map "[outa]" output.mp4

# ๋ฐฉ๋ฒ• 3: ๊ฐ„๋‹จํ•œ ์Šคํฌ๋ฆฝํŠธ๋กœ ์ž๋™ํ™”
for f in *.mp4; do echo "file '$f'" >> list.txt; done
ffmpeg -f concat -safe 0 -i list.txt -c copy output.mp4

๐ŸŽญ ํŽ˜์ด๋“œ ์ธ/์•„์›ƒ ํšจ๊ณผ

# ๋น„๋””์˜ค ํŽ˜์ด๋“œ ์ธ (์ฒ˜์Œ 2์ดˆ)
ffmpeg -i input.mp4 -vf "fade=t=in:st=0:d=2" output.mp4

# ๋น„๋””์˜ค ํŽ˜์ด๋“œ ์•„์›ƒ (๋งˆ์ง€๋ง‰ 3์ดˆ)
ffmpeg -i input.mp4 -vf "fade=t=out:st=27:d=3" output.mp4
# st๋Š” ์‹œ์ž‘ ์‹œ๊ฐ„(์ดˆ), d๋Š” ์ง€์† ์‹œ๊ฐ„(์ดˆ)

# ์˜ค๋””์˜ค ํŽ˜์ด๋“œ ์ธ/์•„์›ƒ
ffmpeg -i input.mp4 -af "afade=t=in:st=0:d=2,afade=t=out:st=27:d=3" output.mp4

# ๋น„๋””์˜ค+์˜ค๋””์˜ค ๋™์‹œ ํŽ˜์ด๋“œ
ffmpeg -i input.mp4 -vf "fade=t=in:st=0:d=2,fade=t=out:st=27:d=3" -af "afade=t=in:st=0:d=2,afade=t=out:st=27:d=3" output.mp4

๐Ÿ–ผ๏ธ ์ธ๋„ค์ผ ์ถ”์ถœํ•˜๊ธฐ

# ํŠน์ • ์‹œ๊ฐ„์˜ ํ”„๋ ˆ์ž„ ์ถ”์ถœ
ffmpeg -i input.mp4 -ss 00:00:05 -vframes 1 thumbnail.jpg

# 1์ดˆ๋งˆ๋‹ค ์ธ๋„ค์ผ ์ถ”์ถœ
ffmpeg -i input.mp4 -vf "fps=1" thumbnail_%03d.jpg

# ๊ณ ํ’ˆ์งˆ ์ธ๋„ค์ผ (ํ•ด์ƒ๋„ ์ง€์ •)
ffmpeg -i input.mp4 -ss 00:00:10 -vframes 1 -vf scale=1920:1080 -q:v 2 thumbnail.jpg

# ์—ฌ๋Ÿฌ ์‹œ๊ฐ„๋Œ€์˜ ์ธ๋„ค์ผ ์ž๋™ ์ถ”์ถœ
ffmpeg -i input.mp4 -vf "select='eq(pict_type,I)'" -vsync vfr thumbnail_%03d.jpg
๐Ÿ’ก I-ํ”„๋ ˆ์ž„ ํ™œ์šฉ: select='eq(pict_type,I)' ํ•„ํ„ฐ๋Š” I-ํ”„๋ ˆ์ž„(ํ‚คํ”„๋ ˆ์ž„)๋งŒ ์ถ”์ถœํ•ด์š”. ์ด๊ฒŒ ํ™”์งˆ์ด ๊ฐ€์žฅ ์ข‹๊ฑฐ๋“ ์š”! ์˜์ƒ ๋ฏธ๋ฆฌ๋ณด๊ธฐ ์ด๋ฏธ์ง€ ๋งŒ๋“ค ๋•Œ ์™„์ „ ์œ ์šฉํ•ฉ๋‹ˆ๋‹ค ใ…‹ใ…‹

โšก ์ธ์ฝ”๋”ฉ ์ตœ์ ํ™” (์†๋„ vs ํ’ˆ์งˆ)

์ธ์ฝ”๋”ฉ์€ ์‹œ๊ฐ„์ด ์˜ค๋ž˜ ๊ฑธ๋ฆฌ๋Š” ์ž‘์—…์ด๋ผ ์ตœ์ ํ™”๊ฐ€ ์ง„์งœ ์ค‘์š”ํ•ด์š”. ์ƒํ™ฉ์— ๋งž๋Š” ์„ค์ •์„ ์„ ํƒํ•˜๋ฉด ์‹œ๊ฐ„์„ ์—„์ฒญ ์ ˆ์•ฝํ•  ์ˆ˜ ์žˆ์ฃ !

๐ŸŽฏ ์ฝ”๋ฑ ์„ ํƒ ๊ฐ€์ด๋“œ

์ฝ”๋ฑ ์žฅ์  ๋‹จ์  ์ถ”์ฒœ ์šฉ๋„
H.264 (libx264) ํ˜ธํ™˜์„ฑ ์ตœ๊ณ , ์•ˆ์ •์  ์••์ถ•๋ฅ  ๋ณดํ†ต ๋ฒ”์šฉ ๋ชฉ์ , ์œ ํŠœ๋ธŒ
H.265 (libx265) ์••์ถ•๋ฅ  ์šฐ์ˆ˜, ๊ณ ํ™”์งˆ ์ธ์ฝ”๋”ฉ ๋А๋ฆผ, ํ˜ธํ™˜์„ฑ ๋‚ฎ์Œ 4K ์˜์ƒ, ์ €์žฅ ๊ณต๊ฐ„ ์ ˆ์•ฝ
VP9 ๋ฌด๋ฃŒ, ์›น ์ตœ์ ํ™” ์ธ์ฝ”๋”ฉ ๋งค์šฐ ๋А๋ฆผ ์›น ์ŠคํŠธ๋ฆฌ๋ฐ, ์œ ํŠœ๋ธŒ
AV1 ์ฐจ์„ธ๋Œ€ ์ฝ”๋ฑ, ์ตœ๊ณ  ์••์ถ•๋ฅ  ์ธ์ฝ”๋”ฉ ๊ทน๋„๋กœ ๋А๋ฆผ ๋ฏธ๋ž˜ ๋Œ€๋น„, ์‹คํ—˜์  ์šฉ๋„

๐Ÿš„ H.264 ์ธ์ฝ”๋”ฉ ์„ค์ • (๊ฐ€์žฅ ๋งŽ์ด ์”€)

# ๊ธฐ๋ณธ ์„ค์ • (๊ท ํ˜•์žกํžŒ ํ’ˆ์งˆ)
ffmpeg -i input.mp4 -c:v libx264 -preset medium -crf 23 output.mp4

# ๊ณ ์† ์ธ์ฝ”๋”ฉ (ํ’ˆ์งˆ ์•ฝ๊ฐ„ ํฌ์ƒ)
ffmpeg -i input.mp4 -c:v libx264 -preset ultrafast -crf 23 output.mp4

# ๊ณ ํ’ˆ์งˆ ์ธ์ฝ”๋”ฉ (์‹œ๊ฐ„ ์˜ค๋ž˜ ๊ฑธ๋ฆผ)
ffmpeg -i input.mp4 -c:v libx264 -preset slow -crf 18 output.mp4

# ์œ ํŠœ๋ธŒ ์ตœ์ ํ™” ์„ค์ •
ffmpeg -i input.mp4 -c:v libx264 -preset slow -crf 18 -c:a aac -b:a 192k -pix_fmt yuv420p -movflags +faststart output.mp4
๐ŸŽš๏ธ CRF ๊ฐ’ ๊ฐ€์ด๋“œ:
โ€ข 0 = ๋ฌด์†์‹ค (ํŒŒ์ผ ํฌ๊ธฐ ์—„์ฒญ ํผ)
โ€ข 18 = ์‹œ๊ฐ์ ์œผ๋กœ ๋ฌด์†์‹ค์— ๊ฐ€๊นŒ์›€ (๊ณ ํ’ˆ์งˆ)
โ€ข 23 = ๊ธฐ๋ณธ๊ฐ’ (์ข‹์€ ํ’ˆ์งˆ, ์ ๋‹นํ•œ ํฌ๊ธฐ)
โ€ข 28 = ๋‚ฎ์€ ํ’ˆ์งˆ (์ž‘์€ ํŒŒ์ผ ํฌ๊ธฐ)
โ€ข 51 = ์ตœ์•…์˜ ํ’ˆ์งˆ (๊ฑฐ์˜ ์•ˆ ์”€)

๋ณดํ†ต 18~28 ์‚ฌ์ด์—์„œ ์„ ํƒํ•˜๋ฉด ๋˜๊ณ , ์ˆซ์ž๊ฐ€ ๋‚ฎ์„์ˆ˜๋ก ํ’ˆ์งˆ ์ข‹๊ณ  ํŒŒ์ผ ์ปค์ ธ์š”!

๐ŸŽฌ ํ”„๋ฆฌ์…‹ ๋น„๊ต

ํ”„๋ฆฌ์…‹ ์ธ์ฝ”๋”ฉ ์†๋„ ์••์ถ• ํšจ์œจ ์‚ฌ์šฉ ์‹œ๋‚˜๋ฆฌ์˜ค
ultrafast ๋งค์šฐ ๋น ๋ฆ„ ๋‚ฎ์Œ ์‹ค์‹œ๊ฐ„ ์ŠคํŠธ๋ฆฌ๋ฐ, ํ…Œ์ŠคํŠธ
superfast ๋น ๋ฆ„ ๋ณดํ†ต ๋น ๋ฅธ ์ฒ˜๋ฆฌ ํ•„์š”์‹œ
veryfast ๋น ๋ฆ„ ๋ณดํ†ต ์ผ๋ฐ˜ ์ž‘์—…
faster ์•ฝ๊ฐ„ ๋น ๋ฆ„ ์ข‹์Œ ์ผ๋ฐ˜ ์ž‘์—…
fast ์•ฝ๊ฐ„ ๋น ๋ฆ„ ์ข‹์Œ ์ผ๋ฐ˜ ์ž‘์—…
medium ๋ณดํ†ต ์ข‹์Œ ๊ธฐ๋ณธ ๊ถŒ์žฅ ์„ค์ •
slow ๋А๋ฆผ ์šฐ์ˆ˜ ์ตœ์ข… ๋ฐฐํฌ์šฉ
slower ๋งค์šฐ ๋А๋ฆผ ์šฐ์ˆ˜ ๊ณ ํ’ˆ์งˆ ํ•„์š”์‹œ
veryslow ๊ทน๋„๋กœ ๋А๋ฆผ ์ตœ๊ณ  ์•„์นด์ด๋น™, ๋งˆ์Šคํ„ฐ ํŒŒ์ผ

๐Ÿ’ช ํ•˜๋“œ์›จ์–ด ๊ฐ€์† ํ™œ์šฉ

# NVIDIA GPU ๊ฐ€์† (NVENC)
ffmpeg -hwaccel cuda -i input.mp4 -c:v h264_nvenc -preset fast -crf 23 output.mp4

# Intel Quick Sync ๊ฐ€์†
ffmpeg -hwaccel qsv -c:v h264_qsv -i input.mp4 -c:v h264_qsv -preset fast output.mp4

# AMD GPU ๊ฐ€์† (AMF)
ffmpeg -hwaccel d3d11va -i input.mp4 -c:v h264_amf -quality speed output.mp4

# macOS VideoToolbox ๊ฐ€์†
ffmpeg -hwaccel videotoolbox -i input.mp4 -c:v h264_videotoolbox -b:v 5M output.mp4
โš ๏ธ ํ•˜๋“œ์›จ์–ด ๊ฐ€์† ์ฃผ์˜์ : GPU ์ธ์ฝ”๋”ฉ์€ CPU๋ณด๋‹ค ํ›จ์”ฌ ๋น ๋ฅด์ง€๋งŒ, ๊ฐ™์€ ๋น„ํŠธ๋ ˆ์ดํŠธ์—์„œ ํ’ˆ์งˆ์ด ์•ฝ๊ฐ„ ๋–จ์–ด์งˆ ์ˆ˜ ์žˆ์–ด์š”. ์†๋„๊ฐ€ ์ค‘์š”ํ•œ ๊ฒฝ์šฐ(์‹ค์‹œ๊ฐ„ ์ŠคํŠธ๋ฆฌ๋ฐ, ๋Œ€๋Ÿ‰ ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ)์— ์‚ฌ์šฉํ•˜๊ณ , ์ตœ์ข… ๋งˆ์Šคํ„ฐ ํŒŒ์ผ์€ CPU ์ธ์ฝ”๋”ฉ์„ ๊ถŒ์žฅํ•ฉ๋‹ˆ๋‹ค!

๐ŸŽต ์˜ค๋””์˜ค ์ธ์ฝ”๋”ฉ ์ตœ์ ํ™”

# AAC ์ธ์ฝ”๋”ฉ (๊ฐ€์žฅ ๋ฒ”์šฉ์ )
ffmpeg -i input.mp4 -c:v copy -c:a aac -b:a 192k output.mp4

# ๊ณ ํ’ˆ์งˆ ์˜ค๋””์˜ค (256kbps)
ffmpeg -i input.mp4 -c:v copy -c:a aac -b:a 256k output.mp4

# ์ €์šฉ๋Ÿ‰ ์˜ค๋””์˜ค (128kbps, ์Œ์„ฑ ์œ„์ฃผ)
ffmpeg -i input.mp4 -c:v copy -c:a aac -b:a 128k output.mp4

# Opus ์ฝ”๋ฑ (์›น ์ŠคํŠธ๋ฆฌ๋ฐ ์ตœ์ )
ffmpeg -i input.mp4 -c:v copy -c:a libopus -b:a 128k output.webm

# ์˜ค๋””์˜ค ์ •๊ทœํ™” (๋ณผ๋ฅจ ๊ท ์ผํ™”)
ffmpeg -i input.mp4 -af loudnorm output.mp4

๐Ÿค– ์ž๋™ํ™” ์Šคํฌ๋ฆฝํŠธ ๋งŒ๋“ค๊ธฐ

์ด์ œ ์ง„์งœ ํ•ต์‹ฌ! FFmpeg ๋ช…๋ น์–ด๋ฅผ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์™€ ๊ฒฐํ•ฉํ•˜๋ฉด ์™„์ „ ์ž๋™ํ™”๋œ ์˜์ƒ ์ฒ˜๋ฆฌ ์‹œ์Šคํ…œ์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด์š” ใ…‹ใ…‹ใ…‹ ์‹ค์ „์—์„œ ๋ฐ”๋กœ ์“ธ ์ˆ˜ ์žˆ๋Š” ์˜ˆ์ œ๋“ค์„ ๋ณด์—ฌ๋“œ๋ฆด๊ฒŒ์š”!

๐Ÿ Python์œผ๋กœ ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ ์ž๋™ํ™”

import subprocess
import os
from pathlib import Path

def batch_convert_videos(input_dir, output_dir, target_format='mp4'):
    """
    ํด๋” ๋‚ด ๋ชจ๋“  ์˜์ƒ์„ ํŠน์ • ํฌ๋งท์œผ๋กœ ๋ณ€ํ™˜
    """
    # ์ถœ๋ ฅ ๋””๋ ‰ํ† ๋ฆฌ ์ƒ์„ฑ
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    
    # ์ง€์›ํ•˜๋Š” ์˜์ƒ ํ™•์žฅ์ž
    video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.flv', '.wmv']
    
    # ์ž…๋ ฅ ๋””๋ ‰ํ† ๋ฆฌ์˜ ๋ชจ๋“  ํŒŒ์ผ ํƒ์ƒ‰
    for filename in os.listdir(input_dir):
        file_path = os.path.join(input_dir, filename)
        
        # ์˜์ƒ ํŒŒ์ผ์ธ์ง€ ํ™•์ธ
        if any(filename.lower().endswith(ext) for ext in video_extensions):
            # ์ถœ๋ ฅ ํŒŒ์ผ๋ช… ์ƒ์„ฑ
            output_filename = f"{Path(filename).stem}.{target_format}"
            output_path = os.path.join(output_dir, output_filename)
            
            # FFmpeg ๋ช…๋ น์–ด ๊ตฌ์„ฑ
            cmd = [
                'ffmpeg',
                '-i', file_path,
                '-c:v', 'libx264',
                '-preset', 'medium',
                '-crf', '23',
                '-c:a', 'aac',
                '-b:a', '192k',
                '-y',  # ๋ฎ์–ด์“ฐ๊ธฐ ํ™•์ธ ์—†์ด
                output_path
            ]
            
            print(f"๋ณ€ํ™˜ ์ค‘: {filename} -> {output_filename}")
            
            try:
                # FFmpeg ์‹คํ–‰
                subprocess.run(cmd, check=True, capture_output=True)
                print(f"โœ… ์™„๋ฃŒ: {output_filename}")
            except subprocess.CalledProcessError as e:
                print(f"โŒ ์‹คํŒจ: {filename} - {e}")

# ์‚ฌ์šฉ ์˜ˆ์‹œ
if __name__ == "__main__":
    batch_convert_videos(
        input_dir='./input_videos',
        output_dir='./output_videos',
        target_format='mp4'
    )
๐ŸŽฏ ์‹ค์ „ ํ™œ์šฉ: ์ด ์Šคํฌ๋ฆฝํŠธ๋Š” ํด๋ผ์ด์–ธํŠธ๊ฐ€ ์—ฌ๋Ÿฌ ํฌ๋งท์˜ ์˜์ƒ์„ ๋ณด๋‚ด์™”์„ ๋•Œ ์ผ๊ด„ ๋ณ€ํ™˜ํ•˜๋Š” ๋ฐ ์™„์ „ ์œ ์šฉํ•ด์š”! ์žฌ๋Šฅ๋„ท์—์„œ ์˜์ƒ ํŽธ์ง‘ ์„œ๋น„์Šค ์ œ๊ณตํ•  ๋•Œ ์ด๋Ÿฐ ์ž๋™ํ™” ๋„๊ตฌ๊ฐ€ ์žˆ์œผ๋ฉด ์ž‘์—… ์‹œ๊ฐ„์„ ์—„์ฒญ ๋‹จ์ถ•ํ•  ์ˆ˜ ์žˆ์ฃ  ใ…‹ใ…‹

๐ŸŽฌ ์ž๋™ ์ธ๋„ค์ผ ์ƒ์„ฑ๊ธฐ

import subprocess
import os
from pathlib import Path

def generate_thumbnails(video_path, output_dir, count=5):
    """
    ์˜์ƒ์—์„œ ๊ท ๋“ฑํ•œ ๊ฐ„๊ฒฉ์œผ๋กœ ์ธ๋„ค์ผ ์ถ”์ถœ
    """
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    
    # ์˜์ƒ ๊ธธ์ด ๊ฐ€์ ธ์˜ค๊ธฐ
    duration_cmd = [
        'ffprobe',
        '-v', 'error',
        '-show_entries', 'format=duration',
        '-of', 'default=noprint_wrappers=1:nokey=1',
        video_path
    ]
    
    try:
        result = subprocess.run(duration_cmd, capture_output=True, text=True, check=True)
        duration = float(result.stdout.strip())
        
        # ์ธ๋„ค์ผ ์ถ”์ถœ ๊ฐ„๊ฒฉ ๊ณ„์‚ฐ
        interval = duration / (count + 1)
        
        video_name = Path(video_path).stem
        
        for i in range(1, count + 1):
            timestamp = interval * i
            output_path = os.path.join(output_dir, f"{video_name}_thumb_{i:02d}.jpg")
            
            # ์ธ๋„ค์ผ ์ถ”์ถœ ๋ช…๋ น์–ด
            thumb_cmd = [
                'ffmpeg',
                '-ss', str(timestamp),
                '-i', video_path,
                '-vframes', '1',
                '-vf', 'scale=1280:720',
                '-q:v', '2',
                '-y',
                output_path
            ]
            
            subprocess.run(thumb_cmd, check=True, capture_output=True)
            print(f"โœ… ์ธ๋„ค์ผ ์ƒ์„ฑ: {output_path} (์‹œ๊ฐ„: {timestamp:.2f}์ดˆ)")
            
    except Exception as e:
        print(f"โŒ ์˜ค๋ฅ˜ ๋ฐœ์ƒ: {e}")

# ์‚ฌ์šฉ ์˜ˆ์‹œ
generate_thumbnails('sample_video.mp4', './thumbnails', count=5)

๐Ÿ“Š ์˜์ƒ ์ •๋ณด ๋ถ„์„๊ธฐ

import subprocess
import json

def analyze_video(video_path):
    """
    ์˜์ƒ ํŒŒ์ผ์˜ ์ƒ์„ธ ์ •๋ณด ์ถ”์ถœ
    """
    cmd = [
        'ffprobe',
        '-v', 'quiet',
        '-print_format', 'json',
        '-show_format',
        '-show_streams',
        video_path
    ]
    
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        data = json.loads(result.stdout)
        
        # ๋น„๋””์˜ค ์ŠคํŠธ๋ฆผ ์ฐพ๊ธฐ
        video_stream = next((s for s in data['streams'] if s['codec_type'] == 'video'), None)
        audio_stream = next((s for s in data['streams'] if s['codec_type'] == 'audio'), None)
        
        info = {
            'ํŒŒ์ผ๋ช…': video_path,
            'ํฌ๋งท': data['format']['format_name'],
            'ํŒŒ์ผํฌ๊ธฐ': f"{int(data['format']['size']) / (1024*1024):.2f} MB",
            '์žฌ์ƒ์‹œ๊ฐ„': f"{float(data['format']['duration']):.2f}์ดˆ",
        }
        
        if video_stream:
            info.update({
                '๋น„๋””์˜ค์ฝ”๋ฑ': video_stream['codec_name'],
                'ํ•ด์ƒ๋„': f"{video_stream['width']}x{video_stream['height']}",
                'ํ”„๋ ˆ์ž„๋ ˆ์ดํŠธ': eval(video_stream['r_frame_rate']),
                '๋น„ํŠธ๋ ˆ์ดํŠธ': f"{int(video_stream.get('bit_rate', 0)) / 1000:.0f} kbps"
            })
        
        if audio_stream:
            info.update({
                '์˜ค๋””์˜ค์ฝ”๋ฑ': audio_stream['codec_name'],
                '์ƒ˜ํ”Œ๋ ˆ์ดํŠธ': f"{audio_stream['sample_rate']} Hz",
                '์ฑ„๋„': audio_stream['channels']
            })
        
        return info
        
    except Exception as e:
        return {'์˜ค๋ฅ˜': str(e)}

# ์‚ฌ์šฉ ์˜ˆ์‹œ
video_info = analyze_video('sample_video.mp4')
for key, value in video_info.items():
    print(f"{key}: {value}")

๐Ÿ”„ ์ง„ํ–‰๋ฅ  ํ‘œ์‹œ ๊ธฐ๋Šฅ ์ถ”๊ฐ€

import subprocess
import re
import sys

def convert_with_progress(input_file, output_file):
    """
    ์ง„ํ–‰๋ฅ ์„ ํ‘œ์‹œํ•˜๋ฉฐ ์˜์ƒ ๋ณ€ํ™˜
    """
    # ๋จผ์ € ์˜์ƒ ๊ธธ์ด ๊ฐ€์ ธ์˜ค๊ธฐ
    duration_cmd = [
        'ffprobe',
        '-v', 'error',
        '-show_entries', 'format=duration',
        '-of', 'default=noprint_wrappers=1:nokey=1',
        input_file
    ]
    
    duration_result = subprocess.run(duration_cmd, capture_output=True, text=True)
    total_duration = float(duration_result.stdout.strip())
    
    # FFmpeg ๋ช…๋ น์–ด
    cmd = [
        'ffmpeg',
        '-i', input_file,
        '-c:v', 'libx264',
        '-preset', 'medium',
        '-crf', '23',
        '-c:a', 'aac',
        '-progress', 'pipe:1',  # ์ง„ํ–‰๋ฅ  ์ •๋ณด๋ฅผ stdout์œผ๋กœ
        '-y',
        output_file
    ]
    
    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
    
    # ์ง„ํ–‰๋ฅ  ํŒŒ์‹ฑ
    for line in process.stdout:
        if line.startswith('out_time_ms='):
            time_ms = int(line.split('=')[1])
            current_time = time_ms / 1000000  # ๋งˆ์ดํฌ๋กœ์ดˆ๋ฅผ ์ดˆ๋กœ ๋ณ€ํ™˜
            progress = (current_time / total_duration) * 100
            
            # ์ง„ํ–‰๋ฅ  ํ‘œ์‹œ
            sys.stdout.write(f"\r์ง„ํ–‰๋ฅ : {progress:.1f}% [{current_time:.1f}s / {total_duration:.1f}s]")
            sys.stdout.flush()
    
    process.wait()
    print("\nโœ… ๋ณ€ํ™˜ ์™„๋ฃŒ!")

# ์‚ฌ์šฉ ์˜ˆ์‹œ
convert_with_progress('input.mp4', 'output.mp4')
๐Ÿ’ก ํ”„๋กœ ํŒ: ์‹ค์ œ ์„œ๋น„์Šค์—์„œ๋Š” ์ด๋Ÿฐ ์ง„ํ–‰๋ฅ  ์ •๋ณด๋ฅผ ์›น์†Œ์ผ“์ด๋‚˜ API๋ฅผ ํ†ตํ•ด ํ”„๋ก ํŠธ์—”๋“œ๋กœ ์ „์†กํ•ด์„œ ์‚ฌ์šฉ์ž์—๊ฒŒ ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋ณด์—ฌ์ค„ ์ˆ˜ ์žˆ์–ด์š”. ์‚ฌ์šฉ์ž ๊ฒฝํ—˜(UX)์ด ์™„์ „ ๋‹ฌ๋ผ์ง€์ฃ !

๐ŸŽจ ์›Œํ„ฐ๋งˆํฌ ์ž๋™ ์‚ฝ์ž… ์‹œ์Šคํ…œ

import subprocess
from pathlib import Path

class WatermarkProcessor:
    def __init__(self, watermark_path):
        self.watermark_path = watermark_path
    
    def add_watermark(self, input_video, output_video, position='top-right', opacity=0.7):
        """
        ์˜์ƒ์— ์›Œํ„ฐ๋งˆํฌ ์ถ”๊ฐ€
        position: 'top-right', 'top-left', 'bottom-right', 'bottom-left', 'center'
        """
        # ์œ„์น˜๋ณ„ overlay ์ขŒํ‘œ ์„ค์ •
        positions = {
            'top-right': 'W-w-10:10',
            'top-left': '10:10',
            'bottom-right': 'W-w-10:H-h-10',
            'bottom-left': '10:H-h-10',
            'center': '(W-w)/2:(H-h)/2'
        }
        
        overlay_pos = positions.get(position, positions['top-right'])
        
        # ํ•„ํ„ฐ ๊ตฌ์„ฑ
        filter_complex = f"[1:v]format=rgba,colorchannelmixer=aa={opacity}[logo];[0:v][logo]overlay={overlay_pos}"
        
        cmd = [
            'ffmpeg',
            '-i', input_video,
            '-i', self.watermark_path,
            '-filter_complex', filter_complex,
            '-c:a', 'copy',
            '-y',
            output_video
        ]
        
        try:
            subprocess.run(cmd, check=True, capture_output=True)
            print(f"โœ… ์›Œํ„ฐ๋งˆํฌ ์ถ”๊ฐ€ ์™„๋ฃŒ: {output_video}")
            return True
        except subprocess.CalledProcessError as e:
            print(f"โŒ ์˜ค๋ฅ˜ ๋ฐœ์ƒ: {e}")
            return False
    
    def batch_watermark(self, input_dir, output_dir, position='top-right'):
        """
        ํด๋” ๋‚ด ๋ชจ๋“  ์˜์ƒ์— ์›Œํ„ฐ๋งˆํฌ ์ผ๊ด„ ์ถ”๊ฐ€
        """
        Path(output_dir).mkdir(parents=True, exist_ok=True)
        
        video_files = list(Path(input_dir).glob('*.mp4'))
        total = len(video_files)
        
        for idx, video_file in enumerate(video_files, 1):
            print(f"\n[{idx}/{total}] ์ฒ˜๋ฆฌ ์ค‘: {video_file.name}")
            output_path = Path(output_dir) / f"watermarked_{video_file.name}"
            self.add_watermark(str(video_file), str(output_path), position)

# ์‚ฌ์šฉ ์˜ˆ์‹œ
processor = WatermarkProcessor('logo.png')
processor.batch_watermark('./input_videos', './watermarked_videos', position='bottom-right')

๐ŸŒ ์›น ์„œ๋น„์Šค์™€ ํ†ตํ•ฉํ•˜๊ธฐ

FFmpeg์„ ์›น ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜๊ณผ ์—ฐ๋™ํ•˜๋ฉด ์ง„์งœ ๊ฐ•๋ ฅํ•œ ์„œ๋น„์Šค๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์–ด์š”! Flask๋‚˜ FastAPI ๊ฐ™์€ ํ”„๋ ˆ์ž„์›Œํฌ์™€ ๊ฒฐํ•ฉํ•œ ์˜ˆ์ œ๋ฅผ ๋ณด์—ฌ๋“œ๋ฆด๊ฒŒ์š” ใ…‹ใ…‹

๐Ÿš€ FastAPI๋กœ ์˜์ƒ ๋ณ€ํ™˜ API ๋งŒ๋“ค๊ธฐ

from fastapi import FastAPI, File, UploadFile, BackgroundTasks
from fastapi.responses import FileResponse
import subprocess
import uuid
import os
from pathlib import Path

app = FastAPI(title="Video Converter API")

# ์ž„์‹œ ํŒŒ์ผ ์ €์žฅ ๋””๋ ‰ํ† ๋ฆฌ
UPLOAD_DIR = Path("./uploads")
OUTPUT_DIR = Path("./outputs")
UPLOAD_DIR.mkdir(exist_ok=True)
OUTPUT_DIR.mkdir(exist_ok=True)

def convert_video(input_path: str, output_path: str, target_format: str):
    """
    ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ ์˜์ƒ ๋ณ€ํ™˜ ์‹คํ–‰
    """
    cmd = [
        'ffmpeg',
        '-i', input_path,
        '-c:v', 'libx264',
        '-preset', 'medium',
        '-crf', '23',
        '-c:a', 'aac',
        '-b:a', '192k',
        '-y',
        output_path
    ]
    
    try:
        subprocess.run(cmd, check=True, capture_output=True)
        print(f"โœ… ๋ณ€ํ™˜ ์™„๋ฃŒ: {output_path}")
    except Exception as e:
        print(f"โŒ ๋ณ€ํ™˜ ์‹คํŒจ: {e}")

@app.post("/convert/")
async def convert_video_endpoint(
    background_tasks: BackgroundTasks,
    file: UploadFile = File(...),
    target_format: str = "mp4"
):
    """
    ์˜์ƒ ํŒŒ์ผ์„ ์—…๋กœ๋“œํ•˜๊ณ  ๋ณ€ํ™˜ ์š”์ฒญ
    """
    # ๊ณ ์œ  ํŒŒ์ผ๋ช… ์ƒ์„ฑ
    file_id = str(uuid.uuid4())
    input_filename = f"{file_id}_{file.filename}"
    output_filename = f"{file_id}_converted.{target_format}"
    
    input_path = UPLOAD_DIR / input_filename
    output_path = OUTPUT_DIR / output_filename
    
    # ํŒŒ์ผ ์ €์žฅ
    with open(input_path, "wb") as buffer:
        content = await file.read()
        buffer.write(content)
    
    # ๋ฐฑ๊ทธ๋ผ์šด๋“œ์—์„œ ๋ณ€ํ™˜ ์ž‘์—… ์‹คํ–‰
    background_tasks.add_task(convert_video, str(input_path), str(output_path), target_format)
    
    return {
        "message": "๋ณ€ํ™˜ ์ž‘์—…์ด ์‹œ์ž‘๋˜์—ˆ์Šต๋‹ˆ๋‹ค",
        "file_id": file_id,
        "download_url": f"/download/{output_filename}"
    }

@app.get("/download/{filename}")
async def download_file(filename: str):
    """
    ๋ณ€ํ™˜๋œ ํŒŒ์ผ ๋‹ค์šด๋กœ๋“œ
    """
    file_path = OUTPUT_DIR / filename
    
    if not file_path.exists():
        return {"error": "ํŒŒ์ผ์„ ์ฐพ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค"}
    
    return FileResponse(
        path=file_path,
        filename=filename,
        media_type='application/octet-stream'
    )

@app.get("/info/{filename}")
async def get_video_info(filename: str):
    """
    ์˜์ƒ ํŒŒ์ผ ์ •๋ณด ์กฐํšŒ
    """
    file_path = UPLOAD_DIR / filename
    
    if not file_path.exists():
        return {"error": "ํŒŒ์ผ์„ ์ฐพ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค"}
    
    cmd = [
        'ffprobe',
        '-v', 'quiet',
        '-print_format', 'json',
        '-show_format',
        '-show_streams',
        str(file_path)
    ]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    return {"data": result.stdout}

# ์„œ๋ฒ„ ์‹คํ–‰: uvicorn main:app --reload
๐ŸŽฏ ์‹ค์ „ ํ™œ์šฉ: ์ด๋Ÿฐ API๋ฅผ ๋งŒ๋“ค๋ฉด ์›น์‚ฌ์ดํŠธ๋‚˜ ๋ชจ๋ฐ”์ผ ์•ฑ์—์„œ ์˜์ƒ ๋ณ€ํ™˜ ๊ธฐ๋Šฅ์„ ์ œ๊ณตํ•  ์ˆ˜ ์žˆ์–ด์š”! ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ "์˜์ƒ ํฌ๋งท ๋ณ€ํ™˜ ์„œ๋น„์Šค"๋ฅผ ์ œ๊ณตํ•  ๋•Œ ์ด๋Ÿฐ ์‹œ์Šคํ…œ์„ ๋ฐฑ์—”๋“œ๋กœ ๊ตฌ์ถ•ํ•˜๋ฉด ์™„์ „ ํ”„๋กœํŽ˜์…”๋„ํ•˜๊ฒŒ ์šด์˜ ๊ฐ€๋Šฅํ•˜์ฃ  ใ…‹ใ…‹ใ…‹

๐Ÿ“ฑ ์‹ค์‹œ๊ฐ„ ์ง„ํ–‰๋ฅ  ์ถ”์  (WebSocket)

from fastapi import FastAPI, WebSocket
import subprocess
import asyncio
import re

app = FastAPI()

@app.websocket("/ws/convert")
async def websocket_convert(websocket: WebSocket):
    await websocket.accept()
    
    # ํด๋ผ์ด์–ธํŠธ๋กœ๋ถ€ํ„ฐ ํŒŒ์ผ ์ •๋ณด ๋ฐ›๊ธฐ
    data = await websocket.receive_json()
    input_file = data['input_file']
    output_file = data['output_file']
    
    # ์˜์ƒ ๊ธธ์ด ๊ฐ€์ ธ์˜ค๊ธฐ
    duration_cmd = [
        'ffprobe',
        '-v', 'error',
        '-show_entries', 'format=duration',
        '-of', 'default=noprint_wrappers=1:nokey=1',
        input_file
    ]
    
    duration_result = subprocess.run(duration_cmd, capture_output=True, text=True)
    total_duration = float(duration_result.stdout.strip())
    
    # FFmpeg ํ”„๋กœ์„ธ์Šค ์‹œ์ž‘
    cmd = [
        'ffmpeg',
        '-i', input_file,
        '-c:v', 'libx264',
        '-preset', 'medium',
        '-crf', '23',
        '-progress', 'pipe:1',
        '-y',
        output_file
    ]
    
    process = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        universal_newlines=True
    )
    
    # ์ง„ํ–‰๋ฅ  ์‹ค์‹œ๊ฐ„ ์ „์†ก
    for line in process.stdout:
        if line.startswith('out_time_ms='):
            time_ms = int(line.split('=')[1])
            current_time = time_ms / 1000000
            progress = min((current_time / total_duration) * 100, 100)
            
            await websocket.send_json({
                'progress': round(progress, 1),
                'current_time': round(current_time, 1),
                'total_duration': round(total_duration, 1),
                'status': 'processing'
            })
    
    process.wait()
    
    # ์™„๋ฃŒ ๋ฉ”์‹œ์ง€
    await websocket.send_json({
        'progress': 100,
        'status': 'completed',
        'output_file': output_file
    })
    
    await websocket.close()
๐Ÿ’ก WebSocket ํ™œ์šฉ: ์ด๋ ‡๊ฒŒ WebSocket์„ ์‚ฌ์šฉํ•˜๋ฉด ํด๋ผ์ด์–ธํŠธ(์›น ๋ธŒ๋ผ์šฐ์ €)์—์„œ ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋ณ€ํ™˜ ์ง„ํ–‰๋ฅ ์„ ๋ณผ ์ˆ˜ ์žˆ์–ด์š”. ์‚ฌ์šฉ์ž๊ฐ€ "์ง€๊ธˆ ๋ช‡ ํผ์„ผํŠธ ์ง„ํ–‰๋๋‚˜?" ๊ถ๊ธˆํ•ดํ•˜์ง€ ์•Š๊ณ  ํŽธํ•˜๊ฒŒ ๊ธฐ๋‹ค๋ฆด ์ˆ˜ ์žˆ์ฃ !

๐ŸŽ“ ๊ณ ๊ธ‰ ํ•„ํ„ฐ ํ™œ์šฉ๋ฒ•

FFmpeg์˜ ์ง„์งœ ํŒŒ์›Œ๋Š” ํ•„ํ„ฐ ์‹œ์Šคํ…œ์— ์žˆ์–ด์š”! ๋ณต์žกํ•œ ํ•„ํ„ฐ ์ฒด์ธ์„ ๊ตฌ์„ฑํ•˜๋ฉด ํ”„๋ฆฌ๋ฏธ์–ด ํ”„๋กœ ๋ชป์ง€์•Š์€ ํŽธ์ง‘์ด ๊ฐ€๋Šฅํ•˜์ฃ  ใ…‹ใ…‹

๐ŸŒˆ ์ƒ‰๋ณด์ • ๋ฐ ์ƒ‰์ƒ ์กฐ์ •

# ๋ฐ๊ธฐ ์กฐ์ ˆ
ffmpeg -i input.mp4 -vf "eq=brightness=0.1" output.mp4

# ๋Œ€๋น„ ์กฐ์ ˆ
ffmpeg -i input.mp4 -vf "eq=contrast=1.5" output.mp4

# ์ฑ„๋„ ์กฐ์ ˆ
ffmpeg -i input.mp4 -vf "eq=saturation=1.3" output.mp4

# ์ข…ํ•ฉ ์ƒ‰๋ณด์ •
ffmpeg -i input.mp4 -vf "eq=brightness=0.05:contrast=1.2:saturation=1.1" output.mp4

# ์ƒ‰์˜จ๋„ ์กฐ์ ˆ (๋”ฐ๋œปํ•˜๊ฒŒ)
ffmpeg -i input.mp4 -vf "colortemperature=5500" output.mp4

# ํ‘๋ฐฑ ๋ณ€ํ™˜
ffmpeg -i input.mp4 -vf "hue=s=0" output.mp4

# ์„ธํ”ผ์•„ ํ†ค
ffmpeg -i input.mp4 -vf "colorchannelmixer=.393:.769:.189:0:.349:.686:.168:0:.272:.534:.131" output.mp4

๐ŸŽฌ ์‹œ๋„ค๋งˆํ‹ฑ ํšจ๊ณผ

# ๋ ˆํ„ฐ๋ฐ•์Šค (์‹œ๋„ค๋งˆ์Šค์ฝ”ํ”„ ๋น„์œจ)
ffmpeg -i input.mp4 -vf "pad=iw:ih*1.2:(ow-iw)/2:(oh-ih)/2:black" output.mp4

# ๋น„๋„คํŒ… ํšจ๊ณผ (๊ฐ€์žฅ์ž๋ฆฌ ์–ด๋‘ก๊ฒŒ)
ffmpeg -i input.mp4 -vf "vignette=PI/4" output.mp4

# ํ•„๋ฆ„ ๊ทธ๋ ˆ์ธ ํšจ๊ณผ
ffmpeg -i input.mp4 -vf "noise=alls=20:allf=t+u" output.mp4

# ๋ชจ์…˜ ๋ธ”๋Ÿฌ
ffmpeg -i input.mp4 -vf "minterpolate='mi_mode=mci:mc_mode=aobmc:vsbmc=1:fps=60'" output.mp4

๐Ÿ“ ํฌ๋กญ ๋ฐ ํŒจ๋”ฉ

# ์ค‘์•™ ํฌ๋กญ (์ •์‚ฌ๊ฐํ˜•)
ffmpeg -i input.mp4 -vf "crop=ih:ih" output.mp4

# ํŠน์ • ์˜์—ญ ํฌ๋กญ
ffmpeg -i input.mp4 -vf "crop=1280:720:0:0" output.mp4
# ํ˜•์‹: crop=width:height:x:y

# ์ž๋™ ํฌ๋กญ (๊ฒ€์€ ์—ฌ๋ฐฑ ์ œ๊ฑฐ)
ffmpeg -i input.mp4 -vf "cropdetect=24:16:0" -f null -
# ์œ„ ๋ช…๋ น์–ด๋กœ ํฌ๋กญ ๊ฐ’ ํ™•์ธ ํ›„ ์ ์šฉ

# ํŒจ๋”ฉ ์ถ”๊ฐ€ (16:9๋ฅผ 4:3์œผ๋กœ)
ffmpeg -i input.mp4 -vf "pad=ih*4/3:ih:(ow-iw)/2:0:black" output.mp4

๐Ÿ”„ ํšŒ์ „ ๋ฐ ๋’ค์ง‘๊ธฐ

# 90๋„ ์‹œ๊ณ„๋ฐฉํ–ฅ ํšŒ์ „
ffmpeg -i input.mp4 -vf "transpose=1" output.mp4

# 90๋„ ๋ฐ˜์‹œ๊ณ„๋ฐฉํ–ฅ ํšŒ์ „
ffmpeg -i input.mp4 -vf "transpose=2" output.mp4

# 180๋„ ํšŒ์ „
ffmpeg -i input.mp4 -vf "transpose=2,transpose=2" output.mp4

# ์ขŒ์šฐ ๋ฐ˜์ „
ffmpeg -i input.mp4 -vf "hflip" output.mp4

# ์ƒํ•˜ ๋ฐ˜์ „
ffmpeg -i input.mp4 -vf "vflip" output.mp4

# ๋ฉ”ํƒ€๋ฐ์ดํ„ฐ ๊ธฐ๋ฐ˜ ์ž๋™ ํšŒ์ „
ffmpeg -i input.mp4 -vf "transpose=2" -metadata:s:v rotate=0 output.mp4

โšก ์†๋„ ์กฐ์ ˆ (์Šฌ๋กœ์šฐ/ํƒ€์ž„๋žฉ์Šค)

# 2๋ฐฐ์† (ํƒ€์ž„๋žฉ์Šค)
ffmpeg -i input.mp4 -filter:v "setpts=0.5*PTS" -filter:a "atempo=2.0" output.mp4

# 0.5๋ฐฐ์† (์Šฌ๋กœ์šฐ ๋ชจ์…˜)
ffmpeg -i input.mp4 -filter:v "setpts=2.0*PTS" -filter:a "atempo=0.5" output.mp4

# 4๋ฐฐ์† (์˜ค๋””์˜ค ์ œ๊ฑฐ)
ffmpeg -i input.mp4 -filter:v "setpts=0.25*PTS" -an output.mp4

# ๋ถ€๋“œ๋Ÿฌ์šด ์Šฌ๋กœ์šฐ ๋ชจ์…˜ (ํ”„๋ ˆ์ž„ ๋ณด๊ฐ„)
ffmpeg -i input.mp4 -filter:v "minterpolate='mi_mode=mci:mc_mode=aobmc:vsbmc=1:fps=120',setpts=4*PTS" output.mp4
โš ๏ธ ์†๋„ ์กฐ์ ˆ ์ฃผ์˜: ์˜ค๋””์˜ค ์†๋„๋Š” atempo ํ•„ํ„ฐ๋กœ ์กฐ์ ˆํ•˜๋Š”๋ฐ, 0.5~2.0 ๋ฒ”์œ„๋งŒ ์ง€์›ํ•ด์š”. ๊ทธ ์ด์ƒ/์ดํ•˜๋Š” ์—ฌ๋Ÿฌ ๋ฒˆ ์ฒด์ธ์œผ๋กœ ์—ฐ๊ฒฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ: 4๋ฐฐ์†์€ atempo=2.0,atempo=2.0

๐ŸŽจ ๋ณตํ•ฉ ํ•„ํ„ฐ ์ฒด์ธ

# ์—ฌ๋Ÿฌ ํšจ๊ณผ ๋™์‹œ ์ ์šฉ
ffmpeg -i input.mp4 -vf "scale=1920:1080,eq=brightness=0.05:contrast=1.2,unsharp=5:5:1.0:5:5:0.0" output.mp4

# ์›Œํ„ฐ๋งˆํฌ + ํ…์ŠคํŠธ + ํŽ˜์ด๋“œ
ffmpeg -i input.mp4 -i logo.png -filter_complex \
"[0:v]fade=t=in:st=0:d=2,fade=t=out:st=28:d=2[v1]; \
[v1]drawtext=text='Sample Video':fontsize=48:fontcolor=white:x=(w-text_w)/2:y=h-100[v2]; \
[v2][1:v]overlay=W-w-10:10[outv]" \
-map "[outv]" -map 0:a output.mp4

# PIP (Picture in Picture) ํšจ๊ณผ
ffmpeg -i main.mp4 -i pip.mp4 -filter_complex \
"[1:v]scale=320:240[pip]; \
[0:v][pip]overlay=W-w-10:H-h-10" \
output.mp4

๐ŸŽฏ ์‹ค์ „ ํ”„๋กœ์ ํŠธ ์˜ˆ์ œ

์ด์ œ ๋ฐฐ์šด ๊ฑธ ์ข…ํ•ฉํ•ด์„œ ์‹ค์ œ๋กœ ์“ธ ์ˆ˜ ์žˆ๋Š” ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ณผ๊ฒŒ์š”! ์™„์ „ ์‹ค์šฉ์ ์ธ ์˜ˆ์ œ๋“ค์ด์—์š” ใ…‹ใ…‹

๐Ÿ“บ ์œ ํŠœ๋ธŒ ์ž๋™ ์—…๋กœ๋“œ ์‹œ์Šคํ…œ

import subprocess
from pathlib import Path
import json

class YouTubeVideoProcessor:
    def __init__(self, intro_path, outro_path, watermark_path):
        self.intro_path = intro_path
        self.outro_path = outro_path
        self.watermark_path = watermark_path
    
    def process_for_youtube(self, input_video, output_video, title_text):
        """
        ์œ ํŠœ๋ธŒ ์—…๋กœ๋“œ์šฉ ์˜์ƒ ์ž๋™ ์ฒ˜๋ฆฌ
        - ์ธํŠธ๋กœ/์•„์›ƒํŠธ๋กœ ์ถ”๊ฐ€
        - ์›Œํ„ฐ๋งˆํฌ ์‚ฝ์ž…
        - ํƒ€์ดํ‹€ ํ…์ŠคํŠธ ์˜ค๋ฒ„๋ ˆ์ด
        - ์œ ํŠœ๋ธŒ ์ตœ์ ํ™” ์ธ์ฝ”๋”ฉ
        """
        # 1๋‹จ๊ณ„: ํŒŒ์ผ ๋ฆฌ์ŠคํŠธ ์ƒ์„ฑ
        filelist_path = 'temp_filelist.txt'
        with open(filelist_path, 'w') as f:
            f.write(f"file '{self.intro_path}'\n")
            f.write(f"file '{input_video}'\n")
            f.write(f"file '{self.outro_path}'\n")
        
        # 2๋‹จ๊ณ„: ์˜์ƒ ํ•ฉ์น˜๊ธฐ + ํ•„ํ„ฐ ์ ์šฉ
        filter_complex = (
            f"[1:v]drawtext=text='{title_text}':"
            f"fontsize=72:fontcolor=white:x=(w-text_w)/2:y=100:"
            f"shadowcolor=black:shadowx=2:shadowy=2[titled];"
            f"[titled][2:v]overlay=W-w-20:20:format=auto[outv]"
        )
        
        cmd = [
            'ffmpeg',
            '-f', 'concat',
            '-safe', '0',
            '-i', filelist_path,
            '-i', self.watermark_path,
            '-filter_complex', filter_complex,
            '-map', '[outv]',
            '-map', '0:a',
            '-c:v', 'libx264',
            '-preset', 'slow',
            '-crf', '18',
            '-c:a', 'aac',
            '-b:a', '192k',
            '-pix_fmt', 'yuv420p',
            '-movflags', '+faststart',  # ์›น ์ŠคํŠธ๋ฆฌ๋ฐ ์ตœ์ ํ™”
            '-y',
            output_video
        ]
        
        try:
            subprocess.run(cmd, check=True, capture_output=True)
            print(f"โœ… ์œ ํŠœ๋ธŒ์šฉ ์˜์ƒ ์ฒ˜๋ฆฌ ์™„๋ฃŒ: {output_video}")
            
            # ์ž„์‹œ ํŒŒ์ผ ์‚ญ์ œ
            Path(filelist_path).unlink()
            
            return True
        except Exception as e:
            print(f"โŒ ์ฒ˜๋ฆฌ ์‹คํŒจ: {e}")
            return False
    
    def create_thumbnail(self, video_path, output_path, timestamp='00:00:05'):
        """
        ์œ ํŠœ๋ธŒ ์ธ๋„ค์ผ ์ƒ์„ฑ (1280x720)
        """
        cmd = [
            'ffmpeg',
            '-ss', timestamp,
            '-i', video_path,
            '-vf', 'scale=1280:720',
            '-vframes', '1',
            '-q:v', '2',
            '-y',
            output_path
        ]
        
        subprocess.run(cmd, check=True, capture_output=True)
        print(f"โœ… ์ธ๋„ค์ผ ์ƒ์„ฑ: {output_path}")

# ์‚ฌ์šฉ ์˜ˆ์‹œ
processor = YouTubeVideoProcessor(
    intro_path='intro.mp4',
    outro_path='outro.mp4',
    watermark_path='logo.png'
)

processor.process_for_youtube(
    input_video='main_content.mp4',
    output_video='youtube_ready.mp4',
    title_text='FFmpeg ์™„์ „์ •๋ณต ๊ฐ€์ด๋“œ'
)

processor.create_thumbnail('youtube_ready.mp4', 'thumbnail.jpg')

๐Ÿ“ฑ ์†Œ์…œ ๋ฏธ๋””์–ด ๋ฉ€ํ‹ฐ ํฌ๋งท ์ƒ์„ฑ๊ธฐ

class SocialMediaConverter:
    """
    ํ•˜๋‚˜์˜ ์˜์ƒ์„ ์—ฌ๋Ÿฌ ์†Œ์…œ ๋ฏธ๋””์–ด ํ”Œ๋žซํผ์šฉ์œผ๋กœ ์ž๋™ ๋ณ€ํ™˜
    """
    
    PLATFORM_SPECS = {
        'youtube': {
            'resolution': '1920:1080',
            'aspect': '16:9',
            'max_duration': None,
            'format': 'mp4'
        },
        'instagram_feed': {
            'resolution': '1080:1080',
            'aspect': '1:1',
            'max_duration': 60,
            'format': 'mp4'
        },
        'instagram_story': {
            'resolution': '1080:1920',
            'aspect': '9:16',
            'max_duration': 15,
            'format': 'mp4'
        },
        'tiktok': {
            'resolution': '1080:1920',
            'aspect': '9:16',
            'max_duration': 60,
            'format': 'mp4'
        },
        'twitter': {
            'resolution': '1280:720',
            'aspect': '16:9',
            'max_duration': 140,
            'format': 'mp4'
        }
    }
    
    def convert_for_platform(self, input_video, platform, output_dir='./social_media'):
        """
        ํŠน์ • ํ”Œ๋žซํผ์šฉ์œผ๋กœ ์˜์ƒ ๋ณ€ํ™˜
        """
        if platform not in self.PLATFORM_SPECS:
            raise ValueError(f"์ง€์›ํ•˜์ง€ ์•Š๋Š” ํ”Œ๋žซํผ: {platform}")
        
        spec = self.PLATFORM_SPECS[platform]
        Path(output_dir).mkdir(parents=True, exist_ok=True)
        
        output_filename = f"{Path(input_video).stem}_{platform}.{spec['format']}"
        output_path = Path(output_dir) / output_filename
        
        # ๋น„๋””์˜ค ํ•„ํ„ฐ ๊ตฌ์„ฑ
        vf_filters = []
        
        # ํ•ด์ƒ๋„ ๋ฐ ์ข…ํšก๋น„ ์กฐ์ •
        if spec['aspect'] == '1:1':
            # ์ •์‚ฌ๊ฐํ˜•: ํฌ๋กญ ํ›„ ์Šค์ผ€์ผ
            vf_filters.append(f"crop=min(iw\\,ih):min(iw\\,ih),scale={spec['resolution']}")
        elif spec['aspect'] == '9:16':
            # ์„ธ๋กœํ˜•: ํฌ๋กญ ํ›„ ์Šค์ผ€์ผ
            vf_filters.append(f"crop=ih*9/16:ih,scale={spec['resolution']}")
        else:
            # ๊ธฐ๋ณธ: ์Šค์ผ€์ผ๋งŒ
            vf_filters.append(f"scale={spec['resolution']}")
        
        # ํŒจ๋”ฉ ์ถ”๊ฐ€ (ํ•„์š”์‹œ)
        vf_filters.append("pad=ceil(iw/2)*2:ceil(ih/2)*2")
        
        vf_string = ','.join(vf_filters)
        
        # FFmpeg ๋ช…๋ น์–ด ๊ตฌ์„ฑ
        cmd = [
            'ffmpeg',
            '-i', input_video,
            '-vf', vf_string,
            '-c:v', 'libx264',
            '-preset', 'medium',
            '-crf', '23',
            '-c:a', 'aac',
            '-b:a', '128k',
            '-movflags', '+faststart',
            '-y'
        ]
        
        # ์ตœ๋Œ€ ๊ธธ์ด ์ œํ•œ
        if spec['max_duration']:
            cmd.extend(['-t', str(spec['max_duration'])])
        
        cmd.append(str(output_path))
        
        try:
            subprocess.run(cmd, check=True, capture_output=True)
            print(f"โœ… {platform}์šฉ ๋ณ€ํ™˜ ์™„๋ฃŒ: {output_path}")
            return str(output_path)
        except Exception as e:
            print(f"โŒ {platform} ๋ณ€ํ™˜ ์‹คํŒจ: {e}")
            return None
    
    def convert_all_platforms(self, input_video, output_dir='./social_media'):
        """
        ๋ชจ๋“  ํ”Œ๋žซํผ์šฉ์œผ๋กœ ์ผ๊ด„ ๋ณ€ํ™˜
        """
        results = {}
        for platform in self.PLATFORM_SPECS.keys():
            print(f"\n๐Ÿ”„ {platform} ๋ณ€ํ™˜ ์ค‘...")
            output_path = self.convert_for_platform(input_video, platform, output_dir)
            results[platform] = output_path
        
        return results

# ์‚ฌ์šฉ ์˜ˆ์‹œ
converter = SocialMediaConverter()
results = converter.convert_all_platforms('original_video.mp4')

print("\n๐Ÿ“Š ๋ณ€ํ™˜ ๊ฒฐ๊ณผ:")
for platform, path in results.items():
    if path:
        print(f"  โœ… {platform}: {path}")
    else:
        print(f"  โŒ {platform}: ์‹คํŒจ")
๐Ÿ’ฐ ๋น„์ฆˆ๋‹ˆ์Šค ํ™œ์šฉ: ์ด๋Ÿฐ ์ž๋™ํ™” ์‹œ์Šคํ…œ์„ ๊ตฌ์ถ•ํ•˜๋ฉด ์žฌ๋Šฅ๋„ท์—์„œ "์†Œ์…œ ๋ฏธ๋””์–ด ์˜์ƒ ์ตœ์ ํ™” ์„œ๋น„์Šค"๋ฅผ ์ œ๊ณตํ•  ์ˆ˜ ์žˆ์–ด์š”! ํด๋ผ์ด์–ธํŠธ๊ฐ€ ์˜์ƒ ํ•˜๋‚˜๋งŒ ์ฃผ๋ฉด ์œ ํŠœ๋ธŒ, ์ธ์Šคํƒ€, ํ‹ฑํ†ก ๋“ฑ ๋ชจ๋“  ํ”Œ๋žซํผ์šฉ์œผ๋กœ ์ž๋™ ๋ณ€ํ™˜ํ•ด์ฃผ๋Š” ๊ฑฐ์ฃ . ์™„์ „ ๊ฟ€ํ…œ ์„œ๋น„์Šค ใ…‹ใ…‹ใ…‹

๐ŸŽฌ ์ž๋™ ํ•˜์ด๋ผ์ดํŠธ ํด๋ฆฝ ์ƒ์„ฑ๊ธฐ

import subprocess
import json
from pathlib import Path

class HighlightGenerator:
    def __init__(self, silence_threshold=-30, min_silence_duration=1.0):
        """
        silence_threshold: ๋ฌด์Œ์œผ๋กœ ๊ฐ„์ฃผํ•  dB ๋ ˆ๋ฒจ
        min_silence_duration: ์ตœ์†Œ ๋ฌด์Œ ์ง€์† ์‹œ๊ฐ„(์ดˆ)
        """
        self.silence_threshold = silence_threshold
        self.min_silence_duration = min_silence_duration
    
    def detect_silence(self, video_path):
        """
        ์˜์ƒ์—์„œ ๋ฌด์Œ ๊ตฌ๊ฐ„ ๊ฐ์ง€
        """
        cmd = [
            'ffmpeg',
            '-i', video_path,
            '-af', f'silencedetect=noise={self.silence_threshold}dB:d={self.min_silence_duration}',
            '-f', 'null',
            '-'
        ]
        
        result = subprocess.run(cmd, capture_output=True, text=True, stderr=subprocess.STDOUT)
        
        # ๋ฌด์Œ ๊ตฌ๊ฐ„ ํŒŒ์‹ฑ
        silence_periods = []
        lines = result.stdout.split('\n')
        
        silence_start = None
        for line in lines:
            if 'silence_start' in line:
                silence_start = float(line.split('silence_start: ')[1])
            elif 'silence_end' in line and silence_start is not None:
                silence_end = float(line.split('silence_end: ')[1].split('|')[0])
                silence_periods.append((silence_start, silence_end))
                silence_start = None
        
        return silence_periods
    
    def generate_highlights(self, video_path, output_dir, min_clip_duration=5):
        """
        ๋ฌด์Œ ๊ตฌ๊ฐ„์„ ๊ธฐ์ค€์œผ๋กœ ํ•˜์ด๋ผ์ดํŠธ ํด๋ฆฝ ์ƒ์„ฑ
        """
        Path(output_dir).mkdir(parents=True, exist_ok=True)
        
        # ๋ฌด์Œ ๊ตฌ๊ฐ„ ๊ฐ์ง€
        silence_periods = self.detect_silence(video_path)
        
        if not silence_periods:
            print("๋ฌด์Œ ๊ตฌ๊ฐ„์„ ์ฐพ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.")
            return []
        
        # ์˜์ƒ ์ „์ฒด ๊ธธ์ด ๊ฐ€์ ธ์˜ค๊ธฐ
        duration_cmd = [
            'ffprobe',
            '-v', 'error',
            '-show_entries', 'format=duration',
            '-of', 'default=noprint_wrappers=1:nokey=1',
            video_path
        ]
        total_duration = float(subprocess.run(duration_cmd, capture_output=True, text=True).stdout.strip())
        
        # ํ•˜์ด๋ผ์ดํŠธ ๊ตฌ๊ฐ„ ๊ณ„์‚ฐ (๋ฌด์Œ ์‚ฌ์ด์˜ ๊ตฌ๊ฐ„)
        highlights = []
        prev_end = 0
        
        for silence_start, silence_end in silence_periods:
            if silence_start - prev_end >= min_clip_duration:
                highlights.append((prev_end, silence_start))
            prev_end = silence_end
        
        # ๋งˆ์ง€๋ง‰ ๊ตฌ๊ฐ„
        if total_duration - prev_end >= min_clip_duration:
            highlights.append((prev_end, total_duration))
        
        # ํ•˜์ด๋ผ์ดํŠธ ํด๋ฆฝ ์ถ”์ถœ
        output_files = []
        for idx, (start, end) in enumerate(highlights, 1):
            duration = end - start
            output_filename = f"highlight_{idx:02d}.mp4"
            output_path = Path(output_dir) / output_filename
            
            cmd = [
                'ffmpeg',
                '-ss', str(start),
                '-i', video_path,
                '-t', str(duration),
                '-c', 'copy',
                '-y',
                str(output_path)
            ]
            
            subprocess.run(cmd, check=True, capture_output=True)
            print(f"โœ… ํ•˜์ด๋ผ์ดํŠธ {idx} ์ƒ์„ฑ: {start:.1f}s ~ {end:.1f}s ({duration:.1f}s)")
            output_files.append(str(output_path))
        
        return output_files

# ์‚ฌ์šฉ ์˜ˆ์‹œ
generator = HighlightGenerator(silence_threshold=-35, min_silence_duration=2.0)
highlights = generator.generate_highlights('long_video.mp4', './highlights')

print(f"\n๐Ÿ“Š ์ด {len(highlights)}๊ฐœ์˜ ํ•˜์ด๋ผ์ดํŠธ ํด๋ฆฝ ์ƒ์„ฑ๋จ")
๐Ÿ’ก ํ™œ์šฉ ์•„์ด๋””์–ด: ์ด ๊ธฐ๋Šฅ์€ ๊ธด ๊ฐ•์˜ ์˜์ƒ์ด๋‚˜ ํŒŸ์บ์ŠคํŠธ์—์„œ ์ž๋™์œผ๋กœ ํ•ต์‹ฌ ๋ถ€๋ถ„๋งŒ ์ถ”์ถœํ•  ๋•Œ ์œ ์šฉํ•ด์š”. ๋ฌด์Œ ๊ตฌ๊ฐ„์„ ๊ธฐ์ค€์œผ๋กœ ์ž๋ฅด๋‹ˆ๊นŒ ์ž์—ฐ์Šค๋Ÿฌ์šด ํŽธ์ง‘์ ์„ ์ฐพ์„ ์ˆ˜ ์žˆ์ฃ !

๐Ÿ› ํŠธ๋Ÿฌ๋ธ”์ŠˆํŒ… & ์ž์ฃผ ๋ฌป๋Š” ์งˆ๋ฌธ

FFmpeg ์‚ฌ์šฉํ•˜๋‹ค ๋ณด๋ฉด ์ž์ฃผ ๋งˆ์ฃผ์น˜๋Š” ๋ฌธ์ œ๋“ค์ด ์žˆ์–ด์š”. ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์„ ์ •๋ฆฌํ•ด๋ดค์Šต๋‹ˆ๋‹ค!

โŒ ์ž์ฃผ ๋ฐœ์ƒํ•˜๋Š” ์—๋Ÿฌ์™€ ํ•ด๊ฒฐ๋ฒ•

1 Error: "codec not found" ๋˜๋Š” "Unknown encoder"

์›์ธ: FFmpeg ๋นŒ๋“œ์— ํ•ด๋‹น ์ฝ”๋ฑ์ด ํฌํ•จ๋˜์ง€ ์•Š์Œ
ํ•ด๊ฒฐ: ์ „์ฒด ์ฝ”๋ฑ์ด ํฌํ•จ๋œ ๋นŒ๋“œ๋ฅผ ๋‹ค์‹œ ์„ค์น˜ํ•˜๊ฑฐ๋‚˜, ๋‹ค๋ฅธ ์ฝ”๋ฑ ์‚ฌ์šฉ
# ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•œ ์ฝ”๋ฑ ํ™•์ธ
ffmpeg -codecs

# ์‚ฌ์šฉ ๊ฐ€๋Šฅํ•œ ์ธ์ฝ”๋” ํ™•์ธ
ffmpeg -encoders

# ๋Œ€์ฒด ์ฝ”๋ฑ ์‚ฌ์šฉ ์˜ˆ์‹œ
ffmpeg -i input.mp4 -c:v libx264 output.mp4  # H.264 ๋Œ€์‹ 
2 Error: "height not divisible by 2"

์›์ธ: H.264 ์ฝ”๋ฑ์€ ๊ฐ€๋กœ/์„ธ๋กœ๊ฐ€ 2์˜ ๋ฐฐ์ˆ˜์—ฌ์•ผ ํ•จ
ํ•ด๊ฒฐ: ์Šค์ผ€์ผ ํ•„ํ„ฐ์—์„œ ์ž๋™์œผ๋กœ 2์˜ ๋ฐฐ์ˆ˜๋กœ ์กฐ์ •
# ์ž˜๋ชป๋œ ์˜ˆ
ffmpeg -i input.mp4 -vf "scale=1921:1081" output.mp4  # ํ™€์ˆ˜!

# ์˜ฌ๋ฐ”๋ฅธ ์˜ˆ
ffmpeg -i input.mp4 -vf "scale=1920:1080" output.mp4

# ์ž๋™ ์กฐ์ •
ffmpeg -i input.mp4 -vf "scale='trunc(iw/2)*2':'trunc(ih/2)*2'" output.mp4
3 Error: "Conversion failed" ๋˜๋Š” ํ’ˆ์งˆ ์ €ํ•˜

์›์ธ: ์ž˜๋ชป๋œ ์ธ์ฝ”๋”ฉ ์„ค์ • ๋˜๋Š” ๋น„ํŠธ๋ ˆ์ดํŠธ ๋ถ€์กฑ
ํ•ด๊ฒฐ: CRF ๊ฐ’ ์กฐ์ • ๋˜๋Š” ๋น„ํŠธ๋ ˆ์ดํŠธ ๋ช…์‹œ
# CRF ๋ฐฉ์‹ (๊ถŒ์žฅ)
ffmpeg -i input.mp4 -c:v libx264 -crf 18 output.mp4

# ๋น„ํŠธ๋ ˆ์ดํŠธ ๋ฐฉ์‹
ffmpeg -i input.mp4 -c:v libx264 -b:v 5M output.mp4

# 2-pass ์ธ์ฝ”๋”ฉ (์ตœ๊ณ  ํ’ˆ์งˆ)
ffmpeg -i input.mp4 -c:v libx264 -b:v 5M -pass 1 -f null /dev/null
ffmpeg -i input.mp4 -c:v libx264 -b:v 5M -pass 2 output.mp4
4 ๋ฌธ์ œ: ์ธ์ฝ”๋”ฉ ์†๋„๊ฐ€ ๋„ˆ๋ฌด ๋А๋ฆผ

ํ•ด๊ฒฐ: ํ”„๋ฆฌ์…‹ ์กฐ์ •, ํ•˜๋“œ์›จ์–ด ๊ฐ€์† ์‚ฌ์šฉ, ํ•ด์ƒ๋„ ๋‚ฎ์ถ”๊ธฐ
# ๋น ๋ฅธ ํ”„๋ฆฌ์…‹ ์‚ฌ์šฉ
ffmpeg -i input.mp4 -c:v libx264 -preset ultrafast output.mp4

# GPU ๊ฐ€์† (NVIDIA)
ffmpeg -hwaccel cuda -i input.mp4 -c:v h264_nvenc -preset fast output.mp4

# ํ•ด์ƒ๋„ ๋‚ฎ์ถ”๊ธฐ
ffmpeg -i input.mp4 -vf "scale=1280:720" -c:v libx264 -preset fast output.mp4

# ๋ฉ€ํ‹ฐ์Šค๋ ˆ๋”ฉ ํ™œ์„ฑํ™”
ffmpeg -i input.mp4 -threads 8 -c:v libx264 output.mp4
5 ๋ฌธ์ œ: ์˜ค๋””์˜ค/๋น„๋””์˜ค ์‹ฑํฌ ์•ˆ ๋งž์Œ

์›์ธ: ๊ฐ€๋ณ€ ํ”„๋ ˆ์ž„๋ ˆ์ดํŠธ(VFR) ์˜์ƒ ๋˜๋Š” ํƒ€์ž„์Šคํƒฌํ”„ ๋ฌธ์ œ
ํ•ด๊ฒฐ: ๊ณ ์ • ํ”„๋ ˆ์ž„๋ ˆ์ดํŠธ๋กœ ๋ณ€ํ™˜ ๋˜๋Š” ํƒ€์ž„์Šคํƒฌํ”„ ์žฌ์ƒ์„ฑ
# ๊ณ ์ • ํ”„๋ ˆ์ž„๋ ˆ์ดํŠธ๋กœ ๋ณ€ํ™˜
ffmpeg -i input.mp4 -r 30 -c:v libx264 output.mp4

# ํƒ€์ž„์Šคํƒฌํ”„ ์žฌ์ƒ์„ฑ
ffmpeg -i input.mp4 -c copy -fflags +genpts output.mp4

# ์˜ค๋””์˜ค ์ง€์—ฐ ๋ณด์ • (0.5์ดˆ ์ง€์—ฐ)
ffmpeg -i input.mp4 -itsoffset 0.5 -i input.mp4 -map 0:v -map 1:a -c copy output.mp4

๐Ÿ’ก ์„ฑ๋Šฅ ์ตœ์ ํ™” ํŒ

์ƒํ™ฉ ์ตœ์ ํ™” ๋ฐฉ๋ฒ• ์˜ˆ์ƒ ํšจ๊ณผ
๋Œ€๋Ÿ‰ ํŒŒ์ผ ์ฒ˜๋ฆฌ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ (GNU Parallel ์‚ฌ์šฉ) CPU ์ฝ”์–ด ์ˆ˜๋งŒํผ ์†๋„ ํ–ฅ์ƒ
์‹ค์‹œ๊ฐ„ ์ŠคํŠธ๋ฆฌ๋ฐ ultrafast ํ”„๋ฆฌ์…‹ + GPU ๊ฐ€์† ์ง€์—ฐ ์‹œ๊ฐ„ ์ตœ์†Œํ™”
์ €์žฅ ๊ณต๊ฐ„ ๋ถ€์กฑ H.265 ์ฝ”๋ฑ + CRF 28 ํŒŒ์ผ ํฌ๊ธฐ 50% ๊ฐ์†Œ
๊ณ ํ’ˆ์งˆ ์•„์นด์ด๋น™ veryslow ํ”„๋ฆฌ์…‹ + CRF 18 ์ตœ๊ณ  ํ’ˆ์งˆ ์œ ์ง€
์›น ์ŠคํŠธ๋ฆฌ๋ฐ faststart ํ”Œ๋ž˜๊ทธ + ์ ์ ˆํ•œ ๋น„ํŠธ๋ ˆ์ดํŠธ ๋น ๋ฅธ ๋กœ๋”ฉ

๐Ÿ”ง ์œ ์šฉํ•œ ๋””๋ฒ„๊น… ๋ช…๋ น์–ด

# ์˜์ƒ ์ •๋ณด ์ƒ์„ธ ์ถœ๋ ฅ
ffprobe -v error -show_format -show_streams input.mp4

# ํ”„๋ ˆ์ž„๋ณ„ ์ •๋ณด ํ™•์ธ
ffprobe -v error -show_frames input.mp4

# ํŠน์ • ์ŠคํŠธ๋ฆผ๋งŒ ๋ถ„์„
ffprobe -v error -select_streams v:0 -show_entries stream=codec_name,width,height input.mp4

# ์ธ์ฝ”๋”ฉ ์ง„ํ–‰ ์ƒํ™ฉ ์ƒ์„ธ ๋กœ๊ทธ
ffmpeg -i input.mp4 -c:v libx264 -progress - -y output.mp4

# ํ•„ํ„ฐ ๊ทธ๋ž˜ํ”„ ์‹œ๊ฐํ™” (๋ณต์žกํ•œ ํ•„ํ„ฐ ๋””๋ฒ„๊น…์šฉ)
ffmpeg -i input.mp4 -filter_complex "..." -filter_complex_script graph.txt

๐Ÿš€ ๊ณ ๊ธ‰ ํ™œ์šฉ: CI/CD ํŒŒ์ดํ”„๋ผ์ธ ํ†ตํ•ฉ

FFmpeg์„ CI/CD ํŒŒ์ดํ”„๋ผ์ธ์— ํ†ตํ•ฉํ•˜๋ฉด ์˜์ƒ ์ฒ˜๋ฆฌ๋ฅผ ์™„์ „ ์ž๋™ํ™”ํ•  ์ˆ˜ ์žˆ์–ด์š”! GitHub Actions๋‚˜ GitLab CI ๊ฐ™์€ ๋„๊ตฌ์™€ ๊ฒฐํ•ฉํ•œ ์˜ˆ์ œ๋ฅผ ๋ณด์—ฌ๋“œ๋ฆด๊ฒŒ์š” ใ…‹ใ…‹

๐Ÿ™ GitHub Actions ์›Œํฌํ”Œ๋กœ์šฐ

# .github/workflows/video-processing.yml
name: Video Processing Pipeline

on:
  push:
    paths:
      - 'videos/**'
  workflow_dispatch:

jobs:
  process-videos:
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout repository
        uses: actions/checkout@v3
      
      - name: Install FFmpeg
        run: |
          sudo apt-get update
          sudo apt-get install -y ffmpeg
      
      - name: Process videos
        run: |
          mkdir -p processed_videos
          
          for video in videos/*.mp4; do
            filename=$(basename "$video" .mp4)
            
            # 1080p ๋ฒ„์ „ ์ƒ์„ฑ
            ffmpeg -i "$video" \
              -vf "scale=1920:1080" \
              -c:v libx264 -preset medium -crf 23 \
              -c:a aac -b:a 192k \
              "processed_videos/${filename}_1080p.mp4"
            
            # 720p ๋ฒ„์ „ ์ƒ์„ฑ
            ffmpeg -i "$video" \
              -vf "scale=1280:720" \
              -c:v libx264 -preset medium -crf 23 \
              -c:a aac -b:a 128k \
              "processed_videos/${filename}_720p.mp4"
            
            # ์ธ๋„ค์ผ ์ƒ์„ฑ
            ffmpeg -i "$video" \
              -ss 00:00:05 -vframes 1 \
              -vf "scale=1280:720" \
              "processed_videos/${filename}_thumb.jpg"
          done
      
      - name: Upload processed videos
        uses: actions/upload-artifact@v3
        with:
          name: processed-videos
          path: processed_videos/
      
      - name: Deploy to S3 (optional)
        if: github.ref == 'refs/heads/main'
        env:
          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        run: |
          aws s3 sync processed_videos/ s3://my-bucket/videos/ --acl public-read

๐Ÿณ Docker ์ปจํ…Œ์ด๋„ˆํ™”

# Dockerfile
FROM jrottenberg/ffmpeg:4.4-alpine

# Python ์„ค์น˜ (์Šคํฌ๋ฆฝํŠธ ์‹คํ–‰์šฉ)
RUN apk add --no-cache python3 py3-pip

# ์ž‘์—… ๋””๋ ‰ํ† ๋ฆฌ ์„ค์ •
WORKDIR /app

# ์˜์กด์„ฑ ์„ค์น˜
COPY requirements.txt .
RUN pip3 install -r requirements.txt

# ์Šคํฌ๋ฆฝํŠธ ๋ณต์‚ฌ
COPY video_processor.py .

# ๋ณผ๋ฅจ ๋งˆ์šดํŠธ ํฌ์ธํŠธ
VOLUME ["/input", "/output"]

# ์‹คํ–‰ ๋ช…๋ น
ENTRYPOINT ["python3", "video_processor.py"]
# docker-compose.yml
version: '3.8'

services:
  video-processor:
    build: .
    volumes:
      - ./input_videos:/input
      - ./output_videos:/output
    environment:
      - PRESET=medium
      - CRF=23
      - OUTPUT_FORMAT=mp4
    command: --input /input --output /output
๐ŸŽฏ ์‹ค์ „ ํ™œ์šฉ: Docker ์ปจํ…Œ์ด๋„ˆ๋กœ ๋งŒ๋“ค๋ฉด ์–ด๋–ค ํ™˜๊ฒฝ์—์„œ๋“  ๋™์ผํ•˜๊ฒŒ ์ž‘๋™ํ•˜๋Š” ์˜์ƒ ์ฒ˜๋ฆฌ ์‹œ์Šคํ…œ์„ ๊ตฌ์ถ•ํ•  ์ˆ˜ ์žˆ์–ด์š”. AWS ECS๋‚˜ Kubernetes์— ๋ฐฐํฌํ•ด์„œ ๋Œ€๊ทœ๋ชจ ์˜์ƒ ์ฒ˜๋ฆฌ ์„œ๋น„์Šค๋ฅผ ์šด์˜ํ•  ์ˆ˜๋„ ์žˆ์ฃ !

โš™๏ธ ํ ์‹œ์Šคํ…œ๊ณผ ํ†ตํ•ฉ (Celery + Redis)

# tasks.py
from celery import Celery
import subprocess
from pathlib import Path

app = Celery('video_tasks', broker='redis://localhost:6379/0')

@app.task(bind=True)
def convert_video(self, input_path, output_path, options=None):
    """
    ๋น„๋™๊ธฐ ์˜์ƒ ๋ณ€ํ™˜ ์ž‘์—…
    """
    options = options or {}
    
    cmd = [
        'ffmpeg',
        '-i', input_path,
        '-c:v', options.get('video_codec', 'libx264'),
        '-preset', options.get('preset', 'medium'),
        '-crf', str(options.get('crf', 23)),
        '-c:a', options.get('audio_codec', 'aac'),
        '-b:a', options.get('audio_bitrate', '192k'),
        '-progress', 'pipe:1',
        '-y',
        output_path
    ]
    
    process = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        universal_newlines=True
    )
    
    # ์ง„ํ–‰๋ฅ  ์—…๋ฐ์ดํŠธ
    for line in process.stdout:
        if line.startswith('out_time_ms='):
            time_ms = int(line.split('=')[1])
            # Celery ํƒœ์Šคํฌ ์ƒํƒœ ์—…๋ฐ์ดํŠธ
            self.update_state(
                state='PROGRESS',
                meta={'current': time_ms, 'status': 'Converting...'}
            )
    
    process.wait()
    
    if process.returncode == 0:
        return {'status': 'completed', 'output': output_path}
    else:
        raise Exception(f"FFmpeg failed with code {process.returncode}")

# ์›Œ์ปค ์‹คํ–‰: celery -A tasks worker --loglevel=info
# api.py (FastAPI์™€ ํ†ตํ•ฉ)
from fastapi import FastAPI, UploadFile, BackgroundTasks
from tasks import convert_video
import uuid

app = FastAPI()

@app.post("/convert/")
async def queue_conversion(file: UploadFile):
    """
    ์˜์ƒ ๋ณ€ํ™˜ ์ž‘์—…์„ ํ์— ์ถ”๊ฐ€
    """
    task_id = str(uuid.uuid4())
    input_path = f"/tmp/{task_id}_{file.filename}"
    output_path = f"/tmp/{task_id}_output.mp4"
    
    # ํŒŒ์ผ ์ €์žฅ
    with open(input_path, "wb") as f:
        content = await file.read()
        f.write(content)
    
    # Celery ํƒœ์Šคํฌ ์‹คํ–‰
    task = convert_video.delay(input_path, output_path)
    
    return {
        "task_id": task.id,
        "status": "queued",
        "check_url": f"/status/{task.id}"
    }

@app.get("/status/{task_id}")
async def check_status(task_id: str):
    """
    ์ž‘์—… ์ง„ํ–‰ ์ƒํ™ฉ ํ™•์ธ
    """
    task = convert_video.AsyncResult(task_id)
    
    if task.state == 'PENDING':
        response = {'state': task.state, 'status': 'Pending...'}
    elif task.state == 'PROGRESS':
        response = {
            'state': task.state,
            'current': task.info.get('current', 0),
            'status': task.info.get('status', '')
        }
    elif task.state == 'SUCCESS':
        response = {
            'state': task.state,
            'result': task.result
        }
    else:
        response = {'state': task.state, 'status': str(task.info)}
    
    return response
๐Ÿ’ก ํ™•์žฅ์„ฑ ํŒ: Celery + Redis ์กฐํ•ฉ์€ ๋Œ€๊ทœ๋ชจ ์˜์ƒ ์ฒ˜๋ฆฌ์— ์™„์ „ ์ตœ์ ํ™”๋˜์–ด ์žˆ์–ด์š”. ์—ฌ๋Ÿฌ ์›Œ์ปค๋ฅผ ๋„์›Œ์„œ ๋™์‹œ์— ์ˆ˜์‹ญ~์ˆ˜๋ฐฑ ๊ฐœ์˜ ์˜์ƒ์„ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์ฃ . ์žฌ๋Šฅ๋„ท์—์„œ ์˜์ƒ ํŽธ์ง‘ ์„œ๋น„์Šค๋ฅผ ๋Œ€๊ทœ๋ชจ๋กœ ์šด์˜ํ•  ๋•Œ ์ด๋Ÿฐ ์•„ํ‚คํ…์ฒ˜๊ฐ€ ํ•„์ˆ˜์˜ˆ์š”!

๐Ÿ“š ์ถ”๊ฐ€ ํ•™์Šต ๋ฆฌ์†Œ์Šค & ์ปค๋ฎค๋‹ˆํ‹ฐ

FFmpeg์€ ์ •๋ง ๋ฐฉ๋Œ€ํ•œ ๋„๊ตฌ๋ผ์„œ ๊ณ„์† ๋ฐฐ์šธ ๊ฒŒ ๋งŽ์•„์š”. ์œ ์šฉํ•œ ๋ฆฌ์†Œ์Šค๋“ค์„ ์ •๋ฆฌํ•ด๋ดค์Šต๋‹ˆ๋‹ค!

๐Ÿ“– ๊ณต์‹ ๋ฌธ์„œ ๋ฐ ๋ ˆํผ๋Ÿฐ์Šค

1 FFmpeg ๊ณต์‹ ๋ฌธ์„œ
https://ffmpeg.org/documentation.html
๊ฐ€์žฅ ์ •ํ™•ํ•˜๊ณ  ์ƒ์„ธํ•œ ์ •๋ณด. ๋ชจ๋“  ์˜ต์…˜๊ณผ ํ•„ํ„ฐ ์„ค๋ช…์ด ์žˆ์–ด์š”.
2 FFmpeg Wiki
https://trac.ffmpeg.org/wiki
์‹ค์šฉ์ ์ธ ์˜ˆ์ œ์™€ ๊ฐ€์ด๋“œ๊ฐ€ ๋งŽ์•„์š”. ํŠนํžˆ ์ธ์ฝ”๋”ฉ ๊ฐ€์ด๋“œ ์„น์…˜ ์ถ”์ฒœ!
3 Stack Overflow
'ffmpeg' ํƒœ๊ทธ๋กœ ๊ฒ€์ƒ‰ํ•˜๋ฉด ๊ฑฐ์˜ ๋ชจ๋“  ๋ฌธ์ œ์˜ ํ•ด๋‹ต์„ ์ฐพ์„ ์ˆ˜ ์žˆ์–ด์š” ใ…‹ใ…‹

๐ŸŽ“ ํ•™์Šต ํŒ

1. ์ž‘์€ ํ…Œ์ŠคํŠธ ํŒŒ์ผ๋กœ ์‹œ์ž‘ํ•˜๊ธฐ ํฐ ์˜์ƒ์œผ๋กœ ํ…Œ์ŠคํŠธํ•˜๋ฉด ์‹œ๊ฐ„ ๋‚ญ๋น„์˜ˆ์š”. 10์ดˆ์งœ๋ฆฌ ์ƒ˜ํ”Œ ์˜์ƒ์œผ๋กœ ๋ช…๋ น์–ด๋ฅผ ๋จผ์ € ํ…Œ์ŠคํŠธํ•˜์„ธ์š”!
2. ๋กœ๊ทธ ์ฝ๋Š” ๋ฒ• ์ตํžˆ๊ธฐ FFmpeg์˜ ์ถœ๋ ฅ ๋กœ๊ทธ๋ฅผ ์ดํ•ดํ•˜๋ฉด ๋ฌธ์ œ ํ•ด๊ฒฐ์ด ํ›จ์”ฌ ์‰ฌ์›Œ์ ธ์š”. ํŠนํžˆ ์—๋Ÿฌ ๋ฉ”์‹œ์ง€๋ฅผ ์ฃผ์˜๊นŠ๊ฒŒ ์ฝ์œผ์„ธ์š”.
3. ํ•„ํ„ฐ ์ฒด์ธ ๋‹จ๊ณ„๋ณ„๋กœ ํ…Œ์ŠคํŠธ ๋ณต์žกํ•œ ํ•„ํ„ฐ๋Š” ํ•œ ๋ฒˆ์— ๋งŒ๋“ค์ง€ ๋ง๊ณ , ํ•˜๋‚˜์”ฉ ์ถ”๊ฐ€ํ•˜๋ฉด์„œ ๊ฒฐ๊ณผ๋ฅผ ํ™•์ธํ•˜์„ธ์š”.
4. ์Šคํฌ๋ฆฝํŠธ๋กœ ์ž๋™ํ™” ์ž์ฃผ ์“ฐ๋Š” ๋ช…๋ น์–ด๋Š” ์Šคํฌ๋ฆฝํŠธ๋กœ ๋งŒ๋“ค์–ด๋‘๋ฉด ์‹œ๊ฐ„ ์ ˆ์•ฝ + ์‹ค์ˆ˜ ๋ฐฉ์ง€!

๐Ÿ’ผ ์‹ค๋ฌด ํ™œ์šฉ ์‹œ๋‚˜๋ฆฌ์˜ค

์—…์ข…/๋ถ„์•ผ ํ™œ์šฉ ์‚ฌ๋ก€ ํ•ต์‹ฌ ๊ธฐ๋Šฅ
์œ ํŠœ๋ฒ„/ํฌ๋ฆฌ์—์ดํ„ฐ ์˜์ƒ ์ž๋™ ํŽธ์ง‘ ๋ฐ ์—…๋กœ๋“œ ์ธํŠธ๋กœ/์•„์›ƒํŠธ๋กœ ์ถ”๊ฐ€, ์›Œํ„ฐ๋งˆํฌ, ์ธ๋„ค์ผ ์ƒ์„ฑ
๊ต์œก ํ”Œ๋žซํผ ๊ฐ•์˜ ์˜์ƒ ์ž๋™ ์ฒ˜๋ฆฌ ํ™”์งˆ๋ณ„ ๋‹ค์ค‘ ๋ฒ„์ „, ์ž๋ง‰ ์‚ฝ์ž…, ์ฑ•ํ„ฐ ๋ถ„ํ• 
OTT/์ŠคํŠธ๋ฆฌ๋ฐ ์ ์‘ํ˜• ์ŠคํŠธ๋ฆฌ๋ฐ ์ƒ์„ฑ HLS/DASH ๋ณ€ํ™˜, ๋‹ค์ค‘ ๋น„ํŠธ๋ ˆ์ดํŠธ
์†Œ์…œ ๋ฏธ๋””์–ด ์—์ด์ „์‹œ ํ”Œ๋žซํผ๋ณ„ ์ตœ์ ํ™” ์ข…ํšก๋น„ ๋ณ€ํ™˜, ๊ธธ์ด ์กฐ์ ˆ, ํฌ๋งท ๋ณ€ํ™˜
๋ณด์•ˆ/๊ฐ์‹œ CCTV ์˜์ƒ ์••์ถ• ๋ฐ ๋ณด๊ด€ ํƒ€์ž„๋žฉ์Šค, ์ €์šฉ๋Ÿ‰ ์ธ์ฝ”๋”ฉ, ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ

๐ŸŽ‰ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€... ์—ฌ๊ธฐ๊นŒ์ง€ ์ฝ์œผ์…จ๋‹ค๋ฉด ์ง„์งœ ๋Œ€๋‹จํ•˜์„ธ์š”! ใ…‹ใ…‹ใ…‹ FFmpeg์€ ์ฒ˜์Œ์—” ์ข€ ์–ด๋ ต๊ฒŒ ๋А๊ปด์งˆ ์ˆ˜ ์žˆ์ง€๋งŒ, ์ต์ˆ™ํ•ด์ง€๋ฉด ์ •๋ง ๊ฐ•๋ ฅํ•œ ๋„๊ตฌ์˜ˆ์š”. ์˜์ƒ ํŽธ์ง‘ ํ”„๋กœ๊ทธ๋žจ ์—†์ด๋„ ๋ช…๋ น์–ด ๋ช‡ ์ค„๋กœ ํ”„๋กœํŽ˜์…”๋„ํ•œ ๊ฒฐ๊ณผ๋ฌผ์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ๊ฑฐ๋“ ์š”. ๐Ÿš€

ํŠนํžˆ ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ ๊ฒฐํ•ฉํ•˜๋ฉด ์™„์ „ ์ž๋™ํ™”๋œ ์˜์ƒ ์ฒ˜๋ฆฌ ์‹œ์Šคํ…œ์„ ๊ตฌ์ถ•ํ•  ์ˆ˜ ์žˆ์–ด์„œ, ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์˜์ƒ ๊ด€๋ จ ์„œ๋น„์Šค๋ฅผ ์ œ๊ณตํ•˜๋Š” ๋ถ„๋“คํ•œํ…Œ๋Š” ํ•„์ˆ˜ ์Šคํ‚ฌ์ด๋ผ๊ณ  ํ•  ์ˆ˜ ์žˆ์ฃ !

์ด ๊ฐ€์ด๋“œ์—์„œ ๋‹ค๋ฃฌ ๋‚ด์šฉ๋“ค์„ ์‹ค์ œ๋กœ ํ•˜๋‚˜์”ฉ ๋”ฐ๋ผํ•ด๋ณด๋ฉด์„œ ์ž์‹ ๋งŒ์˜ ์ž๋™ํ™” ์‹œ์Šคํ…œ์„ ๋งŒ๋“ค์–ด๋ณด์„ธ์š”. ์ฒ˜์Œ์—” ์—๋Ÿฌ๋„ ๋งŽ์ด ๋‚˜๊ณ  ํ—ค๋งฌ ์ˆ˜ ์žˆ์ง€๋งŒ, ๊ทธ๊ฒŒ ๋‹ค ๋ฐฐ์šฐ๋Š” ๊ณผ์ •์ด์—์š” ใ…‹ใ…‹

ํ˜น์‹œ FFmpeg ๊ด€๋ จํ•ด์„œ ๋” ๊ถ๊ธˆํ•œ ์ ์ด ์žˆ๊ฑฐ๋‚˜, ํŠน์ • ํ”„๋กœ์ ํŠธ์— ์ ์šฉํ•˜๊ณ  ์‹ถ์€๋ฐ ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„์ด ์žˆ๋‹ค๋ฉด ์žฌ๋Šฅ๋„ท ์ปค๋ฎค๋‹ˆํ‹ฐ์—์„œ ์งˆ๋ฌธํ•ด๋ณด์„ธ์š”! ๋งŽ์€ ์ „๋ฌธ๊ฐ€๋“ค์ด ๋„์›€์„ ์ค„ ๊ฑฐ์˜ˆ์š”. ๐Ÿ˜Š

๊ทธ๋Ÿผ ์—ฌ๋Ÿฌ๋ถ„์˜ ์˜์ƒ ์ž๋™ํ™” ํ”„๋กœ์ ํŠธ๊ฐ€ ์„ฑ๊ณต์ ์ด๊ธธ ๋ฐ”๋ผ๋ฉฐ, ์ด๋งŒ ๋งˆ์น˜๊ฒ ์Šต๋‹ˆ๋‹ค! ํ™”์ดํŒ…! ๐Ÿ’ชโœจ

๐ŸŒŸ ์ด ๊ธ€์ด ๋„์›€์ด ๋˜์…จ๋‚˜์š”? ์žฌ๋Šฅ๋„ท์—์„œ ๋” ๋งŽ์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์ง€์‹๊ณผ ์‹ค์ „ ๋…ธํ•˜์šฐ๋ฅผ ๋งŒ๋‚˜๋ณด์„ธ์š”!
์—ฌ๋Ÿฌ๋ถ„์˜ ์žฌ๋Šฅ์„ ๊ณต์œ ํ•˜๊ณ , ๋‹ค๋ฅธ ์ „๋ฌธ๊ฐ€๋“ค๊ณผ ๊ต๋ฅ˜ํ•  ์ˆ˜ ์žˆ๋Š” ๊ณต๊ฐ„์ž…๋‹ˆ๋‹ค. ๐ŸŽฏ
๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.