@jjlmoya/utils-streaming 1.19.0 → 1.21.0

package/src/tool/videoBitratePlanner/i18n/pt.ts

@@ -0,0 +1,37 @@
+import { createLocalizedContent } from '../locale-content';
+
+export const content = createLocalizedContent({
+  language: 'pt',
+  slug: 'calculadora-bitrate-armazenamento-video',
+  title: 'Planejador de Bitrate e Armazenamento de Vídeo',
+  description: 'Estime o armazenamento de vídeo, o tempo por fotograma e níveis práticos de bitrate para streaming ou gravação.',
+  ui: {
+    presetLabel: 'Comece com uma cena', presetFast: 'Stream web rápido', presetUpload: 'Live diário', presetArchive: 'Arquivo 4K', resolutionLabel: 'Resolução', frameRateLabel: 'Fotogramas por segundo', codecLabel: 'Codec', bitrateLabel: 'Bitrate de vídeo', durationLabel: 'Duração da sessão', copiesLabel: 'Cópias guardadas', minutesLabel: 'minutos', copiesShort: 'cópias', h264: 'H.264', h265: 'H.265', av1: 'AV1', codecNote: 'A eficiência do codec muda a leitura de qualidade, não o cálculo do armazenamento.', sceneLabel: 'Do sinal ao armazenamento', signalSource: 'Imagem', codecGate: 'Codificação', storageReel: 'Armazenamento', qualityEstimate: 'Leitura de qualidade', storageEstimate: 'Armazenamento estimado', perCopy: 'Uma cópia', allCopies: 'Todas as cópias', perHour: 'Por hora', frameTime: 'Tempo por fotograma', dataPerFrame: 'Dados por fotograma', comparisonLabel: 'Comparação de armazenamento', lean: 'Leve', balanced: 'Equilibrado', crisp: 'Nítido', qualityLean: 'Leve e compacto', qualityBalanced: 'Sinal equilibrado', qualityStrong: 'Bom detalhe', qualityExcellent: 'Grande margem', qualityAggressive: 'Compressão agressiva', qualityGuidance: 'Uma estimativa visual para comparar definições.', capacityLight: 'Pegada de armazenamento leve', capacityMedium: 'Pegada de armazenamento média', capacityHeavy: 'Pegada de armazenamento elevada', capacityNote: 'O estado de capacidade usa o total de cópias mostrado acima.', reset: 'Repor valores', localNote: 'Funciona localmente neste navegador. Nada é enviado.', assumptionTitle: 'Ler os pressupostos', assumptionText: 'O armazenamento usa gigabytes decimais e o bitrate de vídeo indicado. Não inclui áudio, sobrecarga do contentor, picos de bitrate variável nem espaço do sistema de ficheiros.', warningText: 'Os níveis de qualidade são referências de planeamento. Movimento, grão, fotogramas-chave, predefinições do codificador, transcodificação e margem de rede podem alterar o resultado real.', readyText: 'Altere um valor para redesenhar o sinal.', calculateAria: 'Atualizar o plano de vídeo',
+  },
+  faq: [
+    { question: 'Este planeador envia ou inspeciona o meu vídeo?', answer: 'Não. Usa apenas os valores introduzidos no navegador. Não envia ficheiros, não inspeciona uma câmara nem consulta um serviço de streaming.' },
+    { question: 'Como é calculado o armazenamento?', answer: 'O bitrate é multiplicado pela duração e dividido por oito para converter bits em bytes. O resultado usa gigabytes decimais e é multiplicado pelo número de cópias.' },
+    { question: 'O que significa a leitura de qualidade?', answer: 'É uma regra indicativa baseada em píxeis, fotogramas por segundo, bitrate e um fator amplo de eficiência do codec. Não promete qualidade porque o movimento e o codificador também contam.' },
+    { question: 'Por que motivo o mesmo bitrate muda com outra resolução ou taxa de fotogramas?', answer: 'Uma resolução maior tem mais píxeis e uma taxa maior envia mais fotogramas por segundo. Mais informação visual tem de partilhar o mesmo bitrate.' },
+    { question: 'Posso usar o resultado como requisito de uma plataforma?', answer: 'Use-o para planear capacidade e comparar cenários. Os requisitos mudam, por isso consulte a orientação atual do destino e deixe margem de envio para uma transmissão ao vivo.' },
+  ],
+  howTo: [
+    { name: 'Escolha o formato da imagem', text: 'Selecione a resolução e a taxa de fotogramas que correspondem ao stream ou gravação que pretende criar.' },
+    { name: 'Defina o sinal', text: 'Escolha o codec e introduza o bitrate de vídeo em megabits por segundo. Um preset é um bom ponto de partida.' },
+    { name: 'Descreva a sessão', text: 'Indique a duração em minutos e o número de cópias que quer conservar, editar ou entregar.' },
+    { name: 'Leia a compensação', text: 'Compare os níveis leve, equilibrado e nítido para perceber a mudança de armazenamento antes da sessão.' },
+  ],
+  seo: [
+    { type: 'title', text: 'Estime o armazenamento de vídeo antes de transmitir ou gravar', level: 2 },
+    { type: 'paragraph', html: 'Uma calculadora de bitrate de vídeo ajuda a preparar um plano de armazenamento realista para uma sessão. Introduza bitrate, duração e cópias e compare três níveis de sinal para o mesmo formato de imagem.' },
+    { type: 'title', text: 'O que calcula o planeador', level: 3 },
+    { type: 'list', items: ['<strong>Armazenamento:</strong> bitrate multiplicado pelo tempo, convertido de bits para gigabytes decimais e multiplicado pelas cópias.', '<strong>Tempo por fotograma:</strong> milissegundos disponíveis por fotograma na FPS escolhida e uma estimativa de dados por fotograma.', '<strong>Leitura de qualidade:</strong> comparação de píxeis por fotograma ajustada por um fator de eficiência do codec.'] },
+    { type: 'title', text: 'Como a resolução e a FPS mudam a compensação', level: 3 },
+    { type: 'paragraph', html: 'A resolução aumenta os píxeis de cada fotograma e a FPS aumenta a quantidade de fotogramas por segundo. Se o bitrate ficar igual, cada fotograma recebe menos dados e a compressão fica mais exigente.' },
+    { type: 'tip', title: 'Deixe margem para uma transmissão ao vivo', html: 'Considere o bitrate de vídeo como a carga principal, não como toda a capacidade da ligação. Reserve espaço para áudio, protocolo e variações da rede e teste uma cena com movimento semelhante.' },
+    { type: 'title', text: 'Use as orientações da plataforma no ajuste final', level: 3 },
+    { type: 'paragraph', html: 'Este planeador é independente da plataforma. O YouTube publica intervalos de bitrate por resolução e taxa de fotogramas. Consulte as regras atuais do destino para validar o cenário.' },
+    { type: 'title', text: 'Por que motivo o resultado é uma estimativa', level: 3 },
+    { type: 'paragraph', html: 'Um bitrate nominal não descreve todos os bytes do ficheiro final. Bitrate variável, áudio, metadados do contentor, fotogramas-chave, transcodificação e unidades do sistema podem alterar o tamanho.' },
+  ],
+});

package/src/tool/videoBitratePlanner/i18n/ru.ts

@@ -0,0 +1,37 @@
+import { createLocalizedContent } from '../locale-content';
+
+export const content = createLocalizedContent({
+  language: 'ru',
+  slug: 'kalkulyator-bitreyta-hranilishcha-video',
+  title: 'Планировщик битрейта и хранилища видео',
+  description: 'Оцените объём видеохранилища, время кадра и практичные уровни битрейта для трансляции или записи.',
+  ui: {
+    presetLabel: 'Начать со сцены', presetFast: 'Быстрая веб-трансляция', presetUpload: 'Обычный эфир', presetArchive: 'Архив 4K', resolutionLabel: 'Разрешение', frameRateLabel: 'Частота кадров', codecLabel: 'Кодек', bitrateLabel: 'Битрейт видео', durationLabel: 'Длительность сеанса', copiesLabel: 'Сохраняемые копии', minutesLabel: 'минут', copiesShort: 'копий', h264: 'H.264', h265: 'H.265', av1: 'AV1', codecNote: 'Эффективность кодека меняет оценку качества, но не расчёт хранилища.', sceneLabel: 'От сигнала к хранилищу', signalSource: 'Изображение', codecGate: 'Кодирование', storageReel: 'Хранилище', qualityEstimate: 'Оценка качества', storageEstimate: 'Расчётный объём', perCopy: 'Одна копия', allCopies: 'Все копии', perHour: 'В час', frameTime: 'Время кадра', dataPerFrame: 'Данные на кадр', comparisonLabel: 'Сравнение объёма', lean: 'Экономный', balanced: 'Сбалансированный', crisp: 'Чёткий', qualityLean: 'Лёгкий сигнал', qualityBalanced: 'Сбалансированный сигнал', qualityStrong: 'Много деталей', qualityExcellent: 'Большой запас', qualityAggressive: 'Сильное сжатие', qualityGuidance: 'Визуальная оценка для сравнения настроек.', capacityLight: 'Небольшая нагрузка на хранилище', capacityMedium: 'Средняя нагрузка на хранилище', capacityHeavy: 'Большая нагрузка на хранилище', capacityNote: 'Статус ёмкости основан на общем числе копий выше.', reset: 'Сбросить значения', localNote: 'Работает локально в браузере. Ничего не загружается.', assumptionTitle: 'Допущения расчёта', assumptionText: 'Объём считается в десятичных гигабайтах по введённому битрейту видео. Аудио, служебные данные контейнера, пики переменного битрейта и место файловой системы не добавляются.', warningText: 'Уровни качества служат для планирования. Движение, зернистость, ключевые кадры, пресет кодировщика, перекодирование платформы и запас сети меняют реальный результат.', readyText: 'Измените значение, чтобы перерисовать сигнал.', calculateAria: 'Обновить план видео',
+  },
+  faq: [
+    { question: 'Загружает ли этот планировщик и проверяет ли он моё видео?', answer: 'Нет. Он использует только значения, введённые в браузере. Файлы не загружаются, камера не проверяется, запросы к сервисам трансляции не выполняются.' },
+    { question: 'Как рассчитывается объём хранилища?', answer: 'Битрейт умножается на длительность и делится на восемь для перевода битов в байты. Результат указан в десятичных гигабайтах и умножен на число копий.' },
+    { question: 'Что означает оценка качества?', answer: 'Это ориентир на основе пикселей, кадров в секунду, битрейта и общего коэффициента эффективности кодека. Это не гарантия качества, поскольку важны также движение и настройки кодировщика.' },
+    { question: 'Почему один и тот же битрейт меняется при другом разрешении или FPS?', answer: 'Большее разрешение содержит больше пикселей, а высокая частота отправляет больше кадров в секунду. Одному битрейту приходится описывать больше визуальной информации.' },
+    { question: 'Можно ли считать результат требованием платформы?', answer: 'Используйте его для планирования ёмкости и сравнения сценариев. Требования меняются, поэтому проверьте актуальную инструкцию площадки и оставьте запас исходящей скорости для эфира.' },
+  ],
+  howTo: [
+    { name: 'Выберите формат изображения', text: 'Укажите разрешение и частоту кадров для планируемой трансляции или записи.' },
+    { name: 'Настройте сигнал кодирования', text: 'Выберите кодек и введите битрейт видео в мегабитах в секунду. Для старта можно выбрать пресет.' },
+    { name: 'Опишите сеанс', text: 'Введите длительность в минутах и число копий, которые нужно сохранить, смонтировать или передать.' },
+    { name: 'Прочитайте компромисс', text: 'Сравните экономный, сбалансированный и чёткий уровни до начала записи.' },
+  ],
+  seo: [
+    { type: 'title', text: 'Оцените объём видео перед трансляцией или записью', level: 2 },
+    { type: 'paragraph', html: 'Калькулятор битрейта видео помогает составить реалистичный план хранилища для записи. Введите битрейт, длительность и число копий, а затем сравните три уровня сигнала для одного формата изображения.' },
+    { type: 'title', text: 'Что рассчитывает планировщик', level: 3 },
+    { type: 'list', items: ['<strong>Хранилище:</strong> битрейт умножается на время, переводится из битов в десятичные гигабайты и умножается на число копий.', '<strong>Время кадра:</strong> миллисекунды на кадр при выбранной частоте и оценка данных на кадр.', '<strong>Оценка качества:</strong> сравнение пикселей на кадр с поправкой на эффективность кодека.'] },
+    { type: 'title', text: 'Как разрешение и FPS меняют компромисс', level: 3 },
+    { type: 'paragraph', html: 'Разрешение увеличивает число пикселей в кадре, а FPS увеличивает число кадров в секунду. При неизменном битрейте каждому кадру достаётся меньше данных и сжатие становится сложнее.' },
+    { type: 'tip', title: 'Оставьте запас для эфира', html: 'Считайте битрейт видео основной нагрузкой, а не всей пропускной способностью. Оставьте место для звука, протокола и сетевых колебаний и протестируйте похожую по движению сцену.' },
+    { type: 'title', text: 'Проверьте правила платформы перед финальным выбором', level: 3 },
+    { type: 'paragraph', html: 'Планировщик не привязан к площадке. YouTube публикует диапазоны битрейта по разрешению и частоте кадров. Сверьте смоделированный сценарий с актуальными правилами назначения.' },
+    { type: 'title', text: 'Почему результат является оценкой', level: 3 },
+    { type: 'paragraph', html: 'Номинальный битрейт не описывает каждый байт готового файла. Переменный битрейт, звук, метаданные контейнера, ключевые кадры, перекодирование и единицы системы могут изменить размер.' },
+  ],
+});

package/src/tool/videoBitratePlanner/i18n/sv.ts

@@ -0,0 +1,37 @@
+import { createLocalizedContent } from '../locale-content';
+
+export const content = createLocalizedContent({
+  language: 'sv',
+  slug: 'video-bitrate-lagringsplanerare',
+  title: 'Planerare för videobitrate och lagring',
+  description: 'Uppskatta videolagring, bildtid och praktiska bitrate nivåer för streaming eller inspelning.',
+  ui: {
+    presetLabel: 'Börja med en scen', presetFast: 'Snabb webbstream', presetUpload: 'Vardaglig livesändning', presetArchive: '4K arkiv', resolutionLabel: 'Upplösning', frameRateLabel: 'Bildfrekvens', codecLabel: 'Kodek', bitrateLabel: 'Videobitrate', durationLabel: 'Sessionens längd', copiesLabel: 'Sparade kopior', minutesLabel: 'minuter', copiesShort: 'kopior', h264: 'H.264', h265: 'H.265', av1: 'AV1', codecNote: 'Kodekens effektivitet ändrar kvalitetsbedömningen, inte lagringsberäkningen.', sceneLabel: 'Signal till lagring', signalSource: 'Bild', codecGate: 'Kodning', storageReel: 'Lagring', qualityEstimate: 'Kvalitetsbedömning', storageEstimate: 'Uppskattad lagring', perCopy: 'En kopia', allCopies: 'Alla kopior', perHour: 'Per timme', frameTime: 'Bildtid', dataPerFrame: 'Data per bild', comparisonLabel: 'Jämförelse av lagring', lean: 'Snål', balanced: 'Balanserad', crisp: 'Skarp', qualityLean: 'Lätt och snål', qualityBalanced: 'Balanserad signal', qualityStrong: 'Starka detaljer', qualityExcellent: 'Gott om marginal', qualityAggressive: 'Kraftig komprimering', qualityGuidance: 'En visuell uppskattning för att jämföra inställningar.', capacityLight: 'Litet lagringsavtryck', capacityMedium: 'Medelstort lagringsavtryck', capacityHeavy: 'Stort lagringsavtryck', capacityNote: 'Kapacitetsstatusen baseras på det totala antalet kopior ovan.', reset: 'Återställ värden', localNote: 'Kör lokalt i webbläsaren. Ingenting laddas upp.', assumptionTitle: 'Läs antagandena', assumptionText: 'Lagringen använder decimala gigabyte och den angivna videobitraten. Ljud, containeröverhead, toppar i variabel bitrate och filsystemets utrymme läggs inte till.', warningText: 'Kvalitetsnivåerna är planeringsriktlinjer. Rörelse, korn, nyckelbilder, kodarpreset, plattformens omkodning och nätverksmarginal kan ändra det verkliga resultatet.', readyText: 'Ändra ett värde för att rita om signalen.', calculateAria: 'Uppdatera videoplanen',
+  },
+  faq: [
+    { question: 'Laddar eller granskar planeraren min video?', answer: 'Nej. Den använder bara värdena du anger i webbläsaren. Inga filer laddas upp, ingen kamera granskas och ingen streamingtjänst kontaktas.' },
+    { question: 'Hur beräknas lagringen?', answer: 'Bitrate multipliceras med tiden och delas med åtta för att omvandla bitar till byte. Resultatet använder decimala gigabyte och multipliceras med antalet kopior.' },
+    { question: 'Vad betyder kvalitetsbedömningen?', answer: 'Det är en tumregel baserad på pixlar, bilder per sekund, bitrate och en bred kodekeffektivitetsfaktor. Det är inget löfte om bildkvalitet eftersom rörelse och kodarinställningar också spelar roll.' },
+    { question: 'Varför ändras samma bitrate med annan upplösning eller bildfrekvens?', answer: 'En högre upplösning beskriver fler pixlar och en högre bildfrekvens skickar fler bilder per sekund. Mer visuell information måste dela samma bitrate.' },
+    { question: 'Kan resultatet användas som ett plattformskrav?', answer: 'Använd det för kapacitetsplanering och jämförelser. Plattformskrav ändras, så kontrollera den aktuella kodarguiden och lämna uppladdningsmarginal för en livesändning.' },
+  ],
+  howTo: [
+    { name: 'Välj bildformat', text: 'Välj upplösning och bildfrekvens som passar streamen eller inspelningen du planerar.' },
+    { name: 'Ställ in kodningssignalen', text: 'Välj kodek och ange videobitrate i megabit per sekund. Ett preset fungerar som startpunkt.' },
+    { name: 'Beskriv sessionen', text: 'Ange längden i minuter och hur många kopior du vill spara, redigera eller leverera.' },
+    { name: 'Läs avvägningen', text: 'Jämför snåla, balanserade och skarpa nivåer innan du börjar spela in.' },
+  ],
+  seo: [
+    { type: 'title', text: 'Uppskatta videolagring före streaming eller inspelning', level: 2 },
+    { type: 'paragraph', html: 'En videobitrate kalkylator hjälper när en inspelningssession behöver en realistisk lagringsplan. Ange bitrate, längd och kopior och jämför tre signalnivåer för samma bildformat.' },
+    { type: 'title', text: 'Det här beräknar planeraren', level: 3 },
+    { type: 'list', items: ['<strong>Lagring:</strong> bitrate gånger tid, omvandlad från bitar till decimala gigabyte och multiplicerad med kopiorna.', '<strong>Bildtid:</strong> millisekunder per bild vid vald FPS och en uppskattning av data per bild.', '<strong>Kvalitetsbedömning:</strong> en jämförelse av pixlar per bild med en kodekeffektivitetsfaktor.'] },
+    { type: 'title', text: 'Så påverkar upplösning och FPS avvägningen', level: 3 },
+    { type: 'paragraph', html: 'Upplösningen ökar antalet pixlar i varje bild och FPS ökar antalet bilder per sekund. Om bitraten är oförändrad får varje bild mindre data och komprimeringen blir mer krävande.' },
+    { type: 'tip', title: 'Lämna marginal för live', html: 'Se videobitraten som huvudlasten, inte som hela anslutningens kapacitet. Lämna plats för ljud, protokoll och nätverksvariationer och testa en scen med liknande rörelse.' },
+    { type: 'title', text: 'Använd plattformens riktlinjer för slutvärdet', level: 3 },
+    { type: 'paragraph', html: 'Planeraren är plattformsneutral. YouTube publicerar bitrateintervall efter upplösning och bildfrekvens. Kontrollera aktuella regler för destinationen innan du låser inställningen.' },
+    { type: 'title', text: 'Varför lagringsresultatet är en uppskattning', level: 3 },
+    { type: 'paragraph', html: 'En nominell bitrate beskriver inte varje byte i den färdiga filen. Variabel bitrate, ljud, containermetadata, nyckelbilder, omkodning, systemenheter och vald inspelningsprofil kan ändra slutstorleken.' },
+  ],
+});

package/src/tool/videoBitratePlanner/i18n/tr.ts

@@ -0,0 +1,37 @@
+import { createLocalizedContent } from '../locale-content';
+
+export const content = createLocalizedContent({
+  language: 'tr',
+  slug: 'video-bitrate-depolama-planlayici',
+  title: 'Video Bit Hızı ve Depolama Planlayıcısı',
+  description: 'Yayın veya kayıt için video depolamasını, kare süresini ve pratik bit hızı seviyelerini tahmin edin.',
+  ui: {
+    presetLabel: 'Bir sahneyle başlayın', presetFast: 'Hızlı web yayını', presetUpload: 'Günlük canlı yayın', presetArchive: '4K arşiv', resolutionLabel: 'Çözünürlük', frameRateLabel: 'Kare hızı', codecLabel: 'Kodek', bitrateLabel: 'Video bit hızı', durationLabel: 'Oturum süresi', copiesLabel: 'Saklanan kopyalar', minutesLabel: 'dakika', copiesShort: 'kopya', h264: 'H.264', h265: 'H.265', av1: 'AV1', codecNote: 'Kodek verimliliği kalite yorumunu değiştirir, depolama hesabını değiştirmez.', sceneLabel: 'Sinyalden depolamaya', signalSource: 'Görüntü', codecGate: 'Kodlama', storageReel: 'Depolama', qualityEstimate: 'Kalite yorumu', storageEstimate: 'Tahmini depolama', perCopy: 'Bir kopya', allCopies: 'Tüm kopyalar', perHour: 'Saat başına', frameTime: 'Kare süresi', dataPerFrame: 'Kare başına veri', comparisonLabel: 'Depolama karşılaştırması', lean: 'Hafif', balanced: 'Dengeli', crisp: 'Keskin', qualityLean: 'Hafif ve ekonomik', qualityBalanced: 'Dengeli sinyal', qualityStrong: 'Güçlü ayrıntı', qualityExcellent: 'Geniş pay', qualityAggressive: 'Agresif sıkıştırma', qualityGuidance: 'Ayarları karşılaştırmak için görsel bir tahmin.', capacityLight: 'Hafif depolama yükü', capacityMedium: 'Orta depolama yükü', capacityHeavy: 'Yüksek depolama yükü', capacityNote: 'Kapasite durumu yukarıdaki toplam kopyalara göre belirlenir.', reset: 'Değerleri sıfırla', localNote: 'Bu tarayıcıda yerel çalışır. Hiçbir şey yüklenmez.', assumptionTitle: 'Varsayımları okuyun', assumptionText: 'Depolama, girilen video bit hızını ve ondalık gigabaytları kullanır. Ses, kapsayıcı ek yükü, değişken bit hızı tepe değerleri ve dosya sistemi payı eklenmez.', warningText: 'Kalite seviyeleri planlama ölçütleridir. Hareket, gren, anahtar kareler, kodlayıcı ön ayarları, platform dönüştürmesi ve ağ payı gerçek sonucu değiştirebilir.', readyText: 'Sinyali yeniden çizmek için bir değeri değiştirin.', calculateAria: 'Video planını güncelle',
+  },
+  faq: [
+    { question: 'Bu planlayıcı videomu yükler veya inceler mi?', answer: 'Hayır. Yalnızca tarayıcıya girdiğiniz değerleri kullanır. Dosya yüklemez, kamerayı incelemez ve yayın hizmetine bağlanmaz.' },
+    { question: 'Depolama nasıl hesaplanır?', answer: 'Bit hızı süreyle çarpılır ve bitleri bayta çevirmek için sekize bölünür. Sonuç ondalık gigabayt olarak gösterilir ve kopya sayısıyla çarpılır.' },
+    { question: 'Kalite yorumu ne anlama gelir?', answer: 'Piksel, saniyedeki kare, bit hızı ve genel bir kodek verimlilik katsayısına dayanan pratik bir ölçüttür. Hareket ve kodlayıcı ayarları da önemli olduğu için görüntü kalitesi garantisi değildir.' },
+    { question: 'Aynı bit hızı farklı çözünürlük veya kare hızında neden değişir?', answer: 'Yüksek çözünürlükte daha fazla piksel, yüksek kare hızında saniyede daha fazla kare vardır. Daha fazla görsel bilgi aynı bit hızını paylaşır.' },
+    { question: 'Sonucu bir platform şartı olarak kullanabilir miyim?', answer: 'Kapasite planlamak ve senaryoları karşılaştırmak için kullanın. Platform şartları değişebilir; güncel kodlayıcı rehberini kontrol edin ve canlı yayın için yükleme payı bırakın.' },
+  ],
+  howTo: [
+    { name: 'Görüntü biçimini seçin', text: 'Planladığınız yayın veya kayda uygun çözünürlük ve kare hızını seçin.' },
+    { name: 'Kodlama sinyalini ayarlayın', text: 'Kodeği seçin ve video bit hızını saniyede megabit olarak girin. Başlangıç için bir ön ayar kullanabilirsiniz.' },
+    { name: 'Oturumu tanımlayın', text: 'Süreyi dakika olarak ve saklamak, düzenlemek veya teslim etmek istediğiniz kopya sayısını girin.' },
+    { name: 'Değiş tokuşu okuyun', text: 'Kayıttan önce hafif, dengeli ve keskin seviyelerin depolamayı nasıl değiştirdiğini karşılaştırın.' },
+  ],
+  seo: [
+    { type: 'title', text: 'Yayın veya kayıt öncesinde video depolamasını tahmin edin', level: 2 },
+    { type: 'paragraph', html: 'Video bit hızı hesaplayıcısı, bir kayıt oturumu için gerçekçi depolama planı gerektiğinde yardımcı olur. Bit hızını, süreyi ve kopyaları girin; aynı görüntü biçimi için üç sinyal seviyesini karşılaştırın.' },
+    { type: 'title', text: 'Planlayıcının hesapladıkları', level: 3 },
+    { type: 'list', items: ['<strong>Depolama:</strong> bit hızı zamanla çarpılır, bitten ondalık gigabayta çevrilir ve kopya sayısıyla çarpılır.', '<strong>Kare süresi:</strong> seçilen FPS değerinde her kare için kullanılabilen milisaniye ve kare başına veri tahmini.', '<strong>Kalite yorumu:</strong> kodek verimlilik katsayısıyla ayarlanmış kare başına piksel karşılaştırması.'] },
+    { type: 'title', text: 'Çözünürlük ve FPS değiş tokuşu nasıl etkiler', level: 3 },
+    { type: 'paragraph', html: 'Çözünürlük her karedeki piksel sayısını, FPS ise saniyedeki kare sayısını artırır. Bit hızı sabit kalırsa her kareye daha az veri düşer ve sıkıştırma zorlaşır.' },
+    { type: 'tip', title: 'Canlı yayın için pay bırakın', html: 'Video bit hızını bağlantının tamamı olarak görmeyin. Ses, protokol ve ağ değişimleri için alan bırakın ve gerçek yayına benzer hareket içeren bir sahneyi test edin.' },
+    { type: 'title', text: 'Son ayar için platform rehberini kullanın', level: 3 },
+    { type: 'paragraph', html: 'Bu planlayıcı platformdan bağımsızdır. YouTube çözünürlük ve kare hızına göre bit hızı aralıkları yayımlar. Burada oluşturduğunuz senaryoyu hedef platformun güncel kurallarıyla doğrulayın.' },
+    { type: 'title', text: 'Depolama sonucu neden tahmindir', level: 3 },
+    { type: 'paragraph', html: 'Nominal bit hızı son dosyadaki her baytı açıklamaz. Değişken bit hızı, ses, kapsayıcı meta verileri, anahtar kareler, dönüştürme ve sistem birimleri son boyutu değiştirebilir.' },
+  ],
+});

package/src/tool/videoBitratePlanner/i18n/zh.ts

@@ -0,0 +1,37 @@
+import { createLocalizedContent } from '../locale-content';
+
+export const content = createLocalizedContent({
+  language: 'zh',
+  slug: 'video-bitrate-storage-planner',
+  title: '视频码率与存储规划器',
+  description: '估算直播或录制所需的视频存储空间、帧时间和实用码率等级。',
+  ui: {
+    presetLabel: '从场景开始', presetFast: '快速网页直播', presetUpload: '日常直播', presetArchive: '4K 存档', resolutionLabel: '分辨率', frameRateLabel: '帧率', codecLabel: '编码器', bitrateLabel: '视频码率', durationLabel: '会话时长', copiesLabel: '保存副本', minutesLabel: '分钟', copiesShort: '副本', h264: 'H.264', h265: 'H.265', av1: 'AV1', codecNote: '编码器效率会改变质量判断，但不会改变存储空间的算术结果。', sceneLabel: '从信号到存储', signalSource: '画面', codecGate: '编码', storageReel: '存储', qualityEstimate: '质量判断', storageEstimate: '预计存储', perCopy: '单个副本', allCopies: '全部副本', perHour: '每小时', frameTime: '帧时间', dataPerFrame: '每帧数据', comparisonLabel: '存储对比', lean: '轻量', balanced: '均衡', crisp: '清晰', qualityLean: '轻量省空间', qualityBalanced: '均衡信号', qualityStrong: '细节充足', qualityExcellent: '余量充足', qualityAggressive: '强压缩', qualityGuidance: '用于比较设置的视觉估算。', capacityLight: '存储占用较小', capacityMedium: '中等存储占用', capacityHeavy: '存储占用较大', capacityNote: '容量状态根据上方显示的副本总数计算。', reset: '重置数值', localNote: '在此浏览器本地运行，不会上传内容。', assumptionTitle: '查看计算假设', assumptionText: '存储使用十进制 GB 和输入的视频码率计算。不包含音频、容器开销、可变码率峰值或文件系统空间。', warningText: '质量等级是规划参考。运动、颗粒、关键帧、编码器预设、平台转码和网络余量都会改变真实结果。', readyText: '修改数值即可重新绘制信号。', calculateAria: '更新视频计划',
+  },
+  faq: [
+    { question: '这个规划器会上传或检查我的视频吗？', answer: '不会。它只使用你在浏览器中输入的数值，不会上传文件、检查摄像头或查询直播服务。' },
+    { question: '存储空间如何计算？', answer: '将码率乘以时长，再除以 8 把比特换算为字节。结果使用十进制 GB，并乘以保存副本的数量。' },
+    { question: '质量判断是什么意思？', answer: '这是根据像素、每秒帧数、码率和宽泛的编码器效率系数得出的参考值。运动和编码器设置也会影响结果，因此它不是画质保证。' },
+    { question: '为什么分辨率或帧率变化后，相同码率的含义也会变化？', answer: '更高分辨率包含更多像素，更高帧率每秒发送更多画面。更多视觉信息需要共享同一个码率。' },
+    { question: '可以把结果当作平台要求吗？', answer: '请把它用于容量规划和方案比较。平台要求会变化，因此应查看目标平台最新的编码指南，并为直播保留上传余量。' },
+  ],
+  howTo: [
+    { name: '选择画面格式', text: '选择与你准备制作的直播或录制相符的分辨率和帧率。' },
+    { name: '设置编码信号', text: '选择编码器并输入 Mbps 格式的视频码率。不确定时可以先使用预设。' },
+    { name: '描述会话', text: '输入分钟数和需要保存、剪辑或交付的副本数量。' },
+    { name: '查看取舍', text: '比较轻量、均衡和清晰等级，提前了解录制前的存储变化。' },
+  ],
+  seo: [
+    { type: 'title', text: '在直播或录制前估算视频存储空间', level: 2 },
+    { type: 'paragraph', html: '视频码率计算器适合需要制定实际存储计划的录制会话。输入码率、时长和副本数量，然后比较同一画面格式下的三种信号等级。' },
+    { type: 'title', text: '规划器会计算什么', level: 3 },
+    { type: 'list', items: ['<strong>存储空间:</strong> 码率乘以时间，从比特换算为十进制 GB，再乘以副本数量。', '<strong>帧时间:</strong> 根据所选 FPS 计算每帧可用的毫秒数，并估算每帧数据。', '<strong>质量判断:</strong> 根据编码器效率系数调整后的每帧像素对比。'] },
+    { type: 'title', text: '分辨率和 FPS 如何改变取舍', level: 3 },
+    { type: 'paragraph', html: '分辨率会增加每帧的像素数量，FPS 会增加每秒的帧数。如果码率不变，每帧能分到的数据就会减少，压缩压力也会增加。' },
+    { type: 'tip', title: '为直播保留网络余量', html: '不要把视频码率视为网络连接的全部容量。应为音频、协议和网络波动留出空间，并使用与真实直播运动情况相近的场景进行测试。' },
+    { type: 'title', text: '最终设置请参考平台指南', level: 3 },
+    { type: 'paragraph', html: '本规划器不绑定特定平台。YouTube 会按照分辨率和帧率发布码率范围。请使用目标平台的最新规则验证这里建立的方案。' },
+    { type: 'title', text: '为什么存储结果只是估算', level: 3 },
+    { type: 'paragraph', html: '名义码率无法描述最终文件中的每个字节。可变码率、音频、容器元数据、关键帧、转码和系统单位都可能改变最终大小。正式制作前应保留实际测试文件，并用它核对容量。' },
+  ],
+});

package/src/tool/videoBitratePlanner/index.ts

@@ -0,0 +1,13 @@
+import { videoBitratePlanner } from './entry';
+import type { ToolDefinition } from '../../types';
+import plannerCss from './video-bitrate-storage-planner.css?raw';
+
+export * from './entry';
+
+export const VIDEO_BITRATE_PLANNER_TOOL: ToolDefinition = {
+  entry: videoBitratePlanner,
+  Component: () => import('./component.astro'),
+  SEOComponent: () => import('./seo.astro'),
+  BibliographyComponent: () => import('./bibliography.astro'),
+  css: plannerCss,
+};

package/src/tool/videoBitratePlanner/locale-content.ts

@@ -0,0 +1,72 @@
+import type { FAQPage, HowTo, SoftwareApplication, Thing, WithContext } from 'schema-dts';
+import { bibliography } from './bibliography';
+import type { ToolLocaleContent, FAQItem, HowToStep, SEOSection } from '../../types';
+import type { VideoBitratePlannerUI } from './ui';
+
+export interface VideoBitrateLocaleData {
+  slug: string;
+  title: string;
+  description: string;
+  ui: VideoBitratePlannerUI;
+  seo: SEOSection[];
+  faq: FAQItem[];
+  howTo: HowToStep[];
+  language: string;
+}
+
+function createFaqSchema(faq: FAQItem[]): WithContext<FAQPage> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  };
+}
+
+function createHowToSchema(data: VideoBitrateLocaleData): WithContext<HowTo> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: data.title,
+    description: data.description,
+    step: data.howTo.map((step, index) => ({
+      '@type': 'HowToStep',
+      position: index + 1,
+      name: step.name,
+      text: step.text,
+    })),
+  };
+}
+
+function createAppSchema(data: VideoBitrateLocaleData): WithContext<SoftwareApplication> {
+  return {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: data.title,
+    description: data.description,
+    applicationCategory: 'UtilityApplication',
+    operatingSystem: 'All',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+    inLanguage: data.language,
+  };
+}
+
+export function createLocalizedContent(data: VideoBitrateLocaleData): ToolLocaleContent<VideoBitratePlannerUI> {
+  const faqSchema = createFaqSchema(data.faq);
+  const howToSchema = createHowToSchema(data);
+  const appSchema = createAppSchema(data);
+  return {
+    slug: data.slug,
+    title: data.title,
+    description: data.description,
+    ui: data.ui,
+    seo: data.seo,
+    faq: data.faq,
+    bibliography,
+    howTo: data.howTo,
+    schemas: [faqSchema as WithContext<Thing>, howToSchema as WithContext<Thing>, appSchema as WithContext<Thing>],
+  };
+}

package/src/tool/videoBitratePlanner/logic.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { calculatePlan, RESOLUTION_PRESETS } from './logic';
+
+const baseInput = {
+  resolutionId: '1080p',
+  fps: 60,
+  codec: 'h264' as const,
+  bitrateMbps: 8,
+  durationMinutes: 60,
+  copies: 1,
+};
+
+describe('video bitrate planner logic', () => {
+  it('contains the supported resolution presets', () => {
+    expect(RESOLUTION_PRESETS.map((item) => item.id)).toEqual(['720p', '1080p', '1440p', '2160p']);
+  });
+
+  it('converts bitrate and duration into storage', () => {
+    const result = calculatePlan(baseInput);
+    expect(result.perCopyGb).toBeCloseTo(3.6, 6);
+    expect(result.bitratePerHourGb).toBeCloseTo(3.6, 6);
+    expect(result.dataPerFrameKb).toBeCloseTo(16.6667, 3);
+  });
+
+  it('multiplies storage by the requested copies', () => {
+    const result = calculatePlan({ ...baseInput, copies: 3, durationMinutes: 90 });
+    expect(result.allCopiesGb).toBeCloseTo(16.2, 6);
+    expect(result.capacityTone).toBe('light');
+  });
+
+  it('recognizes codec efficiency in the quality estimate', () => {
+    const h264 = calculatePlan(baseInput);
+    const av1 = calculatePlan({ ...baseInput, codec: 'av1' });
+    expect(av1.quality.effectiveBpp).toBeGreaterThan(h264.quality.effectiveBpp);
+  });
+
+  it('clamps unsafe or incomplete values to useful defaults', () => {
+    const result = calculatePlan({
+      ...baseInput,
+      fps: Number.NaN,
+      bitrateMbps: -4,
+      durationMinutes: 0,
+      copies: 400,
+    });
+    expect(result.input.fps).toBe(60);
+    expect(result.input.bitrateMbps).toBe(8);
+    expect(result.input.durationMinutes).toBe(60);
+    expect(result.input.copies).toBe(99);
+  });
+});

package/src/tool/videoBitratePlanner/logic.ts

@@ -0,0 +1,158 @@
+export type VideoCodec = 'h264' | 'h265' | 'av1';
+
+export interface ResolutionPreset {
+  id: string;
+  label: string;
+  width: number;
+  height: number;
+}
+
+export interface PlannerInput {
+  resolutionId: string;
+  fps: number;
+  codec: VideoCodec;
+  bitrateMbps: number;
+  durationMinutes: number;
+  copies: number;
+}
+
+export interface QualityResult {
+  label: string;
+  tone: 'lean' | 'balanced' | 'strong' | 'excellent' | 'aggressive';
+  effectiveBpp: number;
+  guidance: string;
+}
+
+export interface ComparisonRow {
+  label: string;
+  bitrateMbps: number;
+  storageGb: number;
+  quality: string;
+  tone: QualityResult['tone'];
+}
+
+export interface PlannerResult {
+  input: PlannerInput;
+  resolution: ResolutionPreset;
+  bitratePerHourGb: number;
+  perCopyGb: number;
+  allCopiesGb: number;
+  frameTimeMs: number;
+  dataPerFrameKb: number;
+  quality: QualityResult;
+  capacityTone: 'light' | 'medium' | 'heavy';
+  comparison: ComparisonRow[];
+}
+
+export const RESOLUTION_PRESETS: ResolutionPreset[] = [
+  { id: '720p', label: '720p', width: 1280, height: 720 },
+  { id: '1080p', label: '1080p', width: 1920, height: 1080 },
+  { id: '1440p', label: '1440p', width: 2560, height: 1440 },
+  { id: '2160p', label: '4K', width: 3840, height: 2160 },
+];
+
+const CODEC_EFFICIENCY: Record<VideoCodec, number> = {
+  h264: 1,
+  h265: 1.35,
+  av1: 1.55,
+};
+
+const QUALITY_GUIDANCE: Record<QualityResult['tone'], string> = {
+  aggressive: 'Expect visible compression in motion or detailed scenes.',
+  lean: 'A compact setting for simple scenes and limited upload capacity.',
+  balanced: 'A practical middle ground for everyday streaming and recording.',
+  strong: 'Healthy headroom for motion, text, and changing scenes.',
+  excellent: 'A generous setting for demanding motion and fine detail.',
+};
+
+function clamp(value: number, minimum: number, maximum: number): number {
+  return Math.min(Math.max(value, minimum), maximum);
+}
+
+function getResolution(id: string): ResolutionPreset {
+  return RESOLUTION_PRESETS.find((item) => item.id === id) ?? RESOLUTION_PRESETS[1]!;
+}
+
+function positive(value: number, fallback: number): number {
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function qualityFromBpp(effectiveBpp: number): QualityResult {
+  const tone = getQualityTone(effectiveBpp);
+  return {
+    label: tone,
+    tone,
+    effectiveBpp,
+    guidance: QUALITY_GUIDANCE[tone],
+  };
+}
+
+function getQualityTone(effectiveBpp: number): QualityResult['tone'] {
+  if (effectiveBpp >= 0.16) return 'excellent';
+  if (effectiveBpp >= 0.1) return 'strong';
+  if (effectiveBpp >= 0.06) return 'balanced';
+  if (effectiveBpp >= 0.03) return 'lean';
+  return 'aggressive';
+}
+
+function estimateBitrate(input: PlannerInput, multiplier: number): number {
+  const resolution = getResolution(input.resolutionId);
+  const base = resolution.width * resolution.height * input.fps * 0.000000061;
+  return Math.max(0.5, base * multiplier / CODEC_EFFICIENCY[input.codec]);
+}
+
+function makeComparison(input: PlannerInput): ComparisonRow[] {
+  const tiers = [
+    { label: 'lean', multiplier: 0.65 },
+    { label: 'balanced', multiplier: 1 },
+    { label: 'crisp', multiplier: 1.45 },
+  ];
+  return tiers.map((tier) => {
+    const bitrateMbps = estimateBitrate(input, tier.multiplier);
+    const effectiveBpp = bitrateMbps * 1000000 * CODEC_EFFICIENCY[input.codec]
+      / (getResolution(input.resolutionId).width * getResolution(input.resolutionId).height * input.fps);
+    const quality = qualityFromBpp(effectiveBpp);
+    return {
+      label: tier.label,
+      bitrateMbps,
+      storageGb: bitrateMbps * input.durationMinutes * 60 / 8 / 1000,
+      quality: quality.label,
+      tone: quality.tone,
+    };
+  });
+}
+
+function capacityFromStorage(storageGb: number): PlannerResult['capacityTone'] {
+  if (storageGb >= 100) return 'heavy';
+  if (storageGb >= 20) return 'medium';
+  return 'light';
+}
+
+export function calculatePlan(rawInput: PlannerInput): PlannerResult {
+  const input: PlannerInput = {
+    resolutionId: rawInput.resolutionId,
+    fps: clamp(positive(rawInput.fps, 60), 1, 240),
+    codec: rawInput.codec,
+    bitrateMbps: clamp(positive(rawInput.bitrateMbps, 8), 0.1, 500),
+    durationMinutes: clamp(positive(rawInput.durationMinutes, 60), 1, 10080),
+    copies: Math.round(clamp(positive(rawInput.copies, 1), 1, 99)),
+  };
+  const resolution = getResolution(input.resolutionId);
+  const bitratePerHourGb = input.bitrateMbps * 60 * 60 / 8 / 1000;
+  const perCopyGb = input.bitrateMbps * input.durationMinutes / 8 / 1000 * 60;
+  const effectiveBpp = input.bitrateMbps * 1000000 * CODEC_EFFICIENCY[input.codec]
+    / (resolution.width * resolution.height * input.fps);
+  const quality = qualityFromBpp(effectiveBpp);
+  return {
+    input,
+    resolution,
+    bitratePerHourGb,
+    perCopyGb,
+    allCopiesGb: perCopyGb * input.copies,
+    frameTimeMs: 1000 / input.fps,
+    dataPerFrameKb: input.bitrateMbps * 1000 / input.fps / 8,
+    quality,
+    capacityTone: capacityFromStorage(perCopyGb * input.copies),
+    comparison: makeComparison(input),
+  };
+}

package/src/tool/videoBitratePlanner/seo.astro

@@ -0,0 +1,15 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { VIDEO_BITRATE_PLANNER_TOOL } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await VIDEO_BITRATE_PLANNER_TOOL.entry.i18n[locale]?.();
+if (!content) return null;
+---
+
+{content.seo?.length > 0 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/videoBitratePlanner/storage.ts

@@ -0,0 +1,31 @@
+import type { PlannerInput } from './logic';
+
+const STORAGE_KEY = 'jjlmoya-video-bitrate-planner';
+
+function isStoredInput(value: unknown): value is Partial<PlannerInput> {
+  return typeof value === 'object' && value !== null;
+}
+
+export function loadPlannerInput(fallback: PlannerInput): PlannerInput {
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return fallback;
+    const parsed: unknown = JSON.parse(raw);
+    if (!isStoredInput(parsed)) return fallback;
+    return { ...fallback, ...parsed };
+  } catch {
+    return fallback;
+  }
+}
+
+export function savePlannerInput(input: PlannerInput): void {
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(input));
+  } catch {}
+}
+
+export function clearPlannerInput(): void {
+  try {
+    window.localStorage.removeItem(STORAGE_KEY);
+  } catch {}
+}

package/src/tool/videoBitratePlanner/ui.ts

@@ -0,0 +1,50 @@
+export interface VideoBitratePlannerUI extends Record<string, string | string[]> {
+  presetLabel: string;
+  presetFast: string;
+  presetUpload: string;
+  presetArchive: string;
+  resolutionLabel: string;
+  frameRateLabel: string;
+  codecLabel: string;
+  bitrateLabel: string;
+  durationLabel: string;
+  copiesLabel: string;
+  minutesLabel: string;
+  copiesShort: string;
+  h264: string;
+  h265: string;
+  av1: string;
+  codecNote: string;
+  sceneLabel: string;
+  signalSource: string;
+  codecGate: string;
+  storageReel: string;
+  qualityEstimate: string;
+  storageEstimate: string;
+  perCopy: string;
+  allCopies: string;
+  perHour: string;
+  frameTime: string;
+  dataPerFrame: string;
+  comparisonLabel: string;
+  lean: string;
+  balanced: string;
+  crisp: string;
+  qualityLean: string;
+  qualityBalanced: string;
+  qualityStrong: string;
+  qualityExcellent: string;
+  qualityAggressive: string;
+  qualityGuidance: string;
+  capacityLight: string;
+  capacityMedium: string;
+  capacityHeavy: string;
+  capacityNote: string;
+  reset: string;
+  localNote: string;
+  assumptionTitle: string;
+  assumptionText: string;
+  warningText: string;
+  readyText: string;
+  calculateAria: string;
+}