download vtcff_py - vtcff_py download de código fonte

vtcff

Este projeto é um rascunho e não se destina a ser usado por ninguém.

vtcff é uma biblioteca para transcodificar entre formatos de vídeo, com ênfase na manutenção da qualidade e profundidade de cores nos pipelines de produção de vídeo. Nas tarefas de estúdio, os segundos de vídeo ocupam gigabytes e compromissos de qualidade são menos desejáveis.

vtcff tende a maximizar a qualidade, a velocidade de sacrifício e o espaço em disco.

vtcff é na verdade um invólucro para ffmpeg - a ferramenta de vídeo menos intuitiva já criada.

Instalar

$ pip3 install vtcff

Este comando instalará o pacote, mas não o próprio FFMPEG.

Outras opções

Instale o pré-lançamento no Github:

$ pip3 install git+https://github.com/rtmigo/vtcff_py@staging#egg=vtcff

Exemplo básico

 import subprocess
from vtcff import FfmpegCommand , Scale , Transpose , Hevc

cmd = FfmpegCommand ()

cmd . src_file = '/path/to/source.mov'
cmd . dst_file = '/path/to/target.mov'

# set set some filters
cmd . scale = Scale ( 1920 , 1080 )
cmd . transpose = Transpose . CLOCKWISE

# set compression format
cmd . dst_codec_video = Hevc ( mbps = 100 )

# run command
subprocess . check_call ( list ( cmd ))

Obtendo os argumentos gerados

 import subprocess , os
from vtcff import FfmpegCommand , Prores

cmd = FfmpegCommand ()
cmd . src_file = 'source.mov'
cmd . dst_file = 'target.mov'
cmd . dst_codec_video = Prores ()

print ( str ( cmd ))
# ffmpeg -i source.mov -codec:v prores_ks target.mov

print ( list ( cmd ))
# ['ffmpeg', '-i', 'source.mov', '-codec:v', 'prores_ks', 'target.mov']

# running in different ways:
os . system ( str ( cmd ))
subprocess . run ( list ( cmd ))

Argumentos personalizados

O objeto permite que você especifique manualmente os argumentos do FFMPEG. Argumentos dados dessa maneira têm precedência sobre os argumentos gerados pelo objeto.

 from vtcff import FfmpegCommand

cmd = FfmpegCommand ()

# set arguments as string
cmd . custom . video . string = "-codec:v libx265"
cmd . custom . video . string += "-x265-params lossless=1"

# or as list
cmd . custom . video . list = [ "-codec:v" , "libx265" ]
cmd . custom . video . list . extend ([ "-x265-params" , "lossless=1" ])

O cmd.custom contém quatro campos, que podem ser modificados de forma independente.

Argumentos a serem inseridos antes -i source :

custom.before_i

Argumentos a serem inseridos após -i source :

custom.after_i
custom.video
custom.audio

ZSCale vs escala

ffmpeg possui dois filtros de vídeo para conversões de cor e tamanho de quadro:

scale (LibswScale) é mais versátil
zscale (ZIMG) oferece uma qualidade mais previsível

Por padrão, vtcff usa zscale . Às vezes, isso pode levar a um erro "sem caminho entre os espaços de cores". Se outros métodos não ajudarem, você pode simplesmente substituir zscale pela scale .

cmd.use_zscale == True significa que zscale é usada
cmd.use_zscale == False significa scale é usada

 from vtcff import FfmpegCommand , Scale

cmd = FfmpegCommand ()

assert cmd . use_zscale == True  # by default, it's 'zscale' (zimg) 
cmd . use_zscale = False  # switching to 'scale' (libswscale)

# properties affected:
cmd . scale = Scale ( 1920 , 1080 )
cmd . src_color_space = 'bt709'
cmd . dst_color_space = 'bt2020ncl'
cmd . src_range_full = True
cmd . dst_range_full = False

use_zscale=True , significa que o ZIMG será usado para conversões definidas explicitamente pelas propriedades do objeto. Isso é bom porque essas conversões serão de alta qualidade.

No entanto, conversões implícitas também podem ser necessárias. Por exemplo, antes de processar o PNG de 16 bits com zscale , precisamos converter o formato Pixel de rgba64be em gbrap16le . O FFMPEG fará isso automaticamente com libswscale independentemente da propriedade use_zscale .

Colheita e escala

 from vtcff import FfmpegCommand , Scale , Crop

# crop 10 pixels, then scale
a = FfmpegCommand ()
a . crop = Crop ( left = 10 )
a . scale = Scale ( 1920 , 1080 )

# scale, then crop 10 pixels
b = FfmpegCommand ()
b . scale = Scale ( 1920 , 1080 )
b . crop = Crop ( left = 10 )

Escala proporcionalmente

 from vtcff import FfmpegCommand , Scale

cmd = FfmpegCommand ()

# set height to 1080, automatically compute width 
cmd . scale = Scale ( - 1 , 1080 )

# set height to 1080, select the width as the closest factor 
# of two to the proportional size 
cmd . scale = Scale ( - 2 , 1080 )

Altere a faixa de cores

 from vtcff import FfmpegCommand

cmd = FfmpegCommand ()

# Full/Data/PC range to Limited/Video/TV
cmd . src_range_full = True
cmd . dst_range_full = False

# rec.709 to rec.2020 
cmd . src_color_space = 'bt709'
cmd . dst_color_space = 'bt2020ncl'

Formatos de destino

Codificando para a Apple Proores

 from vtcff import FfmpegCommand , Prores , ProresProfile

cmd = FfmpegCommand ()

# by default it will encode to ProRes 4:2:2
cmd . dst_codec_video = Prores ()

# encode to ProRes 4:2:2 HQ instead 
cmd . dst_codec_video = Prores ( profile = ProresProfile . HQ )

Codificação para HEVC (H.265)

 from vtcff import FfmpegCommand , Hevc , VcPreset

cmd = FfmpegCommand ()

# ideal quality
cmd . dst_codec_video = Hevc ( lossless = True )

# best for bitrate quality
cmd . dst_codec_video = Hevc ( near_lossless = True , mbps = 100 )

# default quality
cmd . dst_codec_video = Hevc ( mbps = 100 )

# all modes can be tweaked with optional speed presets:
cmd . dst_codec_video = Hevc ( mbps = 100 ,
                           preset = VcPreset . N7_SLOW )

Por padrão, o near_lossless está definido para diminuir a velocidade possível VcPreset.N10_PLACEBO , porque estamos tentando maximizar a qualidade. Você pode escolher uma predefinição mais rápida para que o resultado apareça dentro da vida.

Por padrão, o lossless está definido como mais rápido possível VcPreset.N1_ULTRAFAST , porque não estamos perdendo nenhuma qualidade aqui. O tamanho resultante será aproximadamente comparável ao PRESS HQ/XQ e o tempo de codificação é razoável.

Copiando fluxos

Os fluxos de mídia podem ser copiados sem re-codificação e sem perda de qualidade.

No entanto, pode haver alguma perda de metadados - por exemplo, informações sobre faixas de cores e espaços de cores.

 from vtcff import FfmpegCommand , VideoCopy , NoAudio

cmd = FfmpegCommand ()

# changing container from mp4 to mov
cmd . src_file = "source.mp4"
cmd . dst_file = "source.mov"

# keeping video, removing audio
cmd . dst_codec_video = VideoCopy ()
cmd . dst_codec_audio = NoAudio ()

Imagens para vídeos

Convertendo timelapses ou sequências de quadros CGI para Proporcular o arquivo de vídeo.

 import subprocess
from vtcff import FfmpegCommand , Prores , ProresProfile

cmd = FfmpegCommand ()

# input directory will be automatically transformed 
# to a pattern like '/my/dir_with_frames/img_%04.png'   
cmd . src_file = '/my/dir_with_frames'
cmd . src_fps = 29.97

cmd . dst_file = '/videos/timelapse.mov'
cmd . dst_codec_video = Prores ( profile = ProresProfile . HQ )

# images usually have Full/Data/PC color range,
# but most NLEs assume that videos have Limited/Video/TV range
cmd . src_range_full = True
cmd . dst_range_full = False

# we will treat sRGB like Rec.709, 
# although it's a little sad
cmd . src_color_space = 'bt709'
cmd . dst_color_space = 'bt709'

# run command
subprocess . check_call ( list ( cmd ))