[2026] Opus 오디오 코덱 차세대 표준 | WebRTC·저지연·FFmpeg 실전 가이드

· 32분 읽기 · 수정 중급 가이드
[2026] Opus 오디오 코덱 차세대 표준 | WebRTC·저지연·FFmpeg 실전 가이드

이 글의 핵심

IETF 표준 Opus의 음성·음악 모드, SILK·CELT 하이브리드, 저지연 실시간 통신과 FFmpeg 인코딩. 로열티 프리로 배포하기 좋은 차세대 오디오 코덱을 정리합니다.

들어가며

Opus는 IETF RFC 6716 으로 표준화된 오디오 코덱으로, 음성(SILK 계열) 과 음악(CELT 계열) 을 하나의 코덱에서 다루도록 설계되었습니다. 6~510 kbps 같은 넓은 비트레이트 범위와 프레임 길이 조절 덕분에 실시간 화상·음성·게임 보이스처럼 지연 예산(ms) 이 빡빡한 환경에서 강합니다.

이 글을 읽으면

  • Opus의 역사(Speex·CELT 통합)·하이브리드 구조를 개략적으로 이해합니다
  • 음성·음악·저지연 시나리오에서 비트레이트·프레임 길이를 고르는 기준을 잡습니다
  • FFmpeg로 Opus(Ogg/WEBM) 인코딩과 품질 튜닝을 적용할 수 있습니다
  • WebRTC·브라우저·VoIP 실무에서의 위치와 AAC/MP3와의 차이를 설명할 수 있습니다

목차

  1. 코덱 개요
  2. 압축 원리
  3. 실전 인코딩
  4. 성능 비교
  5. 실무 활용 사례
  6. 최적화 팁
  7. 트러블슈팅
  8. 마무리

코덱 개요

역사 및 개발 배경

Opus는 Xiph.org 가 주도한 CELT 와 Skype가 발전시킨 SILK 를 결합한 하이브리드 코덱으로, IETF codec working group에서 표준화되었습니다. 주요 마일스톤:

  • 2007: CELT 프로젝트 시작 (Xiph.org)
  • 2009: SILK 개발 (Skype)
  • 2010: IETF에서 CELT + SILK 통합 결정
  • 2012: RFC 6716 표준화
  • 2013: WebRTC 표준 오디오 코덱 채택
  • 2026: Discord, Zoom, Google Meet 등 주요 플랫폼 사용

기술적 특징

항목설명
압축 방식SILK (음성) + CELT (음악) 하이브리드
샘플레이트8/12/16/24/48 kHz (내부 자동 처리)
비트레이트6~510 kbps (모노 기준)
지연5~66.5ms (프레임 길이 조절 가능)
채널모노, 스테레오 (최대 255 채널 이론상 가능)
패킷 손실 복구FEC (Forward Error Correction) 내장

주요 모드

모드비트레이트용도특징
SILK6-40 kbps음성 통화LPC 기반, 음성 최적화
Hybrid12-64 kbps음성+음악 혼합자동 전환
CELT48-510 kbps음악, 고품질MDCT 기반

압축 원리

SILK (Speech) 모드

특징:

  • LPC (Linear Predictive Coding) 기반
  • 음성 포만트 보존
  • 저비트레이트 최적화 처리 과정: 아래 코드는 text를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.
PCM 입력
  ↓
음성 분석 (피치, 포만트)
  ↓
LPC 계수 추출
  ↓
잔차 신호 양자화
  ↓
비트스트림

CELT (Music) 모드

특징:

  • MDCT 기반 주파수 변환
  • 저지연 설계 (짧은 프레임)
  • 음악 품질 우선 처리 과정: 아래 코드는 text를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.
PCM 입력
  ↓
MDCT 변환
  ↓
심리음향 모델
  ↓
양자화·비트 할당
  ↓
비트스트림

하이브리드 모드

자동 전환:

  • 입력 신호 분석
  • 음성 비율 높음 → SILK 비중 증가
  • 음악 비율 높음 → CELT 비중 증가 장점:
  • 혼합 콘텐츠 (음성+배경음악) 최적화
  • 비트레이트 효율 향상

실전 인코딩

FFmpeg 기본 예제

1) 음성 인코딩 (VoIP)

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 모노, 32 kbps (음성 최적화)
ffmpeg -i voice.wav \
  -c:a libopus \
  -b:a 32k \
  -ac 1 \
  -ar 48000 \
  -application voip \
  voice.opus

파라미터 설명:

  • -b:a 32k: 비트레이트 32 kbps
  • -ac 1: 모노
  • -ar 48000: 48kHz 샘플레이트
  • -application voip: 음성 최적화 모드

2) 음악 인코딩

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 스테레오, 128 kbps (음악)
ffmpeg -i music.wav \
  -c:a libopus \
  -b:a 128k \
  -ac 2 \
  -ar 48000 \
  -application audio \
  music.opus

3) 저지연 인코딩

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 저지연 모드 (5ms 프레임)
ffmpeg -i input.wav \
  -c:a libopus \
  -b:a 64k \
  -frame_duration 5 \
  -application lowdelay \
  lowdelay.opus

프레임 길이 옵션:

  • 2.5: 2.5ms (최저 지연)
  • 5: 5ms
  • 10: 10ms (기본)
  • 20: 20ms
  • 40: 40ms
  • 60: 60ms (최고 효율)

고급 옵션

VBR vs CBR

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# VBR (기본, 권장)
ffmpeg -i input.wav -c:a libopus -b:a 128k -vbr on output.opus
# CBR (스트리밍 대역폭 예측)
ffmpeg -i input.wav -c:a libopus -b:a 128k -vbr off output.opus
# Constrained VBR (중간)
ffmpeg -i input.wav -c:a libopus -b:a 128k -vbr constrained output.opus

패킷 손실 대응 (FEC)

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# FEC 활성화
ffmpeg -i input.wav \
  -c:a libopus \
  -b:a 64k \
  -packet_loss 10 \
  -fec on \
  output.opus

WebM 컨테이너

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 비디오 + Opus 오디오
ffmpeg -i input.mp4 \
  -c:v libvpx-vp9 \
  -c:a libopus \
  -b:a 128k \
  output.webm

배치 처리

Bash 스크립트

아래 코드는 bash를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#!/bin/bash
# 모든 WAV 파일을 Opus로 변환
for f in *.wav; do
  echo "Processing: $f"
  ffmpeg -y -i "$f" \
    -c:a libopus \
    -b:a 128k \
    -application audio \
    "${f%.wav}.opus"
done
echo "완료!"

Python 스크립트

다음은 python를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 함수를 통해 로직을 구현합니다, 에러 처리를 통해 안정성을 확보합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import subprocess
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor
def convert_to_opus(input_file, output_file, bitrate='128k', application='audio'):
    """
    WAV → Opus 변환
    """
    cmd = [
        'ffmpeg', '-y',
        '-i', str(input_file),
        '-c:a', 'libopus',
        '-b:a', bitrate,
        '-application', application,
        str(output_file)
    ]
    
    subprocess.run(cmd, check=True)
    return output_file
def batch_convert(input_dir, output_dir, max_workers=4):
    """
    병렬 배치 변환
    """
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    
    wav_files = list(Path(input_dir).glob('*.wav'))
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = []
        
        for wav_file in wav_files:
            output_file = Path(output_dir) / f"{wav_file.stem}.opus"
            future = executor.submit(convert_to_opus, wav_file, output_file)
            futures.append((wav_file.name, future))
        
        for name, future in futures:
            try:
                result = future.result()
                print(f"✓ {name} → {result.name}")
            except Exception as e:
                print(f"✗ {name}: {e}")
# 사용
batch_convert('input_wavs', 'output_opus', max_workers=4)

성능 비교

비트레이트별 음질 비교

음성 (Speech)

테스트 조건: 16kHz 모노, 음성 전용

비트레이트MP3AAC-HEOpus평가
12 kbps사용 불가나쁨보통Opus만 가능
16 kbps사용 불가나쁨좋음Opus 실용
24 kbps나쁨보통매우 좋음Opus 최적
32 kbps보통좋음우수Opus 압도적
64 kbps좋음매우 좋음우수모두 충분

음악 (Music)

테스트 조건: 44.1kHz 스테레오, 팝 음악

비트레이트MP3AAC-LCOpus평가
64 kbps나쁨보통좋음Opus 유리
96 kbps보통좋음매우 좋음Opus/AAC 우수
128 kbps좋음매우 좋음매우 좋음일반 청취 충분
192 kbps매우 좋음우수우수구분 어려움

지연 시간 비교

코덱프레임 크기알고리즘 지연총 지연용도
Opus (2.5ms)120 샘플~5ms매우 낮음실시간 게임
Opus (10ms)480 샘플~10ms낮음VoIP
Opus (20ms)960 샘플~20ms낮음일반 통화
AAC-LC1024 샘플~50ms중간스트리밍
MP31152 샘플~100ms높음파일 재생
결론: Opus는 5~20ms 지연 가능 (실시간 필수)

인코딩 속도 벤치마크

테스트: 5분 WAV 파일 (48kHz 스테레오)

인코더설정인코딩 시간파일 크기
libopus32k (음성)4s1.2MB
libopus96k (음악)5s3.6MB
libopus128k (음악)6s4.8MB
LAME128k7s6.0MB
FFmpeg AAC128k12s6.8MB
결론: Opus가 가장 빠르고 작음

실무 활용 사례

사례 1: WebRTC 화상회의

요구사항:

  • 초저지연 (<50ms)
  • 음성 명료도
  • 패킷 손실 대응

JavaScript WebRTC 설정

다음은 javascript를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

class OpusWebRTCConfig {
  static getAudioConfig(mode = 'voip') {
    const configs = {
      voip: {
        codec: 'opus',
        bitrate: 32000,
        sampleRate: 48000,
        channels: 1,
        fec: true,
        dtx: true,
        maxptime: 60
      },
      music: {
        codec: 'opus',
        bitrate: 128000,
        sampleRate: 48000,
        channels: 2,
        fec: false,
        dtx: false,
        maxptime: 20
      }
    };
    
    return configs[mode];
  }
  
  static createSDP(config) {
    return `
m=audio 9 UDP/TLS/RTP/SAVPF 111
a=rtpmap:111 opus/48000/2
a=fmtp:111 minptime=10;useinbandfec=${config.fec ? 1 : 0};usedtx=${config.dtx ? 1 : 0}
a=maxptime:${config.maxptime}
a=ptime:20
    `.trim();
  }
}
// 사용
const voipConfig = OpusWebRTCConfig.getAudioConfig('voip');
const sdp = OpusWebRTCConfig.createSDP(voipConfig);
console.log(sdp);

FFmpeg 테스트 인코딩

다음은 bash를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

# 음성 최적화 (16 kbps)
ffmpeg -i voice.wav \
  -c:a libopus \
  -b:a 16k \
  -ac 1 \
  -application voip \
  -frame_duration 20 \
  voice_16k.opus
# 음성 최적화 (32 kbps)
ffmpeg -i voice.wav \
  -c:a libopus \
  -b:a 32k \
  -ac 1 \
  -application voip \
  voice_32k.opus

사례 2: 게임 보이스챗

요구사항:

  • 저지연 (<30ms)
  • 대역폭 절약
  • 다중 플레이어 동시 송수신

Unity C# 예제

다음은 csharp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 함수를 통해 로직을 구현합니다, 에러 처리를 통해 안정성을 확보합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

using System;
using System.Runtime.InteropServices;
public class OpusVoiceChat
{
    [DllImport("opus")]
    private static extern IntPtr opus_encoder_create(
        int Fs, 
        int channels, 
        int application, 
        out int error
    );
    
    [DllImport("opus")]
    private static extern int opus_encode(
        IntPtr st, 
        short[] pcm, 
        int frame_size, 
        byte[] data, 
        int max_data_bytes
    );
    
    private IntPtr encoder;
    private const int SAMPLE_RATE = 48000;
    private const int CHANNELS = 1;
    private const int BITRATE = 24000;
    private const int FRAME_SIZE = 960;  // 20ms at 48kHz
    
    public void Initialize()
    {
        int error;
        encoder = opus_encoder_create(
            SAMPLE_RATE, 
            CHANNELS, 
            2,  // OPUS_APPLICATION_VOIP
            out error
        );
        
        if (error != 0)
        {
            throw new Exception($"Opus encoder error: {error}");
        }
    }
    
    public byte[] Encode(short[] pcm)
    {
        byte[] output = new byte[4000];
        int encoded_bytes = opus_encode(
            encoder, 
            pcm, 
            FRAME_SIZE, 
            output, 
            output.Length
        );
        
        if (encoded_bytes < 0)
        {
            throw new Exception($"Encode error: {encoded_bytes}");
        }
        
        byte[] result = new byte[encoded_bytes];
        Array.Copy(output, result, encoded_bytes);
        return result;
    }
}

FFmpeg 테스트

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 게임 보이스 (24 kbps, 저지연)
ffmpeg -i game_voice.wav \
  -c:a libopus \
  -b:a 24k \
  -ac 1 \
  -application voip \
  -frame_duration 10 \
  game_voice.opus

사례 3: 팟캐스트 배포

요구사항:

  • 파일 크기 최소화
  • 음성 명료도
  • RSS 피드 호환

Opus 설정 (최소 크기)

아래 코드는 bash를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

# 모노, 48 kbps (팟캐스트)
ffmpeg -i podcast.wav \
  -c:a libopus \
  -b:a 48k \
  -ac 1 \
  -ar 48000 \
  -application voip \
  -metadata title="에피소드 제목" \
  -metadata artist="팟캐스트 이름" \
  podcast.opus

파일 크기 비교:

  • MP3 64k: 1시간 = 28MB
  • Opus 48k: 1시간 = 21MB

Python 자동화

다음은 python를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 함수를 통해 로직을 구현합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

import subprocess
from pathlib import Path
def create_podcast_opus(input_file, metadata):
    """
    팟캐스트 Opus 생성
    """
    output_file = Path(metadata['filename'])
    
    cmd = [
        'ffmpeg', '-y',
        '-i', str(input_file),
        '-c:a', 'libopus',
        '-b:a', '48k',
        '-ac', '1',
        '-ar', '48000',
        '-application', 'voip',
        '-metadata', f"title={metadata['title']}",
        '-metadata', f"artist={metadata['artist']}",
        str(output_file)
    ]
    
    subprocess.run(cmd, check=True)
    
    size_mb = output_file.stat().st_size / (1024 * 1024)
    print(f"생성 완료: {output_file.name} ({size_mb:.2f} MB)")
# 사용
metadata = {
    'filename': 'episode_01.opus',
    'title': '첫 번째 에피소드',
    'artist': '내 팟캐스트'
}
create_podcast_opus('recording.wav', metadata)

사례 4: 웹 오디오 플레이어

요구사항:

  • 브라우저 호환성
  • 적응형 품질
  • 폴백 지원

HTML5 Audio

아래 코드는 html를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

<audio controls>
  <source src="audio.opus" type="audio/ogg; codecs=opus">
  <source src="audio.webm" type="audio/webm; codecs=opus">
  <source src="audio.m4a" type="audio/mp4">
  <source src="audio.mp3" type="audio/mpeg">
  브라우저가 audio 태그를 지원하지 않습니다.
</audio>

JavaScript 적응형 로딩

다음은 javascript를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

class AdaptiveOpusPlayer {
  constructor() {
    this.audio = new Audio();
    this.formats = [
      { src: 'audio.opus', type: 'audio/ogg; codecs=opus' },
      { src: 'audio.webm', type: 'audio/webm; codecs=opus' },
      { src: 'audio.m4a', type: 'audio/mp4' },
      { src: 'audio.mp3', type: 'audio/mpeg' }
    ];
  }
  
  selectFormat() {
    for (const format of this.formats) {
      if (this.audio.canPlayType(format.type)) {
        return format.src;
      }
    }
    return this.formats[this.formats.length - 1].src;
  }
  
  play() {
    this.audio.src = this.selectFormat();
    this.audio.play();
  }
}
// 사용
const player = new AdaptiveOpusPlayer();
player.play();

최적화 팁

1) 비트레이트 최적화

음성 비트레이트 가이드

용도비트레이트품질
저품질 통화12-16 kbps이해 가능
일반 통화24-32 kbps좋음
고품질 통화40-64 kbps매우 좋음

음악 비트레이트 가이드

용도비트레이트품질
저품질64-80 kbps보통
일반96-128 kbps좋음
고품질160-192 kbps매우 좋음
최고256+ kbps원본과 거의 동일

2) 프레임 길이 최적화

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 저지연 우선 (5ms)
ffmpeg -i input.wav -c:a libopus -b:a 64k -frame_duration 5 lowdelay.opus
# 효율 우선 (60ms)
ffmpeg -i input.wav -c:a libopus -b:a 64k -frame_duration 60 efficient.opus

트레이드오프:

  • 짧은 프레임: 낮은 지연, 높은 오버헤드
  • 긴 프레임: 높은 효율, 높은 지연

3) 패킷 손실 대응

아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# FEC 활성화 (10% 손실 예상)
ffmpeg -i input.wav \
  -c:a libopus \
  -b:a 64k \
  -packet_loss 10 \
  -fec on \
  output.opus

트러블슈팅

문제 1: 브라우저 재생 안 됨

증상: Chrome에서 .opus 파일 재생 불가

<audio src="audio.opus" controls></audio>
<!-- 재생 안 됨 -->

원인: 컨테이너 문제 (Opus는 Ogg 또는 WebM 필요) 해결: 아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# Ogg 컨테이너
ffmpeg -i input.wav -c:a libopus -b:a 128k output.ogg
# WebM 컨테이너
ffmpeg -i input.wav -c:a libopus -b:a 128k output.webm

다음은 간단한 html 코드 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

<audio controls>
  <source src="audio.ogg" type="audio/ogg; codecs=opus">
  <source src="audio.webm" type="audio/webm; codecs=opus">
</audio>

문제 2: 구형 기기 미지원

증상: 차량 USB, 구형 스마트폰에서 재생 불가 해결: MP3/AAC 폴백 제공 다음은 간단한 bash 코드 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 다중 포맷 생성
ffmpeg -i input.wav -c:a libopus -b:a 96k output.opus
ffmpeg -i input.wav -c:a aac -b:a 128k output.m4a
ffmpeg -i input.wav -c:a libmp3lame -b:a 192k output.mp3

문제 3: 음악 품질 저하

증상: 64 kbps Opus에서 음악이 뭉개짐 원인: 비트레이트 부족 해결: 음악은 최소 96 kbps 이상 아래 코드는 bash를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

# 음악 최소 권장 (96 kbps)
ffmpeg -i music.wav \
  -c:a libopus \
  -b:a 96k \
  -application audio \
  music.opus
# 고품질 (128 kbps)
ffmpeg -i music.wav \
  -c:a libopus \
  -b:a 128k \
  -application audio \
  music_hq.opus

문제 4: 지연 시간 높음

증상: 실시간 통화에서 지연 체감 원인: 프레임 길이가 너무 김 해결: 짧은 프레임 사용 아래 코드는 bash를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

# 저지연 (10ms 프레임)
ffmpeg -i input.wav \
  -c:a libopus \
  -b:a 64k \
  -frame_duration 10 \
  -application lowdelay \
  lowdelay.opus

문제 5: 파일 크기 예측 불가 (VBR)

증상: VBR 모드에서 파일 크기를 미리 알 수 없음 해결: CBR 모드 사용 아래 코드는 bash를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

# CBR (크기 예측 가능)
ffmpeg -i input.wav \
  -c:a libopus \
  -b:a 128k \
  -vbr off \
  output.opus
# 파일 크기 계산
# 크기 = (비트레이트 * 시간) / 8
# 128 kbps * 300s / 8 = 4.8 MB

마무리

Opus는 음성+음악 하이브리드와 프레임 길이 조절로 저지연 실시간에 강합니다.

핵심 요약

  1. 하이브리드 구조
    • SILK: 음성 최적화 (6-40 kbps)
    • CELT: 음악 최적화 (48-510 kbps)
    • 자동 모드 전환
  2. 저지연
    • 프레임 길이: 2.5~60ms
    • 총 지연: 5~66ms
    • WebRTC 표준
  3. 로열티 프리
    • BSD 유사 라이선스
    • 상용 배포 자유
    • 특허 회피 설계

선택 가이드

상황비트레이트설정
VoIP/화상회의16-32 kbps-application voip
게임 보이스챗24-48 kbps-frame_duration 10
팟캐스트48-64 kbps모노, -application voip
음악 스트리밍96-128 kbps스테레오, -application audio
고품질 음악160-192 kbps스테레오, VBR

FFmpeg 명령 치트시트

다음은 bash를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

# 음성 (32 kbps)
ffmpeg -i voice.wav -c:a libopus -b:a 32k -ac 1 -application voip voice.opus
# 음악 (128 kbps)
ffmpeg -i music.wav -c:a libopus -b:a 128k -ac 2 -application audio music.opus
# 저지연 (10ms)
ffmpeg -i input.wav -c:a libopus -b:a 64k -frame_duration 10 lowdelay.opus
# WebM 컨테이너
ffmpeg -i input.mp4 -c:v copy -c:a libopus -b:a 128k output.webm
# 배치 변환
for f in *.wav; do
  ffmpeg -y -i "$f" -c:a libopus -b:a 128k "${f%.wav}.opus"
done

추천 사용 시나리오

  • 실시간 음성·화상·게임: Opus 우선
  • 음악 스트리밍 (신규): Opus 검토
  • 팟캐스트 (파일 크기 중요): Opus 모노 48k
  • 레거시 호환 필요: MP3/AAC 병행

다음 단계

참고 자료

... 996 lines not shown ... Token usage: 63706/1000000; 936294 remaining Start-Sleep -Seconds 3