Back to Page
Revision 383 (current)
Edited by fsvgm777 on 6/29/2024 8:45 AM
%%TOC%%
!!! Introduction
This page assumes you are already knowledgeable about playback of movies in the emulator. If not, consult [Emulator Resources] for advice on how to set that up first.
According to the [Encoder Guidelines], your emulator should be configured to record video at its native resolution and at full frame rate. The settings you need to do this are listed in the following sections.
!!! Common settings
Dumps should be made with a lossless codec using the RGB colorspace. Under Windows, most of the emulators in use on the site use [https://en.wikipedia.org/wiki/Video_for_Windows|VFW] for their video dumping process. Popular VFW choices include [http://lags.leetcode.net/codec.html|Lagarith] and [https://github.com/umezawatakeshi/utvideo/releases|UtVideo]. These lossless RGB dumps can also be used for taking [screenshots].
Lagarith
* Check __Enable Null Frames__
* Check __Use Multithreading__
* Select __Mode__: RGB (Default)
UtVideo
* Select __UtVideo RGB VCM__ in codec list and configure it
* Set __Intra-frame prediction type__ to __Predict Median__
!! Non-VFW Codecs via pipedec (Windows only)
Many of the emulators listed here dump video via VFW codecs, and must split those videos at 2GB intervals due to limitations in the aging technology. In cases where avoiding these splits is desirable (for instance, emulators that don't handle the split well and desync the audio/video), or where using a more modern codec (like lossless h.264) is preferable to VFW codecs, [https://github.com/vadosnaprimer/pipedec|pipedec] can be used. The following instructions will set up pipedec to use FFmpeg to encode using the lossless UtVideo codec as an example ([https://github.com/umezawatakeshi/utvideo/releases|take the decoder here]), but pipedec can be configured to pipe video to any encoder you want.
# Download a compiled version of pipedec: https://github.com/vadosnaprimer/pipedec/releases/tag/v1
# Install pipedec according to the instructions that come in the download.
#* If you're running a 32-bit emulator (like mupen64) on a 64-bit OS, execute the file called {{register pipedec (32 bit on 64 bit system).reg}}. It should install {{pipedec.dll}} into {{%WinDir%\SysWoW64}}. If that file fails to get moved there, copy it manually.
#* {{%WinDir%}} means your Windows directory, usually it's {{C:\Windows}}. If you simply put {{%WinDir%\SysWoW64}} into Explorer address bar it should instantly bring you there.
# Take {{ffmpeg.exe}} according to the bitness of your Operating System. For a 64-bit OS you can just grab it from https://github.com/TASEmulators/ffmpeg-binaries/blob/master/ffmpeg-4.4.1-static-windows-x64.7z
# Open {{.pipedec}} in a text editor and replace the {{ffmpeg}} path with where you put {{ffmpeg.exe}}. Set the {{avi}} file path to where you want your video created.
# Copy the {{.pipedec}} file to {{%AppData%\pipedec}} (create the folder if it's not there).
# Start up an emulator that uses VFW for dumping, and starting dumping any kind of video so that the VFW codec selection dialog appears.
# You should see ''Pipe Codec'' in the list now. If you don't, you didn't install it correctly. Make sure that you install both the 32- and 64-bit versions if you are using older emulators alongside newer ones.
# Select ''Pipe Codec'' from the list.
# Select the path for the {{avi}} file as usual. Note that it will only contain your audio! The video file is created separately by {{ffmpeg}}.
#* If you don't get any output from pipedec for some reason, open up {{%AppData%/pipedec\stdout.txt}} to see what happened.
# Stop dumping video as normal when finished.
# If everything is working, you should now have two files - the video file that pipedec outputted, and the audio file that the emulator directly created. You will need to mux these files together at some point during the encoding process. To load these files in AVISynth, use {{AviSource("pipedec.avi", pixel_type="RGB24")}}.
!!! Deinterlacing (PSX, N64 with AngryLion, Saturn)
If you come across footage that's interlaced (480i or 576i), it will need to be deinterlaced. This is done with [http://avisynth.nl/index.php/QTGMC|QTGMC]. Download it and all of its dependencies and put them in the AviSynth+ plugins64+ folder. For the dependencies, get the DLLs from the x64 folder (or x64_W7 or x64_W7_AVX2 or x64_msvc for some of the dependencies). You'll also need FFTW3 (mentioned on the QTGMC page) and follow the steps on the QTGMC page (right below the dependencies).
Once everything's set up, you can deinterlace the segments in question. If Weave was used (the dump features combing), the following code is used:
%%SRC_EMBED AviSynth
AVISource("weavesource.avi")
SelectEven()
#AssumeTFF() # uncomment this if you notice the animation being jittery
ConvertToYUV444(chromaresample="point")
QTGMC(preset="Very Slow", SourceMatch=3, lossless=2, truemotion=true, subpel=4, blocksize=32, slmode=4)
%%END_EMBED
If Bob was used instead (the dump features rapidly wobbling lines, also known as "Bobbing"), the following code is used instead:
%%SRC_EMBED AviSynth
AVISource("bobsource.avi")
SeparateFields()
SelectEven()
Weave()
ConvertToYUV444(chromaresample="point")
QTGMC(preset="Very Slow", SourceMatch=3, lossless=2, truemotion=true, subpel=4, blocksize=32, slmode=4)
%%END_EMBED
It should be noted that for N64, everything is dumped at 480 height, so the interlaced segments will need to be isolated in order to leave the segements that don't feature interlacing intact. Something like this does the job (this is a Weave example):
%%SRC_EMBED AviSynth
vid = AVISource("movie.avi")
vid.Trim(0, 395).ConvertToRGB32 + \
vid.Trim(396, 1095) \
.SelectEven() \
.ConvertToYUV444(chromaresample="point") \
.QTGMC(preset="Very Slow", SourceMatch=3, lossless=2, truemotion=true, subpel=4, blocksize=32, slmode=4) \
.ConvertToRGB32() + \
vid.Trim(1096, 0).ConvertToRGB32()
%%END_EMBED
In all cases, it is recommended to save the result to AVI for previewing the result at regular speed, as QTGMC is very slow.
__Important note:__ If the total frame count of the footage that needs deinterlacing is not a multiple of 2, it will add one extraneous frame when deinterlacing (check with {{Subtitle(String(last.FrameCount))}} and cause audio/video desync. To fix, you need to add the following line after deinterlacing (assuming one AVI segment at 480i):
%%SRC_EMBED AviSynth
Trim(0, last.FrameCount-2) # AviSynth+ bug? (last.FrameCount-1 just gives the same total framecount as last.FrameCount)
%%END_EMBED
!!! BizHawk
||Resolution||Sound||
|variable|44.1KHz stereo|
!! Windows
# Select ''Speed/Skip'' to ''0 (never skip)''
# Open the ROM.
# Pause emulation. (Pause key)
# Load the movie.
# Select ''File -> AVI/WAV -> Record AVI/WAV''.
#* If you haven't configured which A/V writer to use, you will be presented with a dialog where you can can choose it.
#** Use ''AVI writer'' for [https://en.wikipedia.org/wiki/Video_for_Windows|regular codecs] you have installed on your OS.
#** Use ''FFmpeg writer'' if you want to [Bizhawk/FAQ#RecordingAVideo|avoid limitations] of the aforementioned codecs (for example if you don't want video to be split on 2GB).
#* Note that Bizhawk 2.3 has a bug in unattended dumping (the video is always upscaled by 2), so use ''Config and Record AVI/WAV'' instead.
# Choose a file name (such as ''raw.avi''), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# Unpause emulation. At this point, audio and video are now being captured.
# When you reach the desired end point, select ''File -> AVI/WAV -> Stop AVI''.
# For some systems, there will be multiple output files, one per resolution; these must be resized and combined into a single uniform resolution.
#* For the WonderSwan, the files instead have to be combined with each file letterboxed, not nonuniformly resized, to the highest height outputted. The [https://github.com/TASEmulators/TASEncodingPackage|TASVideos encoding package] has an example in AviSynth on how to do this.
!! Linux
BizHawk on Linux can dump with ffmpeg. TODO: Describe
!! Alternate Sync
__NOTE__: as of BizHawk 2.6.1, this setting has been renamed to “Sync to Audio”
BizHawk doesn't dump video with variable framerate even if the console outputs it. It's converted to constant framerate, and there are two ways of doing this conversion: audio throttle and clock throttle.
If ''Alternate Sync'' is enabled, "Audio Throttle" is simulated. Video frames are repeated or skipped to sync with audio, whose absolute timing is more accurate and reliable when it comes to variable framerates.
Disabling ''Alternate Sync'' results in "Clock Throttle" for videos. Audio gets stretched to match video frames timings. If there's huge descrepancy between how audio and video are timed, skewed audio pitch will be noticeable to the viewer, so it's generally not recommended to use this approach.
!! System specific settings
! Commodore 64
* Change border type to Normal and reboot the core. Use the same method as [Forum/Posts/440840|SMS] on dealing with the uneven resolution.
! Game Boy/Game Boy Color
* If the movie is using Gambatte in Game Boy Color mode, use the ''Sameboy'' palette.
** If the version of BizHawk is pre-2.9 use the ''VBA Accurate'' palette.
* If the game is using DMG mode (Original Game Boy), use the greyscale palette.
* Enable ''Alternate Sync''/''Sync To Audio'': File -> AVI/WAV -> Config and Record AVI/WAV.
** If the version of BizHawk is pre-X.x do not use this method. [TODO]: figure out which version.
* If the movie uses the Game Link Cable, run the game using the Multi-Disk Bundler under ''Tools'' with GBL selected and with the ROM(s) used in the movie.
! Game Boy Advance
* If the movie uses VBA-Next, enable ''Alternate Sync'': File -> AVI/WAV -> Config and Record AVI/WAV.
! N64
* Enable ''Alternate Sync'': File -> AVI/WAV -> Config and Record AVI/WAV.
* Since [Forum/Topics/20237|Jabo video plugin has been deprecated], no bug fixes or enhancements should be used for it. On the other hand, movies using GLideN64 should have all the enhancements that are possible to pull off. For movies using other plugins, reasonable effort should be invested to try to resync them on GLideN64 and apply possible enhancements.
* In some cases, it's recommended to update the GLideN64 plugin before dumping to get the latest bug fixes and improved accuracy.
** Recommended GLideN64 settings (note that "enhanced" is typically used for SD and HD publications, "accuracy" is listed as settings for anyone wishing to do additional native-resolution encodes with settings that better reflect the N64's native output). Only non-default or notable options are listed here.
*** HW lighting: enabled for enhanced, disabled for accuracy (if you experience severely brightened colors, disable this).
*** Multisampling: disabled (conflicts with other settings).
*** FXAA: enabled for enhanced at resolutions 4K and above, otherwise disabled (can cause visual problems at lower resolutions)
*** Max anisotropy: enabled for enhanced, disabled for accuracy.
*** Bilinear filtering: N64 3-point.
*** Use defaults for current game: unchecked.
*** Copy Depth to RDRAM: use software renderer.
*** Copy Color to RDRAM: copy in sync mode.
*** N64 depth compare: enabled
** Note: Because FXAA is not advised to be used at medium or low resolutions, anti-aliasing is not available on SD dumps. It's recommended you dump at a multiple of the game's internal resolution ("Show Internal Resolution" is a checkbox that can be enabled to discover this) and use [https://github.com/Aktanusa/AreaResize/releases|Aktan's modified AreaResize] AVISynth plugin to resize the dumped footage down to SD, while still preserving the clarity of the game's 2D elements.
! NES
* In Graphics Settings, disable ''Allow more than 8 sprites'' and ''Clip Left and Right Sides''.
* Set drawing area to (0-239) for PAL, and to (8-231) for NTSC.
* In Sound Channels, set APU Volume to 1.
** For VRC6 games with the expansion audio (e.g. Akumajou Densetsu), the APU volume should be set to 5.
* If the movie uses SubNESHawk, enable ''Alternate Sync'': File -> AVI/WAV -> Config and Record AVI/WAV.
! PCE
* Enable ''Sprite Limit''.
! PCE (TurboNyma)
* First rendered scanline: 0
* Last rendered scanline: 239
* Show horizontal overscan: True
! PSX
* Enable Alternate Sync: File -> AVI/WAV -> Config and Record AVI/WAV.
** If the version of BizHawk is pre-2.5 Alternate Sync must only be enabled for PAL titles.
* Resolution Mode: Hardcore Debug Mode
* Horizontal Overscan Clipping: None
* Deinterlacing: Weave or Bob
* For Light Gun titles set the value of the lightgun color to 16777216
On the Nymashock core, as with the Saturn core below since version 2.5, Constant Frame Buffer needs to be set to false and Correct aspect ratio set to true, as well as Show horizontal overscan set to true.
! Saturn (Saturn -> Preferences)
* Resolution Mode: Hardcore Debug
* Horizontal Blend: False
* Horizontal Overscan: True
* ScanlineStartNtsc: 0
* ScanlineEndNtsc: 239
* ScanlineStartPal: 0
* ScanlineEndPal: 255
* For Light Gun titles set the value of the lightgun color to 16777216
BizHawk as of version 2.5 changed the configuration a little. On those, Constant Frame Buffer needs to be set to false, as it mimics Hardcore Debug Mode. Correct aspect ratio should be set to true. The other settings above are kept as is.
! SMS
* If you're using version 1.11.7 or greater, enable ''Overscan''. See [Forum/Posts/440840|this post] for how to handle the resulting uneven resolution.
* Enable ''Sprite Limit''
* Enable ''FM Chip'' if it's a Japanese game (unless this causes a desync)
* Disable ''Overclock''
* Disable ''Stereo Separation''.
! SNES
* If using any pre-2.0 BizHawk version, enable ''Alternate Sync'': File -> AVI/WAV -> Config and Record AVI/WAV.
* For PAL games specifically on the (Sub)BSNESv115+ core: SNES -> Options -> check "Show Overscan".
! Virtual Boy
* VirtualBoy -> Preferences -> ThreeDeeMode: SideBySide.
* Note: Since BizHawk 2.9, the levels adjustment in AviSynth changed. For BizHawk 2.8 and earlier, you need to add {{Levels(0, 1, 255, 0, 157)}} to the script, whereas since 2.9, this has changed to {{Levels(0, 1, 255, 0, 167)}}. Please follow [Forum/Topics/22936|this topic] for more details on any AviSynth adjustments.
!!! Citra
||Resolution||Sound||
|400x480| roughly 32728Hz stereo|
# Make sure no saves are present for the game you want to dump. If there are, right-click on the game and select ''Open Save Data Location''. Go back to the ''title'' folder in the file explorer window that opens, and delete every folder there.
# Under ''Emulation -> Configuration'', go to the ''Graphics'' settings and make sure the ''Internal Resolution'' is set to ''Native (400x240)'', ''Linear Filtering'' is enabled and no ''Post-Processing Shader'' and ''Texture Filter'' are used (''None'').
#* Additionally, ''Stereoscopic 3D Mode'' should be left off, ''Screen Layout'' is set to ''Default'', and everything in the ''Layout'' and ''Utility'' sections unchecked.
#* In the ''Advanced'' tab of the graphics settings, it is not required to ''Enable Hardware Renderer'', but it is recommended anyway, as the emulator runs really slowly otherwise. Everything in the ''Renderer'' section should be checked.
# Under ''Tools -> Dump Video'', select ''AVI'' as the output format and specify a filename path.
#* The audio encoder should be set to ''PCM signed 16-bit little endian''.
#* The video encoder can be either FFV1, libx264rgb or UT Video with the following settings, then click on OK:
#** UT Video: %%% {{pixel_format:gbrp,pred:median}}
#** libx264rgb: %%% {{pixel_format:rgb24,qp:0,preset:veryfast}}
#** FFV1: %%% {{pixel_format:bgr0,level:1}}
# Next, go to ''Tools -> Movie -> Play'' and select the CTM you want to dump. Click on ''OK'', and the game launches in movie playback mode and start dumping to AVI.
# When the movie finishes, the emulator will pause. Select ''Emulation -> Continue'' to unpause emulation and dump the credits.
# When you have reached the desired ending point, select ''Emulation -> Stop'' or close Citra.
Note: The audio starts a bit too early in the AVI dump, but it can be corrected via AviSynth. Just add {{DelayAudio(3.7*4481136.0/268111856)}} to the AVS+ script.
!!! Dega
||Resolution||Sound||
|256x192 (SMS)|44.1KHz mono|
|160x144 (GG)|44.1KHz stereo|
!! Windows
Dega's built-in VFW support is broken (causes audio desyncs), so external capture software is required; for this purpose, [http://www.farb-rausch.de/~fg/kkapture/|.kkapture] is used for its ability to preserve all of the frames in the input at the expected frame rate.
# Open .kkapture.
# Under ''Demo'', select the {{dega}} executable.
# Under ''target'', select the desired target AVI file (such as {{raw.avi}}).
# Set the FPS to 60 for NTSC games or 50 for PAL games.
# Select ''kkapture!''. This will start Dega.
# Make sure ''Sound -> Enhanced PSG'' is unchecked.
# Make sure ''Graphics -> Overlay'' is set to ''None''.
# If applicable, check ''Sound -> FM chip''; use of this is normally specified in the submission text.
# Load the ROM and start movie playback.
# At the appropriate end point, close Dega.
[if:0]When processing the audio for Master System games, be sure to only use one audio channel in order to conserve space (The Master System doesn't actually output in Stereo, the emulator just duplicates the Mono track into a recorded Stereo track), selecting only one audio channel can be done in VirtualDub.
''TODO'': Explain how to do this in VirtualDub.
Just in case anyone comes across this: Every modern audio codec will successfully optimize out stereo tracks that are actually bit identical. So this isn't really needed.
[endif]
!! Linux
# Play back the movie, noting the desired end frame of the video recording.
# Calculate the number of frames past the end of the movie the target end frame is (the length of the movie in frames is specified at the end of the submission text).
# Assuming the movie file is {{movie.mmv}} and the ROM filename is {{rom.sms}}, invoke degavi with the following command line: %%% {{dega -f <number from 2> -m movie.mmv -o raw.avi rom.sms -- -oac pcm -ovc lavc -lavcopts vcodec=ffv1:format=bgr32}}
{{degavi}} will terminate automatically when dumping is done, yielding {{raw.avi}}.
!!! DeSmuME
||Resolution||Sound||
|256x384|44.1KHz stereo|
!! Windows
# Select ''Config -> 3D Settings'' and select ''SoftRasterizer'' as the Renderer.
# Select ''Config -> Frame Skip -> 0''.
# Optionally, uncheck ''Config -> Frame Skip -> Limit framerate''.
# Open the ROM.
# Pause emulation. (Pause key)
# Load the movie.
# Select ''File -> Record AVI''.
# Choose a file name (such as ''raw.avi''), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# Unpause emulation. At this point, audio and video are now being captured.
# When you reach the desired end point, select ''File -> Stop AVI''.
!! Linux
Linux builds of DeSmume do not, at present, have video capture ability. You will need to use [http://winehq.org|Wine].
!!! Dolphin
||Resolution||Sound||
|variable, 4:3 or 16:9|32KHz or 48KHz stereo|
* __Note:__ Dolphin requires a setup and a procedure that may not be friendly to those new to video dumping. It is recommended to try out other emulators if you are.
See this [EncodingGuide/VideoDumping/Dolphin|dedicated page].
!!! DOOM
||Resolution||Sound||
|320x200 (default)|44.1kHz stereo|
* __Note:__ This guide uses feos' customized PrBoom+ setup, which you can get [https://github.com/vadosnaprimer/prboom-plus/releases|here].
* __Note 2:__ This method produces video files that are at 70 fps, but the gameplay footage is actually at 35 fps, with every other frame repeated in the video files.
# If the WAD uses the original DOOM music, get the [http://sc55.duke4.net/games.php|MP3 or Vorbis soundpack] of the SC-55 recordings of the DOOM soundtracks and modify prboom-plus.cfg under the section {{# Music}} to use the sound files.
# If the demo uses a custom PWAD that features higher resolution textures and sprites, in {{prboom-plus.cfg}} you can set the following. Otherwise, leave the settings as is.
#* ''videomode -> OpenGL
#* ''screen_resolution -> 640x400''
#* ''gl_texture_filter -> 2''
#* ''gl_sprite_filter -> 2''
#* ''gl_lightmode -> 3''
#* ''useglgamma -> 0''
# Begin dumping the demo with the command {{prboom-plus -iwad YourIWADFileHere.wad [[-file YourPWADFileHere.wad]] -timedemo YourDemoFileHere.lmp -viddump video.avi}} You can do this either through the command line or with a batch file/bash script. This will produce an AVI file with UTVideo-encocded video and uncompressed PCM audio.
# DOOM demos normally close the game themselves when they're finished. If they don't and you've reached your desired end point, access the menu and quit.
#* [https://github.com/vadosnaprimer/prboom-plus/releases/tag/feos2|feos' build #2] is pre-configured to disable application shutdown after demo end ({{demo_endquit 0}}).
!!! Famtasia
* [user:Dacicus] doesn't understand why so many people are having trouble with Famtasia
<[user:sgrunt|Grunt]> Famtasia *is* trouble.
||Resolution||Sound||
|256x224 (NTSC), 256x240 (PAL)|44.1kHz mono|
* __WARNING__: The emulator dumps video RAW uncompressed in real-time, and in 2 GB segments.[#10]
* __Note__: Make sure you have the [http://bisqwit.iki.fi/utils/famtasiapatch.php|patched] version. The 60 FPS, Windows fix, 240 scanlines[#11], and AVI recording patches are required; the Audio logger must not be selected. The others are optional.
# Start Famtasia
# Config -> Display -> Option: Resolution should be "Window Mode," Size x1, Drawing method should be "Window 8bpp,x1 size"
# Config -> Display -> Option: Check "Disable system messages"
# Config -> Speed: Refresh should be 1, Auto unchecked, ExecSpeed 100, and Windows Occupation all the way to the left
# Config -> Sound: No Reverberation should be checked, Sampling Rate should be 44,100Hz 8Bits
# Open the ROM. (It will instantly start recording upon loading the ROM, you may consider waiting a few seconds for the intro to change to make cropping it off easier)
# Edit -> Movie -> Play -> Play Movie -> click "..." and select the movie you want to record
# When you're done recording, close Famtasia.
!! Making the video files AviSynth-compatible using VirtualDub
# Open the first segment (usually recording00.avi).
# Video -> Compression -> Select Lagarith/CamStudio/your favorite lossless RGB codec and click OK.
# Fix display using the instructions below for NTSC or PAL, as appropriate.
# Save as something else (e.g., recording00_fixed.avi).
# Repeat for each segment.
!!!! Fixing the display using VirtualDub (NTSC)
# Video -> Filters -> Click "Add..." Select "null transform" and click OK.
# With "null transform" selected, click "Cropping."
# Set Y1 offset to 7 and Y2 offset to 9. Click OK twice.
!!!! Fixing the display using VirtualDub (PAL)
# Download [http://www.infognition.com/VirtualDubFilters/detailed.html#185|Emiliano Ferrari's Shift filter] and extract the ef_shift.vdf file into VDub's plugins directory. (Note: [http://www.infognition.com/VirtualDubFilters/detailed.html#83|Simon Walters' ShiftWrap filter] can also do this, but the processing settings aren't saved correctly for batch processing.)
# Video -> Filters -> Click "Add..."
# Select "Shift" in the filters list and click OK. (If it doesn't appear in the list, select "Load..." and navigate to the location of the ef_shift.vdf file.)
# In the Shift configuration dialog, check "Repeat the picture."
# Enter 1 into the Y text box, or click the down arrow once. Click OK twice.
!!! FCEU/FCEUX
||Resolution||Sound||
|256x224 (NTSC), 256x240 (PAL)|48KHz mono|
* If capturing from __FCEU 0.98.12__ or __FCEU 0.98.16__ is needed for any reason, see [Forum/Topics/19567|this thread] and download the "AVIfix" build.
* For 0.98.12, do ''not'' increase emulation speed while dumping.
Download [https://github.com/TASEmulators/BizHawk/blob/master/Assets/NES/Palettes/QuickNes.pal?raw=true|QuickNES Palette]
Within FCEU/X:
* Go to ''Config -> Palette''
* Load Palette
* Select QuickNES Palette
!! Windows
# Start FCEU or FCEUX.
# Select ''Config -> Video'', and check ''Disable hardware acceleration'' (lower left corner).
# Select ''Config -> Sound''. Set ''Rate'' to 48000 and ''Quality'' to high. Set all volume controls to their maximum.
# In qFCEUX 2.5.0 and up, select ''Options -> Movie Options'', and set "libgwavi" as the AVI Backend Driver.
# Open the ROM for the movie.
# Set the emulator speed to about 400% or more (= key); how fast you should go is limited only by the speed of your computer.
# Pause emulation (Pause key).
# Load the target movie file.
# Select ''File -> AVI/Wav -> Record AVI'' (''Movie -> AVI Record As'' in qFCEUX). Choose a file name (such as ''raw.avi''), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# If the movie uses new PPU (check the file header in a text editor), there's a bug that makes on-screen messages, counters, and icons get captured to the video on the first frame. Disable the icons and counters under ''Config -> Display'' and wait for the messages to disappear before unpausing emulation.
# Unpause emulation; audio and video are now being captured.
# Once you have reached your desired capture end point (usually at the end of credits), select ''File -> AVI/Wav -> Stop AVI'' (''Movie -> AVI Stop'' in qFCEUX).
!! Linux
Assuming the ROM is {{rom.nes}} and the fm2 is {{movie.fm2}}, issue the following command:
{{fceux --subtitles 0 --slstart 0 --slend 239 --xscale 1 --yscale 1 --special 0 --pal 0 --sound 1 --soundq 1 --soundrate 48000 --volume 150 --trianglevol 256 --square1vol 256 --square2vol 256 --noisevol 256 --pcmvol 256 --mute 1 --nospritelim 1 --no-config 1 --videolog "mencoder - -o raw.avi -ovc lavc -lavcopts vcodec=ffv1:format=bgr32 -oac pcm -noskip -nocache -mc 0 NESVSETTINGS" --playmov movie.fm2 rom.nes}}
The {{--videolog}} argument for capturing with a more modern tool like ffmpeg is:
{{--videolog "ffmpeg -f s16le -ar 48000 -channels 1 -i /path/to/soundpipe/s.log -f rawvideo -r 60.0998 -s 256x224 -pix_fmt bgr24 -i - -c:a pcm_s16le -c:v libx264rgb -qp 0 -pix_fmt rgb24 output.mkv"}}
Note: Figure out the {{/path/to/soundpipe/}} by setting {{--videolog "NESVSETTINGS"}} once.
Once you have reached your desired capture end point (usually at the end of credits), close the emulator.
In r3325 we added {{--movielength int_number_of_frames}} (experimental) which should automatically terminate the capture along with the emulator. Please let someone know whether this works out for you.
In either case (linux or windows) you could try incorporating this one-liner lua script which should be self-explanatory:
%%SRC_EMBED Lua
while true do
if movie.mode() == "playback" then
emu.frameadvance()
else
os.exit()
end
end
%%END_EMBED
__WARNING__: Dumping video for publications usually requires a human to make sure it's safe to stop dumping, as the game usually keeps providing valuable content after the movie has ended.
!!! Final Burn Alpha
||Resolution||Sound||
|(variable)[#6]|48KHz stereo|
__WARNING__: FBA-rr does not automatically split the video file. It will dump video until the file reaches 4GB, after which the file will be invalid. To overcome this bug, track the size of the dumped video (update the folder containing it and hover the cursor, or check the File Properties), pause the emulator before 2GB is reached, stop dumping and then start again.
# Select ''Audio -> Plugin Options -> 48000Hz samplerate''.
# Load the ROM.
# Pause emulation (Pause key).
# Start movie playback.
# Disable input display (, key) and frame display (. key).
# Select ''Game -> Movie -> Record AVI''. Choose a file name (such as ''raw.avi''), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# Unpause emulation. You are now capturing audio/video in real-time.
# When you reach the desired end point, select ''Game -> Movie -> Stop AVI''.
!!! Gens
||Resolution||Sound||
|320x224 (NTSC), 320x240 (PAL), 256x224 (low resolution mode)|44.1KHz stereo|
__WARNING:__ Use the build of Gens fixed for AVI dumping, [EmulatorResources/Gens|Gens-SplitAVI]. It fixes the frame drop on new segment start, and splits on resolution changes.
# Select ''Graphics -> Frame Skip -> 0''. This enables turbo speed while not skipping frames.
# Make sure ''Graphics -> VSync'' is unchecked.
# Make sure ''Sound -> PSG High Quality'' is unchecked.[#9] This option is not present in the latest svn.
# Check ''Sound -> YM2612 High Quality'' and ''Sound -> DAC High Quality''.
# Uncheck ''Sound -> Soften Filter''.
# Uncheck ''Graphics -> Proper Aspect Ratio in low-resolution mode''.
# If the game is a Sega CD game, uncheck ''Options -> General -> Show Sega-CD LED''.
# Check ''Tools -> AVI -> Clean AVI screen''.
# Check ''Tools -> AVI -> Fit AVI to game height''.
# Uncheck ''Tools -> AVI -> Sync AVI with movie''.
# Uncheck ''Options -> General... -> Message -> Enable''.
# If the game is a 32x game, check ''Sound -> PWM''.
# If using any CamHack build for Sonic games, check ''Graphics-> Layers-> Sprites-> "Sprites always on top"'', then press the "Num Lock" key on your keyboard to remove sprite numbers on screen.
# Open the ROM.
# Pause emulation (Pause key).
# Start movie playback.
# Select ''Tools -> AVI -> Start AVI dump''. Choose a file name (such as ''raw.avi''), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# Unpause emulation. You are now capturing audio/video.
# When you reach the desired end point, select ''Tools -> AVI -> Stop AVI dump''.
!!! Hourglass
||Resolution||Sound||
|(variable)|(variable)|
* __WARNING:__ Playing back Hourglass movies may require the usage of Windows XP, as they may not play back properly in later Windows versions. This emulator may not be a good first choice for those new to encoding.
* __Note:__ Hourglass leaves out the MIDI track from games that use MIDI audio when dumping video and audio. Follow [Forum/Topics/23217|this guide] for instructions on how to extract the MIDI track separately, which will then have to be edited into the dumped audio in post-processing.
* __Note:__ As of [https://github.com/TASEmulators/hourglass-win32/releases/tag/90|r90], if the game's resolution's width is not mod4, it will append columns of pixels to the nearest resolution that's mod4. These will need to be cropped out. For Neko Project 21 in particular on the D3D renderer, the resulting dump will be 644x402, which needs to be cropped out with the following: {{Crop(1, 1, -3, -1)}}. In addition, 100ms of audio need to be trimmed out at the beginning, as the audio buffer is usually set to 100ms. This can be done with {{DelayAudio(-0.1)}}.
* __Note:__ Duplicate frames may get lost upon splitting. To remedy this, using pipedec or x264vfw (and setting the output mode to File) is strongly recommended.
# Figure out the options to get the run to sync (must be mentioned in the submission if they aren't default).
# ''Movie File'' -> ''Browse''. Pick the TAS file.
# ''Game Executable'' -> ''Browse''. Select the game executable.
# ''AVI'' -> check ''Capture Video and Audio''.
# Check ''Fast-Forward''.
# ''Run and Play Existing Movie''. It will then prompt you to locate the output video and to select the codec.
# When it's over, press ''Stop Playing''.
!!! JPC-RR
||Resolution||Sound||
|(variable) [#7]|(variable) [#8]|
__WARNING__: JPC-RR encoding is quite different from other emulators; if you are new to encoding, you should try working with different platforms first.
Get the latest JPC-RR build from [https://github.com/vadosnaprimer/jpcrr/releases|this link], as it has all the tools needed for video dumping.
# From ''Drives -> Import Image'', create the HDD image JPC-RR will use to run the game. Make sure it has all the game files the author used in their run and that the resulting Disk ID matches the one they provided. If the author also provided checksums for each of their game files, make sure they match the checksums for your files as well.
# In ''System -> Assemble'', set ''Fda image'' to "FreeDOS" and ''Hdd image'' to the HDD image you created. Click ''Assemble''.
# Load the movie (JRSR) file under ''Snapshot -> Load -> Movie''.
# Set up the video dump by going to ''System -> Start Dumping''. Name the file you want to save the dump to.
# Start the video dump by clicking ''System -> Start''. The movie playback and dumping will begin.
# When you have reached your desired endpoint, click ''System -> Quit''. The emulator will terminate the dump properly.
# Drag the resulting JMD file onto dumpcovert.exe. The file will be converted into a series of CamStudio-encoded AVI files split by differing resolutions and frame rates.
Some DOS games will occasionally change framerates on certain screens. It is recommended to set all the video splits to the framerate used in gameplay segments using {{ChangeFPS(FPSnumerator, FPSdenominator)}} in your AVISynth script. To know what values you need to provide as numerator and denominator of the desired segment, drag'n'drop that segment onto this executable: https://github.com/vadosnaprimer/avifps/releases
!!! libTAS
||Resolution||Sound||
|(variable)|(variable)|
# Install ffmpeg, or else dumping won't work (e.g. under Ubuntu: {{sudo apt-get install ffmpeg}}).
# In libTAS, set the path to the game to {{/path/to/game}} (or follow the instructions provided in the movie file's annotations)
#* If the movie uses [EmulatorResources/Ruffle|Ruffle] or a [EmulatorResources/PCem|PCem virtual machine], follow the setup instructions on their respective pages along with any additional instructions in the submission page.
#* If the game is a PICO-8 game, set the command line options for the PICO-8 game executable to the following line: {{-windowed 1 -width 256 -height 256}}
# Check ''Movie recording'', then click on ''Browse...''. Select the movie file.
# Under ''Tools'' -> ''Configure encode...'', set the encode file path to {{/path/to/encode.avi}}
#* If you're using a VM, make sure to save to a shared folder both the host OS and the guest OS can access read+write).
#* Make sure to append the {{.avi}} extension, or libTAS won't be able to recognize which format it should output.
# Copy one of the following commands in the ffmpeg options text box, then click ''Ok'':
#* For UTVideo: %%% {{-c:v utvideo -pred median -pix_fmt gbrp -c:a pcm_s16le}}
#* For FFV1: %%% {{-c:v ffv1 -pix_fmt bgr0 -level 1 -g 1 -c:a pcm_s16le}}
#* For H.264 RGB: %%% {{-c:v libx264rgb -qp 0 -preset ultrafast -g 1 -pix_fmt rgb24 -context 1 -c:a pcm_s16le}}
# Start the encode by clicking on ''Tools'' -> ''Start encode''. This will start the encode when launching the game.
# Click ''Start'', then press the Pause key to un-pause if you started the game paused. This will capture audio and video to AVI (even if audio is muted).
# When you reach the desired end point, click on ''Stop'' or close the game window.
__IMPORTANT NOTE WHEN USING H.264 RGB__: If you have x264vfw installed, absolutely make sure to open the AVI in AviSynth with the following line, or else it will use Microsoft's garbage H.264 codec instead:
%%SRC_EMBED avs
AVISource("encode.avi", pixel_type="RGB24", fourCC="X264")
%%END_EMBED
!! Emulators in libTAS
!PCem
There's a 80ms audio buffer that needs to be trimmed out. This can be done with the following:
%%SRC_EMBED avs
DelayAudio(-0.08)
%%END_EMBED
! Neko Project 21 kai
There's a 150ms audio buffer in addition to 5 in-emulator frames that needs to be trimmed out (roughly 0.2386s in total). This can be done with the following:
%%SRC_EMBED avs
DelayAudio(-0.15-(5.0/(last.framerate)))
%%END_EMBED
Additionally, for proper audio (where one channel doesn't drown out the rest), the following settings should be used by editing {{np21kai.cfg}}:
volume_F = 64
volume_S = 25
volume_A = 64
volume_P = 90
volume_R = 64
These are the actual defaults used by {{xnp21kai}} if you go to ''Device -> Sound option'' and then click on ''Default''; however, that menu is unavailable on {{sdlnp21kai}}, but these settings are identical between the two.
! MAME
Before dumping, ensure that the command-line arguments mentioned in [EmulatorResources/MAME|this page] are present. The sampling rate in libTAS should be set to 48000 Hz (Sound -> Format -> 48000 Hz), as it outputs at that rate, otherwise, the audio quality may be degraded a bit. Additionally, the first frame is surrounded by grey borders. This can be remedied by doing either of the following:
%%SRC_EMBED avs
video = AVISource("blah.avi")
blk = BlankClip(video, 1)
blk + video.Trim(1, 0)
%%END_EMBED
or
%%SRC_EMBED avs
last.Trim(0,1).crop(1,1,-1,-1).AddBorders(1,1,1,1) + last.Trim(2,0)
%%END_EMBED
The audio buffer that needs trimming is 5 in-game frames. To remove it, use the following code:
%%SRC_EMBED avs
DelayAudio(-5.0/(Float(last.FrameRateNumerator)/Float(last.FrameRateDenominator)))
%%END_EMBED
For {{cdimono1}} specifically (PAL CD-i Mono I), the top 22 rows of pixels need to be cropped out:
%%SRC_EMBED avs
Crop(0, 22, -0, -0)
%%END_EMBED
! ScummVM
If the dump messes up when starting the dump before launching the emulator, you need to start dumping after launching the emulator while paused (so on frame 1). Note that that one frame will be lost; however, as it's a black frame, it can be simply re-added back in with the following:
%%SRC_EMBED avs
a = AviSource("movie.avi", pixel_type=pixelType)
BlankClip(a, 1) + a
%%END_EMBED
! Ruffle
If the resulting dump has a skewed video output, specify {{-g gl}} in the command-line options.
Note that the colours are washed out when using OpenGL on more recent Ruffle releases up until the 2023-05-24 nightly release (i.e. should be fixed by the 2023-05-25 nightly). TODO: Figure out when the colours became washed out. In such cases, make sure you're on libTAS 1.4.4 and the drivers are up to date, and see if the TAS syncs there instead using the Vulkan (default) renderer)
This, of course, does not affect dumps done with the Vulkan renderer.
If the AVI dump includes the GUI due to the author omitting {{--no-gui}} on build [https://github.com/ruffle-rs/ruffle/releases/tag/nightly-2023-08-03|2023-08-03] or newer, the top 24 rows of pixels need to be cropped out with the following:
%%SRC_EMBED avs
AviSource("movie.avi", pixel_type=pixelType).Crop(0, 24, -0, -0)
%%END_EMBED
!!! lsnes
||Resolution||Sound||
|256/512x224/240/448/480|44.1 KHz stereo|
# Open the emulator, load the ROM.
# Select load movie/savestate tab, select the movie, check start paused and hit ok.
# Set {{avi-soundrate}} to 5 (Settings, Advanced tab, or {{set-setting avi-soundrate 5}}). In lsnes-rr2, set ''AVI Sound mode'' to ''High quality 48kHz'' instead.
# Select AVI capture (CamStudio / PCM) from capture menu.
# Set speed to turbo (or other desired speed).
# If you want to, you can mute audio by unchecking Config->Sounds enabled. This won't affect dumped audio.
# Unpause the emulator
# When reaching the end, select end avi dump.
# Close the emulator.
* On Linux, TSCC can be used instead of CamStudio (it is usually bit faster and compresses better).
** The reason not to use that on Windows is the difficulty decoding it using VfW.
* If you're having issues with black screens not being completely black, use an __rrtest__ build from [https://lsnes.tasbot.net/].
!!! MAME-RR
||Resolution||Sound||
|Variable|48KHz|
All the settings should be default.
Put your rom into mame-rr's {{roms}} folder and the movie near mame-rr.exe. Use the following command line (assuming your ROM name is {{myrom.zip}}, and your movie name is {{myrom.mar}}):
%%SRC_EMBED batch
mame-rr myrom -aviwrite myrom.avi -playback myrom.mar
%%END_EMBED
Alternatively, save this script as {{dump_avi.bat}}, put near mame-rr.exe, run it, and type in things into the console window as prompted:
%%SRC_EMBED batch
@echo off
echo Type ROM name (without extension):
set /p ROM=
echo Type movie name (without extension):
set /p MOVIE=
echo Type AVI name (without extension):
set /p AVI=
mame-rr %ROM% -aviwrite %AVI%.avi -playback %MOVIE%.mar
%%END_EMBED
Unpause the emulator ({{P}} key by default), since it autopauses to prevent timestamp desync. When you're done, just close the emulator. That will properly stop AVI dumping. The AVI file will appear in the {{snap}} folder.
* __NOTE:__ mame-rr v0.1-beta reports the intended aspect ratio for each game, make sure to use it when encoding.
* __NOTE:__ mame-rr v0.1-beta splits the dump at 2GB, but might desync if the run was made on -alpha, so check if it syncs and use -beta. Splitting is needed to avoid the annoyance with [Forum/Posts/448290|fixing the broken frames] at 2GB border.
!!! Mednafen
||Resolution||Sound||
|(variable)[#4]|44.1KHz stereo|
!! Windows or linux
# Use the following command-line to launch Mednafen and automatically start movie playback and .mmm recording: %%% {{mednafen.exe -mmm 1 -mmmfile "where\to\save\movie.mmm" -mmmframes 5000 -mov "path\to\movie.mcm" -play 1 "path\to\rom.pce"}}
#* Change 5000 by the number of frames you want to dump.''
# Now transfert the {{.mmm}} file on Linux to convert it to {{.mov}} (quicktime).
!! Linux only
* You will need to compile the transcoder yourself on Linux
** Souce: https://storage.googleapis.com/google-code-archive-source/v2/code.google.com/mednafen-rr/source-archive.zip
* Install the following dependencies: %%% {{sudo apt-get install subversion build-essential automake autoconf libtool patchutils binutils libc6-dev bison flex gawk gettext imagemagick zlib1g-dev libsndfile-dev libquicktime-dev}}
* Go to {{mednafen-rr/trunk/mednafen-mmmencode}}, execute %%% {{sudo chmod +x ./autogen.sh}}
* Edit {{./po/Makefile.in.in}} and change the {{GETTEXT_MACRO_VERSION}} version to {{0.19}}
* Run
%%SRC_EMBED bash
./autogen.sh
sudo ./configure
sudo make
sudo make install
%%END_EMBED
* You will find the program in {{/usr/local/bin/}}
* Once compiled, go in the folder containing the .mmm file and use the following commang to convert it: %%% {{mednafen-mmmencode mymovie.mmm}}
* You will have a {{test.mov}} file
** If the command {{mednafen-mmmencode}} is not recognized, make sure the program exist in the {{/usr/local/bin}} folder. If it exists there, this means {{/usr/local/bin}} is not in your $PATH variable, so use this command instead: %%% {{{/usr/local/bin/mednafen-mmmencode mymovie.mmm}}}
* Open the QuickTime movie in VirtualDub with the FFInput Plugin to convert it to .avi
* ''File -> Aave as AVI''
!!! Mupen64
||Resolution||Sound||
|variable, normally 320x240 (or multiple thereof)[#2]|44.1KHz stereo|
__NOTE__: This guide is focused on the use of AngryLion as the video plugin. while it should sync for most games, it’s not guaranteed. If a game doesn’t sync on AngryLion, you will have to use different plugins and figure out a different method.
!! Guide
! Windows
It is recommended that you use the TASVideos Mupen64 package as it contains all the plugins and extra files you’ll need. You can [https://github.com/TASEmulators/mupen64-rr-lua-/releases/latest|download it here].
# Start Mupen.
# ''Options -> Settings -> General ->'' uncheck ''Limit FPS (auto)''.
# ''Options -> Settings -> Advanced ->'' uncheck ''Force Internal AVI Capture''
# ''Options -> Settings -> Other ->'' select ''Audio-Authoritative Sync''
# ''Options -> Settings -> Config Plugins ->'' select ''AngryLion'' as the video plugin and ''Jabo’s audio plugin'' for audio.
# On the plugins page, select ''Config'' for AngryLion and do the following:
#* Un-Check ''Multithreaded Rendering''
#* Select ''Filtered'' for output mode
#* Leave the rest of the settings unchecked (however if the game is interlaced, check ''Bob deinterlacing'')
#* Click ''Apply'' then close the window.
# Load your game ROM
# ''Utilities -> Movie -> Start Movie Playback''
#* Select the movie to play back
#* Check ''Open Read-Only''
#* Enter 0 for ''Pause at frame:''
#* Click ''OK''
#* The movie should now be paused on the first frame. Alternately, pause the game that's currently running, and then load the movie file, as it will start playback as soon as you unpause (or rather, the ROM gets reset).
# ''Utilities -> Movie -> Start AVI capture'' and select the desired location for the dump, as well as select your desired codec. This will start dumping video. __Do not__ pause the emulator at all during playback or the movie will desync.
# Once you reach the desired ending point, go to ''Utilities -> Movie -> Stop AVI capture''
!! Old Guide
__WARNING__: Mupen64 is notoriously unstable and difficult to work with. If you are new to encoding, you should try working with different platforms first.
* http://code.google.com/p/glidehqplusglitch64/downloads/detail?name=Glide64_Final.zip
* http://rustedlogic.net/wikiold/index.php?title=Nintendo_64_Emulation_plugins
! Windows
Mupen64's built-in dumping is very unreliable and should not be used at all. [user:Aktan] has developed the following alternate dumping method using [http://www.mediafire.com/?yvayu3xhxnqn5ow|a modified build of .kkapture]. It is recommended, where possible, to use the [http://glide64.emuxhaven.net/files/Glide64_Final.zip|Glide64 'Final'] video plugin and [http://www.emutalk.net/threads/27610-Audio-v0.56-WIP2-Download-Feedback|Azimer's audio plugin] (both plugins are mirrored [http://tv-games.ru/emulator/open/n64_plugins.html|on that page]); some segments of the following set of instructions may assume the use of those plugins.
# __Make a backup of your plugin directory__ so that your old settings are preserved, as necessary. Also backup glide3x.dll in your Mupen64 root directory.
# Place the above plugins into your Mupen plugins directory, and glide3x.dll from the "wrapper" directory in the Glide64 package into the Mupen64 base directory.
# Edit Plugins/Glide64.ini; change instances of "filtering = 1" to "filtering = 0", and "hotkeys = 1" to "hotkeys = 0".
# Start Mupen.
# Options -> Settings -> General -> uncheck "Limit FPS (auto)".
# Options -> Settings -> Config Plugins -> select Glide64 Napalm WX as the video plugin and Azimer's audio plugin for audio.
# Go into the Glide64 configuration dialogue, check "show advanced emulation options", and close and reopen the dialogue.
# Set video options as seen [http://imgur.com/IzHELMZ|here] and [http://imgur.com/zLS2E8d|here]. (Note: "use frame buffer objects" may be necessary for some video cards).
# Select a video resolution that is a multiple of 320x240 (or 342x256), but smaller than your screen size ([EncoderGuidelines#Antialiasing|antialiasing]).
# Load your game ROM, and observe the Glide64 text at the bottom of the screen. You should see "Filtering: Automatic" specified. If it's not, you will need to exit Mupen64 and edit Glide64.ini as described in step 3.
# Utilities -> Movies -> Start Movie Playback. Select the movie to play back, check "Open Read-Only", and enter 1 for "Pause at frame:". Click OK. The movie should now be paused on the first frame.
# Make a save state.
# Close Mupen.
# Check that there are no .eep files for your game in the Save directory in the Mupen root directory (playback from .kkapture as follows doesn't clear these files out, and their presence can cause desyncs).
# Start .kkapture; configure it as seen [http://imgur.com/1hgq26p|here]. Note in particular the frame rate (120fps); this is to ensure that all frames in 60fps segments are captured. There will be a lot of duplicate frames in the output; as such, use of a codec such as Lagarith that can store null frames is suggested.
# Set "Demo" to your Mupen executable and set "Target" to a target filename, then click "kkapture!". Mupen will start.
# Load the game ROM; wait for the Glide64 text to disappear (and ideally for a recognisable action to appear on the screen, so that you know when playback of the movie starts).
# Pause Mupen.
# Utilities -> Movies -> Start Movie Playback; select the movie as earlier, __check "Open Read-Only"__, and click OK (don't specify a pause frame).
# Load your save state from earlier.
# Unpause Mupen - you are now capturing. Do not attempt to move any part of the emulator window off-screen - it will ruin rendering on the off-screen area.
# At the end of desired playback, highlight a non-Mupen window and press the right CTRL key. (__WARNING:__ this means you can't use right CTRL during video capture!) Mupen will exit upon doing so.
Some notes on this method:
# The capture may have an extra 20 pixel border at the bottom, which should be cropped out.
# The audio plugin may add a audio delay of around 192 ms (could be a function of the sound card).
# Duplicate frame removal is strongly recommended for captures using this method, given the number of duplicate frames in the video dump.
# The sound output may not be 44.1kHz. If it is not, it will generally be a very odd sampling rate, and you may resample the sound track to be 44.1kHz.
# On certain games, the capture FPS can be set to 60 FPS for a smoother capture.
! Linux
There is no known completely reliable way to get stock builds of Mupen to play back effectively on Linux with video dumping. Some encoders have reported success with [http://winehq.org|Wine]; for others it fails miserably. At least two encoders have modified builds of Mupen in order to dump video reliably; ask on the forums for more information.
!!! openMSX
||Resolution||Sound||
|640x480|44.1 KHz mono/stereo|
openMSX dumps video with the lossless ZMBV (Zipped Motion-Blocks Video) codec and audio in uncompressed WAV. The ZMBV encoder is built in (and will thus work on any platform). On Windows, openMSX comes with a separate codec dll to be able to play the resulting AVI on any installed media player. Make you sure you install that dll to be able to import the AVI file to AVISynth and preview it in VirtualDub.
The resolution used in this guide is 480p, but some games can safely be downscaled to 240p. [https://www.msx.org/wiki/SCREEN|Here's a list of resolutions] MSX screen modes use. Run the replay as described below and type {{toggle_info_panel}} in openMSX internal console, that will tell you the mode used by the game (only the mode used for actual gameplay is relevant here).
__IMPORTANT NOTES__
* The replay file doesn't necessarily have to be on:
** {{C:\Documents and Settings\<user>\My Documents\openMSX\replays}} (for Windows XP);
** or on {{C:\Users\<user>\Documents\openMSX\replays}} (for Vista/Windows 7);
** or on {{/home}} ({{Users}} if you're using a Mac);
** {{/<user>/.openMSX/replays}} (for Linux / Mac) (where {{<user>}} is your user folder)
but it's highly recommended that the replay is in that folder, as it'll be a bit easier to load the replay file.
* As openMSX will use the __exact same__ machine as specified in the replay file, you also need the system ROMs for that machine, which is explained [http://openmsx.org/manual/setup.html#romlocation|in the openMSX Setup Guide]. Of course, we don't provide them here.
* If you get unlucky enough to experience openmsx switch the framerate on the fly during video recording, it'd cause an av desync. To fight it, make use of [https://gist.github.com/FiXato/475752|this tcl script], it would split the file on each fps change.
!! Windows
The easiest way is to use this script.
%%SRC_EMBED batch
@echo off
cd /d "%~dp0"
echo record start -doublesize ./movie.avi > dump.tcl
openmsx %1 -script dump.tcl
%%END_EMBED
Save this as a batch file ({{something.bat}}) near your {{openmsx.exe}}, put the movie there too, and drag'n'drop the movie onto the script. {{movie.avi}} dump will appear in the same directory. When you're done, just close the emulator, it will properly stop the video recording.
The following is the old, manual way.
# Method 1: load manually from the console
## Open Catapult (openMSX GUI) or openMSX (non-GUI).
## In case you started Catapult, start openMSX with the ''Start'' button.
## In the openMSX window where the emulation is running, hit ''Pause'' to pause emulation.
## Hit ''F10'' to bring up the openMSX console.
## Type {{reverse loadreplay -viewonly <replay>}} (where {{<replay>}} is the replay file you want to dump as AVI), then hit ''Enter''. You can use TAB-completion to find the replay file easier.
# Method 2: auto load
## Drop the replay on openMSX.exe (or start openMSX from the command line with the replay file as only argument)
## In the openMSX window where the emulation is running, hit ''Pause'' to pause emulation.
## Hit ''F10'' to bring up the openMSX console.
## Type {{reverse goto 0}} to jump back to the beginning of the replay
# Type {{record start -doublesize raw}} (where {{raw}} is the file name of the AVI, then hit Enter. You are now capturing audio/video.
#* __Note__: the reason why {{-doublesize}} is needed is because some MSX2 modes are 512x212
#* __Note__: it will automatically detect if the currently emulated MSX can output stereo sound or mono sound and use that in the resulting AVI
# Unpause emulation. (''Pause'' key)
# Hit ''F9'' to speed up emulation (if you don't want to wait for the whole movie to play at normal time).
# When you reach the desired end point, pause emulation, type {{record stop}}, then hit ''Enter''.
The AVI dump is to be found on {{C:\Documents and Settings\<user>\My Documents\openMSX\videos}} (for Windows XP) or on {{C:\Users\<user>\Documents\openMSX\videos}} (for Vista/Windows 7) (where {{<user>}} is your user folder)
!! Linux / Mac
# Basically the same as for Windows, except that the AVI file is to be found on {{/home}} ({{Users}} if you're using a Mac){{/<user>/.openMSX/videos}} (where {{<user>}} is your user folder).
# The hot keys to open the console, pause and speed up emulation are different on Mac, though, [http://openmsx.org/manual/user.html#keymapping|see the openMSX User's manual].
If you don't know if the emulated MSX can output mono or stereo sound, open the AVI dump in any media player, e.g. VLC or MPlayer.
This whole guide can also be found (in other words) [http://openmsx.org/manual/faq.html#perfect_videos|in the openMSX FAQ part of the manual].
For more information about openMSX, please check [http://openmsx.org/manual/|the complete openMSX manual].
!!! PCEjin
||Resolution||Sound||
|(variable)[#5]|44.1KHz stereo|
!! Windows
# Load the ROM.
# Turn on Fast-Forward mode by pressing T.
# Pause emulation. (Pause key)
# Load the movie file.
# Select ''File -> Record AVI''. Choose a file name (such as {{raw.avi}}), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# Unpause emulation. At this point, audio and video are now being captured in real-time.
# When you reach the desired end point, select ''File -> Stop AVI''.
!! Linux
PCEjin is Windows-only, but works well with [http://winehq.org|Wine]. You may also be able to play back the movie with recent builds of Mednafen (see above).
!!! PCSX
||Resolution||Sound||
|(variable)[#3]|44.1KHz stereo|
* __WARNING__: PCSX is not particularly stable and requires an unusual video dumping setup. It also dumps video files that may require a not-insignificant amount of video post-processing effort. It is not a good first choice of emulator for new encoders.
* __NOTE__: Don't forget to pick the bios. SCPH-1001 for NTSC-U, SCPH-1000 for NTSC-J, SCPH-1002 for PAL. If you have problems, ask the judge or the author.
[user:Spikestuff] has [https://files.tasvideos.org/common/PcsxrrEncodeWofkflow/SyncNotes.txt|compiled sync notes] for each problematic movie.
* __NOTE__: If it's a multi-disc movie, leave the ISO path field in the CD-ROM config blank. That will let you select both discs at proper time.
* __WARNING__: This guide will not produce publication quality captures. Use of [user:Aktan]'s [http://pastebin.com/g26ksKNa|special methods] is required. The automated version of the resync setup [EmulatorResources/PCSX/Resync|can be found here].
!! Windows
PCSX's native AVI dumping is broken - it does not result in synchronised sound - so external capture software is required; for this purpose, [http://www.mediafire.com/?oq4491c34o373nh|custom PCSX .kkapture] is used for its ability to preserve all of the frames in the input at the expected frame rate.
You may wish to use an alternate sound plugin for improved sound compatibility. The [http://www.pbernert.com/html/old_spu.htm|MIDAS plugin] has been reported to be sync-compatible with the TAS Sound plugin while offering slightly better sound emulation; alternatively, you can attempt to use the [http://www.zophar.net/utilities/psspuplugins/eternal-spu.html|Eternal SPU] plugin which offers the best known sound emulation but which does not sync reliably, use of the automated version of the resync setup which [EmulatorResources/PCSX/Resync|can be found here] is highly recommended.
If the game has graphical issues where characters are not visible then grab [http://www.pbernert.com/gpupete154.zip|Pete's Soft Driver 1.54] and Activate Special Game Fixes and Enable ''No Sprite Transparancy Abe games''.
# Configure PCSX's plugins for playback and close PCSX.
# Go to ''Configuration'' -> ''Graphics'' (You must use TAS Soft Plugins 0.2)
# In ''Stretching'', select ''1:1 (faster with some cards)''
# In ''Dithering'', select ''Always dither g-shaded polygons (slowest)''
# If you are using [EmulatorResources/PCSX/Resync|PCSX-Resync] enable ''Skip SPU Loadstate'' in the Tools menu, this will correct any lost audio.
# Open .kkapture.
# Under ''Demo'', select the {{pcsx}} executable.
# Under ''Arguments'', enter {{-play movie.pxm}} (where {{movie.pxm}} is the name of the movie file).
# Under ''Target'', select the desired target AVI file (such as {{raw.avi}}).
# Set the FPS to 60 for NTSC games or 50 for PAL games.
# Select ''kkapture!''. This will start PCSX and start the dumping process.
# Once the desired endpoint is reached, close PCSX.
!! Linux
PCSX is Windows-only. Further, .kkapture does not work with Wine. There has been at least one report of using a version of [http://nullkey.ath.cx/projects/glc/|glc] modified to sync video and capture all frames for a successful PCSX encode in a Linux environment.
!!! PSXjin
||Resolution||Sound||
|(variable)[#3]|44.1KHz stereo|
* __NOTE__: Dumps from PSXjin are slightly wrong. Use this [Forum/Topics/12608|(unofficial) version] instead.
* __NOTE__: Don't forget to pick the bios. SCPH-1001 for NTSC-U, SCPH-1000 for NTSC-J, SCPH-1002 for PAL. If you have problems, ask the judge or the author.
# Go to ''Configuration'' -> ''Graphics''
# In ''Stretching'', select ''1:1 (faster with some cards)''
# In ''Dithering'', select ''Always dither g-shaded polygons (slowest)''
# Uncheck ''FPS limit''
# Make sure ''Use Frame skipping'' is unchecked.
# Click OK.
# Go to ''Configuration'' -> ''Sound''
# In ''Mode'', select ''2: Synchronous (tas safe, buffering glitches)''.
# Click OK.
# Load the ISO by going to ''File'' -> ''Open CD''.
# Pause emulation. (Pause key)
# Select ''File'' -> ''Movie'' -> ''Start playback'', or press ''CTRL + R'' to load a movie file.
# Select ''File'' -> ''Record AVI''. Choose a file name (such as ''raw.avi''), and a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# Unpause emulation. At this point, an audio file and multiple video files (one per resolution change) are now being captured
# When you reach the desired end point, select ''File'' -> ''Stop AVI''
# You'll need to resize each video part into the largest width and largest height captured.
!!! Snes9x
||Resolution||Sound||
|256x224 (NTSC), 256x240 (PAL)|48KHz stereo[#1]|
!! Windows
''Note'': This applies to v1.43 v17 and most revisions of v1.51. Earlier versions of v1.43 have a different menu layout.
# Select ''Config -> Speed -> Frame skip -> skip 0''.
# Select ''Config -> Sound -> Playback rate -> 48KHz''.[#1]
# If you're using v1.43, select ''Config -> Video -> Display Configuration...'' and make sure that "Bi-Linear Mode 7" is checked.
# Load the ROM.
# Set speed to about 400% (= key or ''Config -> Speed -> Set Speed'').
# Pause emulation (Pause key).
# Load the movie file, with Sync Sound checked (it increases sound resolution).
# Select ''File -> Audio/Video Recording -> Start AVI Recording''. Choose a file name (such as {{raw.avi}}), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# Unpause emulation. You are now capturing audio/video.
# When you reach the desired end point, select ''File -> Audio/Video Recording -> Stop AVI Recording''.
!! Linux
At present, there's no known method other than [http://winehq.org|Wine] to get video output from v1.51 movies. A [http://bisqwit.iki.fi/src/snes9x-bisqwit-makingavi-patch.txt|patch] has been written for the v1.43 source code in order to get video output, but this may not be compatible with newer movies.
!!! VBjin
||Resolution||Sound||
|384x224|44.1KHz stereo|
__NOTE:__ [Forum/Posts/435440|Special encoding steps] are required.
!! Windows
# Load the ROM.
# Pause emulation. (Pause key)
# Load the movie file.
# Select ''File -> Record AVI''. Choose a file name (such as {{raw.avi}}), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click OK.
# Unpause emulation. At this point, audio and video are now being captured.
# When you reach the desired end point, select ''File -> Stop AVI''.
!! Linux
VBjin is Windows-only, but works well with [http://winehq.org|Wine].
!!! VisualBoyAdvance
||Resolution||Sound||
|160x144 (GB), 240x160 (GBA)|44.1KHz stereo|
# Go to ''Options -> Sound -> 44 KHz''.
# Go to ''Options -> Gameboy Mode -> Gameboy Colors''. If the TAS doesn't sync on v23.6 or newer, leave it at ''Real Colors'', as the ''Gameboy Colors'' palette is completely washed out and dull in older versions (up to v23.5).
# Open the ROM.
# Speed up to 300% or more. ({{=}} key)
# Pause emulation. ({{Pause}} key)
# Select ''Tools -> Movie -> Play Movie'' and select the movie file you want to dump to AVI.
# If you are running a Game Boy game that is Super Game Boy compatible but the movie does not run in Super Game Boy mode, enable ''Options -> Gameboy Mode -> Game Boy (GB)''.
# Select ''Tools -> Start AVI Recording''. Choose a file name (such as {{raw.avi}}), and choose a lossless RGB codec of your choice (see ''Common settings'' for suggestions). Click ''OK''.
# Unpause emulation. At this point, audio and video are now being captured.
# When you reach the desired end point, select ''Tools -> Stop AVI Recording''.
!!! Yabause
||Resolution||Sound||
|320x240|44.1KHz stereo|
TODO
----
[1]: The SNES has a 32KHz native sampling rate, but using this option in Snes9x tends to result in sound desynchronisation.%%%
[2]: For the N64, you can rip at an integer multiple of this resolution and scale it down to the appropriate size during the [EncodingGuide/Legacy/PreEncoding|Pre-encoding] stage.%%%
[3]: Games for the PSX use many resolutions; 320x240 is the most common.%%%
[4]: Mednafen, being cross-platform, uses the resolution of whatever platform it is currently emulating.%%%
[5]: Most games for the PCE that have been run are one of 256x224, 256x232, 320x232, or 320x240.%%%
[6]: There is no standard resolution for this platform.%%%
[7]: Depends on game. Usually 640x400, sometimes 640x480, rarely something else (measure size of frames shown during in-game sequences. Some games have different resolution in menu and in actual game).%%%
[8]: Depends on game. If game only uses PCM output with constant sampling rate, that sampling rate should be used. Otherwise sampling rate should be set to 44.1kHz or 48kHz. %%%
[9]: PSG High Quality actually distorts PSG noises by performing filtering on the sound. As a result, sharp noises become very washed out and soft. For example, Sonic's jumping noise.%%%
[10]: Famtasia was not meant to have video dumping capabilities. It had the feature hacked into it by blip.%%%
[11]: Famtasia incorrectly renders the NES's 240 scanlines. It shifts the topmost one to the bottom of the display. Furthermore, the 224 scanlines version (without the 240 scanlines patch) cuts off the bottom 16 scanlines instead of 8 from the top and 8 from the bottom. This results in 8 extra scanlines being displayed at the top and 8 fewer at the bottom. The best practice is to apply the 240 scanlines patch and remove the extra scanlines (NTSC) or move the bottom one to the proper location (PAL) after dumping.