NodaroAccount
Docs do Nodaro
DocumentaçãoReferência de nósModelosTemplatesAgentes de IA (MCP)DesenvolvedoresAuto-hospedagemPesquisaComparações
SDK para TypeScript

Edição

Edite podcasts e vídeos longos em TypeScript. Enxugue um episódio, corte clipes, capítulos ou um trailer, sincronize e troque câmeras e renderize uma EDL.

client.edit reúne as ferramentas de edição para podcasts e vídeos longos. Em uma só chamada, ele enxuga um episódio inteiro, lista os capítulos dele, corta um trailer ou um pacote de clipes curtos, ou enquadra a gravação por falante. Também encontra silêncios, alinha várias gravações, descobre quem está em cada câmera, planeja um corte a partir de uma transcrição e renderiza uma lista de decisões de edição (EDL). A maioria dos métodos inicia uma tarefa e retorna o id dela, que você consulta periodicamente com client.jobs.getStatus(). Os métodos estimate... e editPlanCapabilities() não iniciam nada, e remapTranscript() roda localmente, sem requisição.

Métodos

MétodoEndpointO que faz
edit.tightenEpisode(input, options?)POST /v1/tighten-episodeEnxuga uma gravação até virar um episódio pronto, em uma só chamada
edit.episodeChapters(input, options?)POST /v1/episode-chaptersLista os capítulos de uma gravação em uma só chamada. Nada é renderizado
edit.episodeTrailer(input, options?)POST /v1/episode-trailerCorta um trailer de 20 a 40 segundos em cada formato de rede social escolhido
edit.clipPack(input, options?)POST /v1/clip-packCorta uma gravação em um pacote de clipes curtos
edit.speakerLayout(input, options?)POST /v1/speaker-layoutEnquadra uma gravação inteira por falante, sem cortar nada
edit.estimateTightenEpisode(input) e os outros métodos estimate...POST /v1/<type>/estimateFaz a cotação de uma das cinco execuções acima. Nada é criado nem cobrado
edit.continueUseCase(input, options?)POST /v1/<type>/continueContinua uma dessas execuções como uma nova tarefa
edit.silenceDetect(input)POST /v1/silence-detectEncontra os trechos silenciosos de uma fonte de áudio ou vídeo
edit.audioSync(input)POST /v1/audio-syncMede o deslocamento de tempo entre gravações, de 2 a 6
edit.speakerMap(input)POST /v1/speaker-mapDescobre em qual câmera está cada falante, pelos próprios microfones das câmeras
edit.editPlan(input)POST /v1/edit-planPlaneja um corte mais enxuto, clipes curtos, capítulos ou um trailer a partir de uma transcrição
edit.editPlanCapabilities()GET /v1/edit-plan/capabilitiesLê os modos do Plano de edição que este servidor consegue planejar. Nada é cobrado
edit.cameraSwitch(input)POST /v1/camera-switchColoca cada corte de uma EDL na câmera da pessoa que está falando
edit.applyEdl(input)POST /v1/apply-edlRenderiza uma EDL em um vídeo ou um arquivo de áudio
edit.remapTranscript(edl, transcript)Nenhum, localMove os tempos de uma transcrição para a linha do tempo editada

Editar um podcast pelo código

Para um episódio inteiro, tightenEpisode() executa todas as etapas abaixo em uma só chamada. Use as etapas uma a uma quando precisar controlar cada uma delas.

Transcrever a gravação

Execute client.audio.transcribe() com um mecanismo que retorne os tempos por palavra. O output_data.json dele é a transcrição de que o plano precisa.

Encontrar o silêncio

Execute silenceDetect() na gravação principal. O output_data.json dele contém os trechos silenciosos.

Planejar o corte

Execute editPlan() no modo tighten com a transcrição, as fontes e o silêncio. Leia o plano com unwrapEditPlanOutput().

Renderizar

Passe o plano para applyEdl(). A tarefa concluída contém o vídeo ou o áudio editado.

Enviar vídeoO episódioTranscreverTempos por palavraDetectar silêncioPlano de ediçãoEnxugarAplicar EDL
A mesma cadeia de edição em nós: transcrever e encontrar o silêncio, planejar um corte mais enxuto e depois renderizá-lo.
import { unwrapEditPlanOutput } from "@nodaro/sdk"

async function outputOf(jobId: string): Promise<any> {
  for (;;) {
    const { data } = await client.jobs.getStatus(jobId)
    if (data.status === "completed") return data.output_data
    if (data.status === "failed" || data.status === "cancelled") throw new Error(data.error_message ?? data.status)
    await new Promise((resolve) => setTimeout(resolve, 3_000))
  }
}

// 1. Transcribe with word timings
const tr = await client.audio.transcribe({ audioUrl: masterUrl, provider: "elevenlabs-stt" })
const transcript = (await outputOf(tr.jobId)).json

// 2. Find the silence
const sd = await client.edit.silenceDetect({ audioUrl: masterUrl, thresholdDb: -35 })
const silence = (await outputOf(sd.jobId)).json

// 3. Plan a tighter cut
const plan = await client.edit.editPlan({
  mode: "tighten",
  planTier: "standard",
  transcript,
  sources: [{ id: "ep", url: masterUrl, kind: "video", role: "master-audio" }],
  silence,
})
const edl = unwrapEditPlanOutput(await outputOf(plan.jobId))

// 4. Render the plan
const render = await client.edit.applyEdl({ edl, output: "video", quality: "final" })
const { videoUrl } = await outputOf(render.jobId)

As mesmas etapas existem como nós: Transcrever, Detectar silêncio, Plano de edição e Aplicar EDL.

Várias câmeras, passo a passo

Para uma conversa filmada com várias câmeras, adicione três etapas. Transcreva com rótulos de falante, por exemplo com diarize: true.

  1. audioSync() mede a diferença entre os relógios das gravações.
  2. editPlan() com offsets planeja a edição no relógio da gravação principal.
  3. speakerMap() descobre quem está em cada câmera, e cameraSwitch() coloca cada corte na câmera de quem fala.

Depois, renderize a EDL com as trocas usando applyEdl(): primeiro uma prévia, depois a final.

client.edit

Editar uma gravação inteira em uma chamada

Cinco métodos executam uma cadeia de edição inteira em uma só chamada, como os nós correspondentes. Cada um retorna { jobId, executionId?, deduped? } (UseCaseJobResult). Cada um tem um método estimate... que faz a cotação da mesma entrada e não inicia nada. Uma execução custa as etapas dela pelos preços delas, mais uma taxa fixa por execução.

options.idempotencyKey é enviado como o cabeçalho Idempotency-Key. Repita a mesma requisição com a mesma chave, e a resposta é a execução já iniciada, com deduped: true.

Várias gravações de uma conversa

tightenEpisode(), episodeTrailer(), clipPack() e speakerLayout() também aceitam as câmeras de uma conversa (UseCaseRecordingsInput). A execução alinha as gravações, descobre quem está em cada câmera e corta para quem está falando.

Propriedade

Tipo

Envie mediaUrl ou mediaUrls. Os dois, ou nenhum, são recusados com um TypeError antes de qualquer requisição. Várias gravações ou um Áudio principal precisam do Mapa de falantes. Onde o Mapa de falantes não está disponível para você, a requisição é recusada com 403 node_not_available antes de qualquer leitura ou cobrança.

Uma execução concluída com várias gravações ou um Áudio principal acrescenta cameras à saída: { speakers: [{ speaker, ordinal, camera, marginDb }], syncNotes, mapNotes }. Ele diz quem foi colocado em qual gravação, e camera: null significa o plano geral.

const multicam = await client.edit.tightenEpisode({
  mediaUrls: [hostCamUrl, guestCamUrl],
  masterAudioUrl: mixerUrl,
  cameras: { wide: null },
})

edit.tightenEpisode(input, options?) e estimateTightenEpisode(input)

Enxuga a gravação de um podcast em uma só chamada, como faz o nó Enxugar episódio. A execução transcreve a gravação, planeja o corte enxuto e o renderiza. Conforme definido, ela também legenda o episódio, faz o enquadramento e coloca uma trilha de música por baixo. Só a gravação é obrigatória, e um campo omitido usa o padrão do nó.

tightenEpisode(input: TightenEpisodeInput, options?: { idempotencyKey?: string }): Promise<TightenEpisodeJobResult>
estimateTightenEpisode(input: TightenEpisodeInput): Promise<{ data: TightenEpisodeEstimate }>

Propriedade

Tipo

const quote = await client.edit.estimateTightenEpisode({ mediaUrl: episodeUrl })
console.log(quote.data.totalCredits)

const { jobId } = await client.edit.tightenEpisode(
  { mediaUrl: episodeUrl, framing: { aspect: "9:16", layout: "auto" } },
  { idempotencyKey: crypto.randomUUID() },
)

Consulte jobId periodicamente. O output_data da tarefa concluída traz o episódio como videoUrl, ou audioUrl para um episódio de áudio. Também traz a EDL do plano em json, e quality: "proxy" para uma prévia de revisão, "final" nos outros casos.

estimateTightenEpisode() retorna { totalCredits, stepsCredits, feeCredits, durationSec, estimate? }: as etapas da execução pelos preços delas, mais uma taxa fixa por execução. estimate: true significa que uma etapa é a estimativa de uma chamada de LLM medida, então mostre o total como ≈N. A estimativa é alta, porque precifica a renderização pela duração total da gravação antes de a edição ser conhecida. A cobrança segue os minutos realmente renderizados. durationSec é null quando não foi possível ler a duração da gravação. Em uma edição sem créditos, todos os valores em créditos são 0.

Os dois métodos recusam antes de qualquer coisa ser criada ou cobrada:

  • Um 400 traz validation_error, media_unreadable, media_has_no_audio, media_too_long ou music_has_no_audio. Com várias gravações, também pode trazer too_many_recordings, recordings_two_audio_only, wide_camera_out_of_range, invalid_cameras ou master_audio_unreadable.
  • Um 403 traz node_not_available.
  • Um 503 traz nodaro_connection_required, provider_key_missing ou use_case_unavailable. provider_key_missing significa que uma instalação auto-hospedada não tem a chave da transcrição de que uma etapa precisa, nem uma conexão com o Nodaro Cloud que a cubra. A mensagem cita a chave.

tightenEpisode() também lança InsufficientCreditsError quando o saldo não cobre a estimativa. Em uma instalação auto-hospedada, as etapas que rodam no Nodaro Cloud precisam de uma conexão com o Nodaro Cloud.

edit.episodeChapters(input, options?) e estimateEpisodeChapters(input)

Lista os capítulos da gravação de um podcast em uma só chamada, como faz o nó Índice de capítulos. A execução transcreve a gravação e depois planeja os capítulos, cada um com um título e um horário de início. Nada é renderizado.

episodeChapters(input: EpisodeChaptersInput, options?: { idempotencyKey?: string }): Promise<UseCaseJobResult>
estimateEpisodeChapters(input: EpisodeChaptersInput): Promise<{ data: UseCaseEstimate }>

Propriedade

Tipo

const chapters = await client.edit.episodeChapters({ mediaUrl: masterUrl })

O output_data.text da tarefa concluída é a lista de capítulos como notas do episódio: uma linha M:SS Title por capítulo, a primeira em 0:00. Quando um capítulo começa em 1:00:00 ou depois, todas as linhas usam H:MM:SS. output_data.json traz a mesma lista como [{ startMs, title }]. Uma execução que não encontra capítulos falha, e a taxa é reembolsada.

Uma execução do Índice de capítulos não pode ser continuada, porque todas as etapas foram concluídas: continueUseCase() responde 409 continuation_not_failed. Execute de novo no lugar. A estimativa precifica uma gravação cuja duração não pode ser lida como 180 minutos. Os dois métodos recusam com os códigos de tightenEpisode(), exceto os de música.

edit.episodeTrailer(input, options?) e estimateEpisodeTrailer(input)

Corta um trailer de 20 a 40 segundos da gravação de um podcast, como faz o nó Trailer do episódio. A execução planeja o trailer com os momentos mais fortes da gravação e o renderiza. Ela toca um cartão de abertura opcional primeiro e preenche o trailer com margens em cada formato escolhido, sem nunca recortar. O plano escolhe a duração e une os momentos com os próprios crossfades curtos.

episodeTrailer(input: EpisodeTrailerInput, options?: { idempotencyKey?: string }): Promise<UseCaseJobResult>
estimateEpisodeTrailer(input: EpisodeTrailerInput): Promise<{ data: UseCaseEstimate }>

Propriedade

Tipo

O output_data.formats da tarefa concluída é [{ format, url }], um trailer por formato escolhido. output_data.videoUrl é o trailer do primeiro formato renderizado, e json é a EDL do trailer. Em uma prévia de revisão, quality é "proxy", videoUrl é a prévia, e formats fica [] até a Renderização final.

Um formato que não pôde ser renderizado aparece em output_data.failedFormats. A execução é concluída com os outros, mantém a taxa e não cobra esse formato. Uma execução sem nenhum formato renderizado falha, e a taxa é reembolsada.

A estimativa precifica o trailer em 40 segundos, o trailer mais longo que o plano corta. Os dois métodos recusam com os códigos de tightenEpisode(), exceto os de música. Eles acrescentam 400 media_needs_video, 400 intro_card_unreadable para um cartão de abertura que não é um vídeo reproduzível, e 400 intro_card_too_long.

edit.clipPack(input, options?) e estimateClipPack(input)

Corta a gravação de um podcast em um pacote de clipes curtos, como faz o nó Pacote de clipes. A execução planeja os clipes, cada um com um título e um gancho, e renderiza cada um como um clipe próprio. Por padrão, cada clipe de vídeo é enquadrado em 9:16 com os falantes empilhados, e legendado. Uma gravação de áudio gera clipes de áudio, sem enquadramento nem legendas. Com várias câmeras, cada clipe corta para quem está falando.

clipPack(input: ClipPackInput, options?: { idempotencyKey?: string }): Promise<UseCaseJobResult>
estimateClipPack(input: ClipPackInput): Promise<{ data: UseCaseEstimate }>

Propriedade

Tipo

O output_data.clips da tarefa concluída é [{ url, title?, hook?, clipKey, thumbnailUrl?, captionsFailed? }], uma entrada por clipe na ordem do plano. output_data.videoUrl é o primeiro clipe, ou audioUrl para clipes de áudio.

Todos os clipes são tentados. Um clipe que não pôde ser renderizado é pulado, não é cobrado e é contado em output_data.failedClips. Um clipe cujas legendas não puderam ser adicionadas vem sem legendas, marcado com captionsFailed: true, e essas legendas não são cobradas. Uma execução sem nenhum clipe renderizado falha, e a taxa é reembolsada.

A estimativa precifica cada clipe pelo dobro da duração-alvo, e a cobrança segue a duração real de cada clipe. Os dois métodos recusam com os códigos de tightenEpisode(), exceto os de música.

edit.speakerLayout(input, options?) e estimateSpeakerLayout(input)

Enquadra uma gravação inteira por falante, como faz o nó Layout de locutores. O resultado tem a mesma duração: nada é cortado. Com várias gravações, cada falante aparece na própria câmera.

speakerLayout(input: SpeakerLayoutInput, options?: { idempotencyKey?: string }): Promise<UseCaseJobResult>
estimateSpeakerLayout(input: SpeakerLayoutInput): Promise<{ data: UseCaseEstimate }>

Propriedade

Tipo

O output_data.videoUrl da tarefa concluída é o vídeo enquadrado, durationSec a duração dele, json a edição e transcript a transcrição. Uma execução com uma gravação lê o tamanho da gravação antes de começar. Quando você inicia muitas dessas em um minuto, uma pode ser recusada com 429 rate_limit_exceeded: tente de novo daqui a pouco.

A estimativa precifica a Visão de falantes pela taxa mais alta, sobre a duração total da gravação. Os dois métodos recusam com os códigos de tightenEpisode(), exceto os de música.

edit.continueUseCase(input, options?)

Continua uma execução de Enxugar episódio, Índice de capítulos, Trailer do episódio, Pacote de clipes ou Layout de locutores como uma nova tarefa e retorna { jobId, executionId?, deduped? }.

continueUseCase(input: UseCaseContinueInput, options?: { idempotencyKey?: string }): Promise<UseCaseJobResult>

Propriedade

Tipo

Qual rota. Com nodeType, a continuação vai direto para a rota desse tipo. Sem ele, o continueUseCase primeiro lê a tarefa (GET /v1/jobs/:id) para saber o tipo que a execução registra, e depois continua na rota desse tipo. Essa leitura precisa do escopo jobs:read no token de um app conectado. Quando o tipo não pode ser lido, continueUseCase lança um NodaroError com o código use_case_type_unknown (400), e nada é enviado. Passe nodeType para pular a leitura. Uma versão mais antiga do SDK pode não conhecer os tipos mais novos, então atualize-a para continuar essas execuções.

const preview = await client.edit.tightenEpisode({ mediaUrl: episodeUrl, reviewBeforeRender: true })
// ...after a person reviews the preview:
const final = await client.edit.continueUseCase({ jobId: preview.jobId, mode: "render-final" })

Uma Renderização final concluída não impede outra Renderização final da mesma prévia com uma edição alterada. As etapas finais então rodam e são cobradas de novo, ainda sem a taxa. Exatamente a mesma edição outra vez é recusada. As recusas são lançadas antes de qualquer execução existir. Uma recusa que cita outra tarefa lança um ContinuationRefusedError, um NodaroError com status 409, cujo jobId é essa tarefa. Ele tem três códigos. already_running significa que uma continuação está em andamento ou foi concluída: acompanhe-a. continuation_superseded significa que uma continuação posterior também falhou: continue essa no lugar. render_final_already_rendered significa que o resultado dela é o que deve ser usado.

Outras recusas incluem not_found, continuation_not_found, continuation_not_failed e continuation_not_completed. continuation_settling significa que você deve tentar de novo daqui a pouco, e render_final_not_preview significa que a tarefa não é uma prévia de revisão. use_case_nothing_kept (409) é uma revisão de Pacote de clipes que não mantém nenhum clipe. Uma execução que o pagante não consegue cobrir lança InsufficientCreditsError.

edit.silenceDetect(input)

Encontra os trechos silenciosos de uma fonte de áudio ou vídeo. Roda no servidor, sem modelo de IA.

silenceDetect(input: SilenceDetectInput): Promise<{ jobId: string }>

Propriedade

Tipo

const { jobId } = await client.edit.silenceDetect({ audioUrl: masterUrl, minSilenceMs: 900 })

O output_data.json da tarefa concluída é um objeto SilenceRanges: { version, ranges: [{ startMs, endMs }], durationMs }. Passe o objeto inteiro como silence para editPlan(). Uma fonte sem som, como um vídeo só de imagem, faz a tarefa falhar, e os créditos são reembolsados.

edit.audioSync(input)

Mede, pelo som, o deslocamento entre os relógios de 2 a 6 gravações de uma mesma conversa, como faz o nó Sincronizar áudio. Roda no servidor, sem modelo de IA. Custa 11 créditos por fonte depois da primeira: 11 para 2 fontes, 33 para 4 e 55 para 6.

audioSync(input: AudioSyncInput): Promise<{ jobId: string }>

Propriedade

Tipo

const { jobId } = await client.edit.audioSync({
  sources: [
    { id: "mic", url: micUrl },
    { id: "camA", url: camAUrl },
  ],
  reference: "mic",
})
// Wait for the job to finish. output_data is typed unknown, so name the result's type.
let job = (await client.jobs.getStatus(jobId)).data
while (job.status !== "completed" && job.status !== "failed" && job.status !== "cancelled") {
  await new Promise((r) => setTimeout(r, 2000))
  job = (await client.jobs.getStatus(jobId)).data
}
const sync = (job.output_data as { json: AudioSyncResult }).json

O output_data.json da tarefa concluída é um AudioSyncResult:

{
  version: number
  reference: string // the source every offset is measured against
  offsets: Array<{
    sourceId: string
    offsetMs: number              // referenceMs = sourceMs + offsetMs
    confidence: number            // 0 to 1; below 0.5 a note asks you to check by ear
    driftMsPerHour: number | null // measured, never corrected; null when the overlap was too short
  }>
  notes: string[] // low confidence, drift above 33 ms over the overlap, no shared sound
}

Com a gravação principal como reference, cada offsetMs é exatamente o offsetMs dessa fonte na sua EDL. Uma requisição malformada é recusada com um NodaroError cujo code é validation_error, antes que qualquer crédito seja reservado. Isso inclui menos de 2 ou mais de 6 fontes, um id repetido ou um reference que não seja um dos ids.

edit.speakerMap(input)

Descobre em qual câmera está cada falante, pelos próprios microfones das câmeras, como faz o nó Mapa de falantes. Roda no servidor sem modelo de IA, com um preço fixo por execução.

speakerMap(input: SpeakerMapInput): Promise<{ jobId: string }>

Propriedade

Tipo

O output_data.json da tarefa concluída é um SpeakerMapResult, e output_data.edl são as gravações como uma edição no relógio da principal:

{
  version: 1
  speakerMap: Record<string, string>   // speaker label → camera id; "" = no clear camera (the wide shot, else any camera with picture)
  confidence: Record<string, { camera: string; marginDb: number | null }> // the loudest camera's lead over the next
  notes: string[]                      // no clear camera, a camera with no sound, and more
  edl?: Edl                            // the recordings as one edit (also on output_data.edl)
}

Enquanto um falante fala, a câmera que o ouve mais alto, por pelo menos marginDb, é a dele. Uma câmera que não ouviu nada vira uma nota, nunca uma falha. Uma requisição malformada lança um NodaroError (400, validation_error), e uma transcrição sem rótulos de falante lança 422 no_speakers, os dois antes de qualquer crédito ser reservado.

const { jobId } = await client.edit.speakerMap({
  sources: [{ id: "camA", url: camAUrl }, { id: "camB", url: camBUrl }, { id: "wide", url: wideUrl }],
  transcript,
  offsets: sync,          // an audioSync result
  wideSourceId: "wide",
})
// ...wait for the job to finish, as for audioSync above, then:
const map = ((await client.jobs.getStatus(jobId)).data.output_data as { json: SpeakerMapResult }).json
await client.edit.cameraSwitch({ edl, transcript, speakerMapResult: map })

edit.editPlan(input)

Planeja uma edição a partir de uma transcrição com tempos, como faz o nó Plano de edição. Escreve um de quatro tipos de plano: um corte mais enxuto da gravação inteira, um conjunto de clipes curtos, capítulos ou um trailer.

editPlan(input: EditPlanInput): Promise<{ jobId: string }>

Propriedade

Tipo

import { unwrapEditPlanOutput } from "@nodaro/sdk"

const { jobId } = await client.edit.editPlan({
  mode: "clips",
  planTier: "standard",
  transcript,
  sources: [{ id: "ep", url: masterUrl, kind: "video", role: "master-audio" }],
  silence,
  count: 5,
  targetAspect: "9:16",
})
const { data } = await client.jobs.getStatus(jobId) // poll until completed
const clips = unwrapEditPlanOutput(data.output_data) // one EDL per clip

Leia a saída da tarefa concluída com unwrapEditPlanOutput(). Essa função retorna um Edl nos modos tighten e trailer, um array de Edl no modo clips e um ChapterSet no modo chapters.

Com offsets, editPlan() verifica as fontes antes de qualquer requisição. Ele lança um NodaroError com o código edit_plan_sources, citando a fonte, quando uma fonte não foi medida ou teve correspondência fraca, ou quando a principal não foi medida. Nesse caso, defina o offsetMs dessa fonte manualmente. Cada corte vai para a primeira câmera que tem imagem para ele.

Em uma instalação auto-hospedada, este método precisa de uma conexão com o Nodaro Cloud. Sem ela, falha com 503 nodaro_connection_required.

edit.editPlanCapabilities()

Lê os modos do Plano de edição que este servidor consegue planejar (GET /v1/edit-plan/capabilities). Nada é criado nem cobrado. Consulte antes de oferecer um modo, porque editPlan() com um modo que a resposta não lista é recusado com 400 mode_not_available.

editPlanCapabilities(): Promise<EditPlanCapabilities>
CampoTipoDescrição
modesEditPlanMode[]Os modos que este servidor planeja. tighten, clips e chapters sempre aparecem, e trailer quando o servidor consegue planejar um trailer.
source"server" | "nodaro.ai" | "nodaro.ai-unreachable"Quem respondeu: este servidor, o Nodaro Cloud para uma instalação auto-hospedada conectada, ou uma instalação auto-hospedada conectada que não conseguiu alcançar o Nodaro Cloud. No último caso, só tighten, clips e chapters aparecem. Um servidor mais novo pode acrescentar um valor.
perMinutebooleantrue quando o Plano de edição é cobrado por minuto iniciado da gravação. false quando é cobrado pela faixa de duração para a qual a gravação é arredondada. Veja Plano de edição.

A resposta nunca fica em cache, porque uma atualização do servidor pode mudá-la.

const { modes } = await client.edit.editPlanCapabilities()
if (modes.includes("trailer")) {
  await client.edit.editPlan({ mode: "trailer", planTier: "standard", transcript, sources })
}

edit.cameraSwitch(input)

Coloca cada corte de uma EDL na câmera de quem está falando, como faz o nó Troca de câmeras. Tem um preço fixo por execução. Roda no Nodaro Cloud. Uma instalação auto-hospedada a repassa pela conexão com o Nodaro Cloud, e falha com 503 nodaro_connection_required sem ela.

cameraSwitch(input: CameraSwitchInput): Promise<{ jobId: string }>

Propriedade

Tipo

Todos os tempos são números inteiros, e os limites são exportados como CAMERA_SWITCH_BOUNDS de @nodaro/shared/edl. Com uma fonte wide, um plano mais longo que a pausa para o geral mais dois planos mais curtos corta para o plano geral no tempo da pausa, por um plano mais curto. Nos padrões, um plano de mais de 25 segundos corta para o geral aos 20 segundos.

O output_data.json da tarefa concluída é a EDL com as trocas, pronta para applyEdl(). output_data.transcript é a transcrição com speakerNames aplicado. A rota recusa antes de qualquer cobrança:

  • 400 invalid_edl: o edl não é uma edição no relógio da gravação, por exemplo um conjunto de clipes, um plano de capítulos ou a EDL de uma saída renderizada.
  • 400 validation_error: uma configuração está fora do intervalo, ou um nome passa de 80 caracteres.
  • 422 no_speakers: a transcrição não tem rótulos de falante. O SDK também verifica isso antes da requisição.

edit.applyEdl(input)

Renderiza uma lista de decisões de edição em um vídeo ou um arquivo de áudio, como faz o nó Aplicar EDL.

applyEdl(input: ApplyEdlInput): Promise<{ jobId: string }>

Propriedade

Tipo

const { jobId } = await client.edit.applyEdl({ edl, output: "video", quality: "proxy", crossfadeMs: 80 })

O output_data da tarefa concluída traz o corte: videoUrl e thumbnailUrl, ou audioUrl. Também traz a transcrição ajustada em json quando você enviou uma, quality ("proxy" ou "final") e clipKey e planBasis quando você os enviou. Uma renderização proxy é uma prévia e nunca aparece na galeria pública. Veja Prévia e renderização final e os créditos de cada qualidade.

A EDL é verificada antes que qualquer crédito seja reservado. Uma fonte desconhecida, um segmento sem imagem em uma edição de vídeo ou mais de 180 minutos de saída em uma única renderização falham com um NodaroError cujo code é invalid_edl. A duração é medida depois dos crossfades. O message indica o problema, por exemplo, que a edição renderiza 200 minutos e precisa ser dividida em partes de no máximo 180 minutos.

edit.remapTranscript(edl, transcript)

Move uma transcrição para a linha do tempo de uma edição, localmente, sem requisição. Descarta as palavras dentro dos trechos cortados, recorta as palavras que atravessam um corte e desloca todos os tempos para a saída editada. applyEdl() faz o mesmo no servidor quando você passa um transcript para ele.

remapTranscript(edl: Edl, transcript: Transcript): Transcript

Propriedade

Tipo

const editedTranscript = client.edit.remapTranscript(edl, transcript)
// caption the edited video without another transcription

Use-o para legendar uma edição sem renderizar e sem uma segunda transcrição. Ele também é a opção mais rápida para uma transcrição grande quando você só precisa dos novos tempos.

Perguntas frequentes

Como cortar as pausas de um podcast com o SDK do Nodaro?

Transcreva a gravação, execute client.edit.silenceDetect e depois client.edit.editPlan no modo tighten, com a transcrição e os trechos de silêncio. Renderize o plano retornado com client.edit.applyEdl.

Posso enxugar um episódio de podcast em uma só chamada?

Sim. client.edit.tightenEpisode recebe a URL de uma gravação, de vídeo ou de áudio de até 3 horas, e retorna uma tarefa. A execução transcreve, planeja e renderiza o episódio enxuto, com legendas, música e enquadramento opcionais.

Posso editar um podcast gravado com várias câmeras?

Sim. Passe as gravações de uma conversa como mediaUrls, e a faixa da mesa de som como masterAudioUrl, para tightenEpisode, episodeTrailer, clipPack ou speakerLayout. A execução alinha as gravações e corta para quem está falando. Várias gravações precisam do Mapa de falantes: onde ele não está disponível para você, a requisição é recusada com 403 node_not_available.

O que é uma EDL?

Uma lista de decisões de edição (EDL): as fontes de uma edição e os segmentos a manter, em ordem, com as transições. client.edit.editPlan escreve uma EDL, e client.edit.applyEdl a renderiza em um vídeo ou um arquivo de áudio.

Qual é a duração máxima de uma renderização de EDL?

No máximo 180 minutos de saída por renderização. Uma edição mais longa é recusada com invalid_edl antes que qualquer crédito seja reservado. Divida-a em partes.

Quanto custa client.edit.audioSync?

11 créditos por fonte depois da primeira: 11 créditos para 2 gravações, 33 para 4 e 55 para 6.

Última atualização

Nesta página