No meu post anterior , falei sobre como extraímos conteúdo de arquivos FMV de origem e criamos ferramentas para analisar aproximadamente 67 GB de arquivos em busca de componentes intermediários usados ​​para criar FMV. Essas peças são a base para a criação de conteúdo FMV remasterizado e foram usadas como "desenhos de montagem" para iniciar o projeto.

Conforme declarado no artigo anterior, o fluxo de trabalho de remasterização é dividido em três ramos: remasterização de quadros desenhados à mão, remasterização de modelos 3D e remasterização de som. Abaixo, falarei sobre os recursos do fluxo de trabalho e os truques que usamos para automatizar a criação da parte principal do vídeo.

Aumentamos o tamanho de todos os quadros desenhados à mão originais para corresponder à resolução de 4K (3840x2160). Levando em consideração a adição da largura da cena refeita e o fato de o jogo ter sido exibido em pixels não quadrados, isso significava que todos os recursos remasterizados precisavam ser criados em uma resolução de 4440x2400 pixels.

Decidimos usar o Adobe Animate para remasterizar todos os quadros FMV desenhados à mão, porque já tínhamos um fluxo de trabalho pronto após o desenvolvimento do Day of the Tentacle Remastered. A equipe de artistas dominou bem esse processo, por isso não consideramos outras opções.


Exemplo de remasterização de um quadro desenhado à mão

Os modelos 3D originais dos arquivos estavam no 3D Studio Release 3. Felizmente, as versões modernas do 3D Studio Max foram capazes de importar todos os dados das malhas e dos quadros-chave cinematográficos usando outro script de automação. Depois disso, convertemos esse arquivo intermediário para trabalhar no Autodesk Maya, onde os artistas fazem sua mágica de remasterização.

Para dar às superfícies das malhas um novo estilo, novos shaders foram aplicados, texturas de alta qualidade foram aplicadas e essas malhas foram significativamente suplementadas para dar ao modelo uma aparência mais suave. Além disso, a janela do quadro foi expandida para todas as câmeras de entrada de vídeo para corresponder à resolução de trabalho de 4440x2400 pixels, porque a câmera original foi projetada para uma proporção mais estreita.


Exemplo de remasterização de modelos 3D

Quanto ao áudio, conseguimos encontrar a maioria das versões originais de alta qualidade, mas houve exceções. As gravações do estúdio de dublagem em inglês foram empacotadas em arquivos, mas a dublagem em outros idiomas, contratada por parceiros externos, não estava disponível para nós. Além disso, conseguimos encontrar a música original de The Gone Jackals, usada no FMV. Algumas versões de efeitos sonoros (SFX) foram substituídas por sons mais "apertados" por um tipo de som semelhante.

Abaixo está um fluxograma que explica aproximadamente como processamos os recursos de origem e os vinculamos ao conteúdo remasterizado. Os quadros de vídeo originais extraídos (usando o SanExtract.exe) foram usados ​​como uma "fonte" para comparação com todos os arquivos de dados do arquivo morto. Os arquivos de manifesto de arquivamento são gerados usando uma pesquisa recursiva de todos os dados de arquivamento; eles foram usados ​​para encontrar rapidamente todos os arquivos exclusivos de um determinado tipo.

A ferramenta SanWrangler foi usada para comparar visualmente a "fonte" original de quadros e dados arquivados. O usuário pode anexar visualmente os arquivos archive aos quadros originais e salvá-los como um mapa de dependência no formato XML. Após criar o mapa de dependência, bastava usar um script Python para gerar automaticamente quadros desenhados manualmente a partir dos recursos originais do arquivo "desenho", bem como "desenhos de montagem" para o Maya 3D. Esses arquivos se tornaram o ponto de partida para a equipe de artistas, que passou a remasterizar.


Extraindo recursos originais e criando "desenhos de montagem"

Essa foi a primeira de muitas etapas que resultaram na obtenção de versões remasterizadas do FMV prontas. Sim, é claro, agora temos o ponto de partida de todos os arquivos que precisam ser refeitos, mas como conectar todos esses fragmentos?

Abaixo, falarei sobre os métodos de automação usados ​​no fluxo de trabalho de fabricação do FMV. Esses métodos podem ser usados ​​não apenas para gerar FMV e aplicar não apenas a um jogo; Eu acho que eles são bastante universais e podem ser usados ​​em muitos aspectos do desenvolvimento de jogos.

Como a maioria dos fluxos de trabalho de criação de gráficos, esse processo será iterativo. Em algum lugar do arquivo de origem, pode haver um bug que precisa ser corrigido pelo artista e, às vezes, era necessário reexportar arquivos dependentes de recursos. Acho que todos nós preferimos que esse trabalho seja feito por um computador, e não por uma pessoa propensa a erros.

Sabíamos exatamente como o vídeo do Full Throttle Remastered deveria parecer e soar, então precisávamos melhorar seus gráficos e sons. Todos os vídeos tiveram que corresponder aos originais, quadro a quadro, incluindo caminhos da câmera, volume do som, movimento panorâmico etc. Para conseguir isso, precisávamos saber como era o fluxo de trabalho da criação de FMVs originais. E esses 67 GB de dados dos arquivos da LucasArts continham muitas pistas sobre como tudo funcionava no original. Eles foram um ótimo começo para nós.

O processo de criação do FMV original

Pode parecer um pouco nostálgico, mas acho importante discutir os aspectos da "arqueologia digital" dessa remasterização de jogos. No final, entender o processo de criação do original permitirá que você responda muitas perguntas e dê dicas sobre como os recursos se transformaram em um resultado final. E ao criar novos FMVs refeitos, precisamos aplicar as mesmas transformações aos nossos recursos remasterizados originais, para que o produto final pareça o mais próximo possível do original. Incluindo, precisávamos do seguinte:

• Localização das trilhas de áudio na linha do tempo
• Configurações de volume e pan para faixas de áudio ao jogar no jogo
• Composição do quadro e posicionamento de cada quadro de vídeo no produto final

Uma ferramenta chamada SMUSHFT (SMUSH for Full Throttle) permitiu ao criador do FMV colocar recursos de vídeo e áudio na linha do tempo e depois codificar o filme FMV resultante (no formato .san), que foi lido pelo mecanismo do jogo. Todos os vídeos foram divididos em uma série de quadros que foram colados para criar o resultado final. O SMUSHFT permitiu ao usuário mover visualmente esses recursos ao longo da linha do tempo e, se necessário, refazer o vídeo.

Você não pode mencionar que eu não participei da criação do jogo original. Eu só conseguia adivinhar como os recursos originais foram criados, estudando dados arquivados e analisando formatos e arquivos executáveis ​​compactados nesses dados. Parece que os modelos 3D foram criados no Autodesk 3D Studio Release 3, e as peças desenhadas à mão foram criadas no DeluxePaint Animation v1.0. Também não sei em que estágios a geração de dados de forma de onda para áudio consistia, mas cada clipe de áudio usado (no formato .sad) contém informações sobre o volume e o panorama dos quadros-chave, usados ​​para misturar o som durante o jogo.


O processo de criação do FMV original

Depois de criar essas partes separadas do quadro, o processo de combinação do quadro foi realizado. Esse processo combinou renderizações de quadros 3D com quadros de animação desenhados à mão (junto com todo o resto), criando um produto final usado pela ferramenta SMUSHFT (arquivos .nut). Depois que o projeto estava pronto para a codificação, o vídeo foi processado e o resultado final (.san) já podia ser reproduzido no mecanismo do jogo.

A SMUSHFT executou a codificação final do formato do arquivo do vídeo original (.san) e cada arquivo de vídeo possuía um arquivo de projeto (.pro) descrevendo a montagem do vídeo (som, vídeo, localização das legendas). Queríamos extrair essas informações para gerar o arquivo de projeto do Adobe Premiere Pro e usá-lo para codificar a versão convertida do vídeo em resolução 4K. Para fazer isso, precisávamos fazer engenharia reversa do arquivo de projeto SMUSHFT.

Formatos de arquivo de engenharia reversa

É ótimo ter código fonte, porque você pode apenas estudá-lo e entender como o arquivo do projeto foi criado / lido. Sem o código fonte, é necessário abrir o arquivo do projeto em um editor hexadecimal e analisar os padrões dentro do arquivo. É exatamente assim que usamos para extrair conteúdo útil do arquivo de projeto SMUSHFT.

Como poderíamos executar o SMUSHFT original no DOSBox, vimos a interface do usuário do programa, que nos deu dicas sobre o formato do arquivo. Dê uma olhada nesta captura de tela da abertura do arquivo .pro original:


Projeto SMUSHFT de amostra

Aqui você pode observar o seguinte: existem recursos nomeados no arquivo (2027.NUT, 2027.SAD, IN_06A.NUT, etc.). Esses recursos nomeados provavelmente exibirão caracteres ASCII dentro do arquivo. Além disso, existem contadores de quadros na parte superior da linha do tempo e, à esquerda da linha do tempo, há um número crescente de camadas. E o último - cada recurso na linha do tempo está localizado em um número de quadro específico e tem uma certa duração. Se conseguirmos extrair essas informações dos arquivos originais do projeto, ele nos informará onde colocar automaticamente novos recursos na linha do tempo do Adobe Premiere Pro.


Projeto de amostra do Adobe Premiere Pro

Ao abrir o arquivo do projeto original em um editor hexadecimal, você pode obter algumas informações bastante úteis. Veja o exemplo acima em hexadecimal:


Arquivo de projeto SMUSHFT no Hex Editor

Podemos começar a olhar o arquivo .pro com um editor hexadecimal (prefiro o Hexplorer) e tentar procurar padrões. Você pode encontrar facilmente recursos nomeados no formato ASCII com um byte zero no final. Aproximadamente na mesma área de memória, há um grupo de valores armazenados como curtos (número inteiro de dois bytes). Comparando números exibidos no SMUSHFT com
Os números do arquivo do projeto em formato hexadecimal nos fornecem a base para a conversão correta do arquivo original do projeto em um editor de vídeo moderno como o Adobe Premiere Pro.

Kit de ferramentas de automação

A maior parte desse fluxo de trabalho foi automatizada e não exigiu intervenção humana. Uma das razões para isso foi que o conteúdo de todos os vídeos foi completamente copiado do original; na verdade, estávamos apenas atualizando o conteúdo. E, portanto, praticamente não tivemos a oportunidade de alterar completamente o formato FMV. Nós apenas precisávamos encontrar uma maneira de recriar o vídeo usando recursos de alta resolução, minimizando o tempo gasto no produto.

Primeiro, devo dizer que um passo inicial sério antes de automatizar todo o processo deve ser uma conversa com uma equipe de criadores de conteúdo (gráficos e áudio). O motivo é que a maioria dos processos de automação exige que os criadores sigam um determinado conjunto de regras sobre a preparação de projetos, locais de arquivos, ferramentas usadas etc. Em nosso projeto, isso significava que tínhamos que discutir ferramentas para criar o conteúdo de quadros desenhados à mão, modelos 3D e sons e, em seguida, um editor de vídeo para reunir tudo isso. Também foi necessário concordar sobre quais partes do fluxo de trabalho serão executadas manualmente e quais serão automatizadas.

Como resultado, decidimos o seguinte:

• Os quadros desenhados manualmente serão criados no Adobe Animate com uma resolução de 4440x2400 pixels.
• Modelos e animações 3D serão criados no Autodesk Maya e renderizados manualmente, também com uma resolução de 4440x2400 pixels.
• Os arquivos de áudio serão criados no formato .wav com parâmetros de 48KHz e 16 bits
• Fragmentos do vídeo serão gerados inicialmente automaticamente, e o artista poderá alterar qualquer parte que ele precisar (com algumas exceções)
• As etapas finais da costura e codificação do FMV serão automatizadas

Para tornar as ferramentas o mais automatizadas possível, usamos vários métodos. O Python foi escolhido como a "cola" que conecta tudo, porque é bem expandido por várias bibliotecas, e o código é fácil de escrever e manter. Também aproveitamos o suporte interno para manipulações de arquivos independentes da plataforma (copiar, mover, excluir).

Python - chamando arquivos executáveis, obtendo resultados

A biblioteca de subprocessos do Python foi ideal para nós, pois permite alterar a execução de outros arquivos executáveis ​​e até aguardar a conclusão de suas tarefas. Ele permite que você obtenha o código retornado pelo programa e acesse o buffer stdout & stderr.

import subprocess # The command to execute command = 'SanExtract.exe -f -i credits.san -o \"C:/output_dir/\" ' # Execute the command via subprocess child = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # Wait for process to complete, returns stdout & stderr buffers stdout, stderr = child.communicate() # Retrieve the return code from the process return_code = child.returncode 

Um exemplo de interação com arquivos executáveis ​​em Python

Python - API do Win32

A API do Win32 é muito útil porque nos deu acesso para transmitir mensagens de teclado e mouse do Windows a partir de um script. Por exemplo, você pode criar uma função que clica no mouse em determinadas coordenadas X, Y da tela:

 import win32api def ClickXY(x,y): win32api.SetCursorPos((x,y)) win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,x,y,0,0) win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,x,y,0,0) 

Exemplo de simulação de clique em mouse Python

Você pode até enviar eventos de pressionamento de tecla para o teclado (com ou sem modificadores):

 import win32api import win32con def PressKey(code, modifierCode=None): if modifierCode: win32api.keybd_event(modifierCode, 0, 0, 0) win32api.keybd_event(code, 0, win32con.KEYEVENTF_EXTENDEDKEY | 0, 0) time.sleep(0.021) win32api.keybd_event(code, 0, win32con.KEYEVENTF_EXTENDEDKEY | win32con.KEYEVENTF_KEYUP, 0) if modifierCode: win32api.keybd_event(modifierCode, 0, win32con.KEYEVENTF_KEYUP, 0) 

Exemplo de simulação de teclado Python

Existem muitas outras possibilidades, mas os exemplos acima realmente ajudaram a alcançar nossos objetivos. Você pode enviar eventos do teclado para qualquer programa ativo e ele começará a digitá-los, como se estivéssemos inserindo algo no teclado, incluindo pressionar as teclas de atalho.

Python - visão computacional para clicar em botões

A experiência mais exclusiva foi o uso do software de visão computacional nas ferramentas que não puderam ser automatizadas através de scripts internos. A maioria das ferramentas modernas tem suporte a scripts, mas ainda requer intervenção do usuário. Por exemplo, o 3D Studio Max permite executar arquivos MAXScript na linha de comando. No nosso caso, executamos o script para importar automaticamente o arquivo de malha 3D, após o qual o 3D Studio Max é iniciado automaticamente e exibe a caixa de diálogo Importar forma, na qual o usuário deve clicar nos botões:


Caixa de diálogo Exemplo de importação de formas

Então - escrevemos um script para automação e agora temos que sentar na frente da tela, pressionando as teclas? Em vez de ficar sentado no teclado e esperar a janela pop-up aparecer, podemos fazer o script fazer uma captura de tela, usar a ligação OpenCV ao Python para encontrar o modelo da imagem do botão e clicar automaticamente nele. Aqui está a aparência do modelo de imagem para o exemplo descrito acima.


Modelo de imagem para ok_button.png

Vale ressaltar que o modelo de imagem contém recursos adicionais (texto para “Objeto único” e “Objetos múltiplos”). Isso nos permite obter um resultado de pesquisa mais determinístico. A seguir, é apresentado um exemplo de script Python usado para clicar automaticamente em um local encontrado de um modelo de imagem:

 import cv2 import ImageGrab # "Constants" TEMPLATE_THRESHOLD = 0.25 CLICK_OFFSET = 20 # Read the template image to search for template_image = cv2.imread('images/ok_button.png', 0) # Screenshot the current desktop and load it to a cv2 format screen = ImageGrab.grab() screen.save('screen.png') screen_image = cv2.imread('screen.png', 0) # Search for the template within the screenshot and retrieve search results match_result = cv2.matchTemplate(screen_image, template_image, cv2.TM_SQDIFF_NORMED) min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(match_result) # If below the threshold, it's likely we know where to click if min_val < TEMPLATE_THRESHOLD: ClickXY(min_loc[0]+CLICK_OFFSET, min_loc[1]+CLICK_OFFSET) 

Um exemplo de clicar em um elemento de exibição usando OpenCV, escrito em Python

Todos os exemplos acima são baseados em Python. Mas há momentos em que precisamos de um controle mais preciso sobre o sistema de janelas do sistema operacional Windows. Isso nos levou a desenvolver ferramentas nativas usando a API de automação do Windows.

Windows Native (C ++) - API de automação do Windows

A API de automação do Windows fornece acesso à API de acessibilidade ativa da Microsoft (MSAA) herdada, bem como à API de automação de interface do usuário da Microsoft. Você pode ler mais sobre isso na página da Microsoft .

Como resultado, conseguimos obter solicitações para determinados elementos da interface do Windows (botões, campos de texto, guias, itens de menu), descobrir onde esses elementos estão localizados espacialmente na tela e clicar / interagir com eles. O Windows SDK também possui ferramentas de teste que permitem ver quais propriedades estão disponíveis. Eles nos permitiram descobrir o que pode ser automatizado em cada programa específico.

O aplicativo Inspect.exe é bastante útil para exibir a hierarquia do gerenciamento de janelas do programa; fornece uma idéia aproximada de onde estão localizados objetos, como controles de menu, e como se referir a elementos de janela usando chamadas de API de automação.


Exemplo Inspect.exe

Depois de aprender a hierarquia de controle do programa Windows, você saberá como encontrá-lo no identificador da janela principal e aprenderá como clicar em diferentes elementos através da API:

 #include <WinUser.h> #include <UIAutomation.h> // Click on a sub-menu item given the Window & Menu handles. void ClickSubMenu(HWND hwnd, HMENU hmenu, const char *pMenuName) { // Iterate through the menu items of the window int menu_item_count = GetMenuItemCount(hmenu); for(int menu_id = 0; menu_id < menu_item_count; ++menu_id) { char menu_name[MAX_PATH]; int len = GetMenuString(hmenu, menu_id, reinterpret_cast<LPSTR>(&menu_name[0]), sizeof(menu_name), MF_BYPOSITION); // Look for the specific menu you're searching for and click it // Make sure to set the window active before doing it... if(!strcmp(pMenuName, menu_name)) { // now get the rect and click the center RECT rect; BOOL success = GetMenuItemRect(hwnd, hmenu, menu_id, &rect); if(success) { SetActiveWindow(hwnd); POINT point = GetMiddlePoint(rect); SetCursorPos(point.x, point.y); mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTDOWN, point.x, point.y, 0, 0); mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_LEFTUP, point.x, point.y, 0, 0); Sleep(DO_TASK_INTERVAL_WAIT_MS); } } } } 

Um exemplo de como empurrar um controle de janela em C ++

E, é claro, passar as teclas digitadas na janela ativa também é simples:

 #include <WinUser.h> #include <UIAutomation.h> // Type the character string to the given window handle static void TypeCharacters(HWND window_handle, const char *pString) { int len = strlen(pString); for(int count = 0; count < len; ++count) { SendMessage(window_handle, WM_CHAR, (WPARAM)pString[count], (LPARAM)0); Sleep(CHARACTER_REPEAT_INTERVAL_MS); } } 

Exemplo de simulação de teclado C ++

Obviamente, essas APIs têm muito mais recursos. Descobri que, graças à ferramenta Inspect.exe, você pode esclarecer quais elementos da janela do programa podem ser acessados.

Formatos de texto intermediários

Parte do nosso fluxo de trabalho foi salvar os arquivos em formato de texto e alterar os valores nesses arquivos de texto. No final, as ferramentas possuem uma interface de usuário para alterar o estado dos dados auxiliares. E se você sabe quais devem ser esses dados auxiliares, não é necessário trabalhar com a ferramenta, basta alterar os dados auxiliares. O truque é saber como manipular esses dados de suporte; ao alterar os formatos de arquivo proprietários, isso pode ser um desafio. Não seria legal se todos tivessem um arquivo de texto simples com o qual você possa trabalhar?

O truque é encontrar uma maneira de contornar os formatos de arquivo proprietários usados ​​pela maioria das ferramentas. A solução geralmente é usar as opções de Importação e Exportação encontradas nas ferramentas comerciais mais modernas. Aqui estão alguns exemplos:

O Adobe Premiere Pro salva os arquivos em um formato proprietário, mas você pode importar / exportar projetos como o Final Cut Pro XML. Após exportar para XML, você pode alterar o XML da maneira que precisamos e reimportar o projeto novamente para o Adobe Premiere Pro.

Outro exemplo é a correção das referências de textura usadas no obsoleto formato de malha 3D do Autodesk 3D Studio Release 3. Ao importar o arquivo de malha original, salvamos a malha recém-convertida em um arquivo .fbx intermediário usando caracteres ASCII. Nesse formato, você pode processar um arquivo de texto e substituir todas as linhas de links de textura pelas corretas.

O Adobe Animate / Flash é muito engraçado, pois os arquivos .fla são na verdade um pouco "quebrados". Arquivos zip. No formato não compactado, eles são armazenados no formato XFL, que pode se referir a outros objetos XFL (por exemplo, bitmaps) de uma pasta local. O engenheiro chefe da Double Fine, Oliver Franzke, criou um script Python modificado para compactar / descompactar arquivos .fla usando ZIP, para que possamos criar / modificar esses arquivos.

Exemplos de uso

3D Studio Max

A versão moderna do 3D Studio Max foi usada para importar o arquivo .prj original para a cena e salvar no formato .CIB do formato ASCII. Para cada arquivo .prj que precisava ser convertido, um arquivo MaxScript (.ms) era gerado automaticamente a partir do script Python, semelhante à seguinte:

 importFile "G:\FullThrottle_Backup\FullThrottle_SourceAssets\BENBIKE.PRJ" #noPrompt 

Exemplo de importação de um modelo 3d usando o MaxScript

Depois disso, esse arquivo .ms foi chamado simplesmente pelo comando Python para executar no 3dsmax.exe:

 3dsmax.exe -U MAXScript "C:\FullThrottleRemastered\import_prj.ms" 

Um exemplo de comando de console para chamar um arquivo executável com o arquivo MaxScript especificado

Como mencionado acima, neste caso, o 3D Studio Max abriu uma caixa de diálogo na qual você precisou clicar. O pacote OpenCV com Python ajudou a clicar no botão nesta janela para que o arquivo original seja importado sem a intervenção do usuário. Após a importação do arquivo, uma série de teclas de menu foi pressionada (usando o win32api Python) para iniciar outro arquivo MAXScript, que exportou o modelo como um arquivo .fbx no formato ASCII. Como .fbx foi salvo como um arquivo de texto normal, todas as dependências das dependências de textura do modelo foram substituídas por links para imagens em um formato moderno. Em seguida, o arquivo .fbx modificado foi novamente carregado automaticamente no 3DSMax e exportado como um arquivo .max. Nesse ponto, o arquivo .max pode ser enviado ao artista para remasterização.

Adobe Animate / Flash

O Adobe Animate / Flash foi usado para remasterizar todos os recursos FMV desenhados à mão. Pegamos as molduras originais desenhadas à mão (tamanho 320x200 pixels) encontradas pela ferramenta SanWrangler e as usamos como “desenhos de montagem”. A escala da imagem foi ampliada para caber 4440x2400 pixels, após o que um arquivo .fla foi gerado automaticamente usando um script Python.

Foi o suficiente para gerar automaticamente o arquivo .fla a partir do zero, usando nosso conhecimento do formato XFL Adobe Animate / Flash. Conseguimos usar o kit de ferramentas já criado por Oliver Franzke para gerar desenhos de montagem de arquivos de animação desenhados à mão.

Adobe Premiere Pro

A API de automação do Windows realmente nos ajudou a determinar quais controles do Premiere Pro estão na tela. Em alguns casos, eles não tinham teclas de atalho. Após receber as coordenadas dos itens de menu, foi necessário mover o cursor para essas coordenadas e enviar um evento de clique do mouse.

Tudo isso é ótimo, mas alguns controles são renderizados de outras maneiras e, portanto, são invisíveis para a API de automação do Windows. Nesse caso, decidimos usar um monte de OpenCV e Python para poder usar o OpenCV em um ambiente de script. Isso foi especialmente útil ao trabalhar com o Adobe Premiere Pro: embora tenha suporte parcial para scripts JavaScript, o tipo de controle necessário não estava disponível por meio da API.

Além disso, os arquivos de projeto do Adobe Premiere Pro são armazenados em um formato binário proprietário. Portanto, não podíamos apenas criar magicamente o arquivo do Premiere Pro, mas poderíamos usar a função de importação, o que nos permitia importar os dados para o arquivo do Final Cut Pro, que possui o formato XML. Depois, bastava gerar o arquivo XML correto, posicionando adequadamente todos os recursos na linha do tempo e depois importar automaticamente esse Final Cut Pro .xml para convertê-lo no formato desejado. Em seguida, poderíamos colocar os quadros exportados em uma fila automatizada para combiná-los em um vídeo finalizado.

Todas as etapas

Abaixo está um diagrama de blocos generalizado que mostra todas as partes automatizadas de um novo fluxo de trabalho. Cada segmento automatizado é cercado por um retângulo arredondado com informações adicionais sobre as técnicas de automação usadas.


Fluxograma de automação FMV remasterizado simplificado

Você notará que a maior parte do trabalho com o Adobe Premiere Pro requer o uso de Python, além de código nativo especializado do Windows. O motivo é a estrutura complexa das janelas do Premiere Pro, bem como a necessidade de usar a API nativa do Windows Automation para garantir a interação adequada com todas as janelas filho dependentes desse aplicativo.

Todos juntos

Usando os métodos descritos acima, conseguimos configurar várias máquinas de automação para dividir o trabalho em todos os vídeos em partes. Além disso, um Slack Bot foi integrado ao fluxo de trabalho para enviar feedback sobre automação ao nosso canal Slack, de acordo com o estado dos vídeos que passam pelo pipeline de processamento, para que possamos saber quando algo der errado.


Exemplo de automação do Adobe Premiere Pro

Os problemas que estamos enfrentando

Tudo isso parece ótimo, mas, de fato, ao implementar o projeto, tivemos problemas. Vou listar apenas os pontos principais.

1) Iteração da mistura do áudio final. A remasterização de todos os arquivos de áudio foi realizada gradualmente. Portanto, quando tivemos, por exemplo, o efeito sonoro “BOOM!”, O engenheiro de som não fazia ideia de onde inseri-lo no mix de áudio; portanto, ele teve que esperar que o vídeo fosse codificado para descobrir o que havia dado errado.

2) Armazenamento de arquivos intermediários não compactados. Os quadros foram armazenados em formato não compactado até o último momento da codificação no vídeo final. Portanto, era necessário armazenar um grande número de quadros no armazenamento local, alguns dos quais armazenados no sistema de controle de versão. Esse aumento no volume armazenado foi muito visível e pode ser bastante caro ao usar alguns sistemas de controle de versão (usamos o Perforce).

3) Prazo de execução. Uma parte sólida do fluxo de trabalho foi automatizada, e isso permitiu que os engenheiros fizessem outras coisas. No entanto, o tempo necessário para criar um vídeo pode ser bastante longo. A parte que consome mais tempo é a codificação de quadros em resolução de 4k. Tínhamos maneiras de investigar o estado dos recursos dentro do Perforce para entender quais etapas precisam ser executadas novamente, mas esse método não foi dividido em partes como gostaríamos.

Próximas etapas

Sim, o artigo acabou sendo volumoso! Embora nossa implementação desse fluxo de trabalho seja bastante específica para o projeto, acredito que certos métodos de automação podem ser usados ​​no desenvolvimento de qualquer jogo. Depois de descobrir o vídeo, você pode considerar um tópico relacionado - tocar FMV durante a execução do jogo. Isso inclui problemas como a codificação de um fluxo de áudio multilíngue, bem como a sincronização de quadros ao reproduzir o FMV original. Aguarde a terceira parte do artigo!