Introduction

This page assumes you are already knowledgeable about playback of movies in the emulator. If not, consult EmulatorResources for advice on how to set that up first.
According to the EncoderGuidelines, 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 VFW for their video dumping process. Popular VFW choices include Lagarith and UtVideo. These lossless RGB dumps can also be used for taking Screenshots.
Lagarith
UtVideo

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, pipedec can be used. The following instructions will set up pipedec to use FFmpeg to encode using the lossless UtVideo codec as an example (take the decoder here), but pipedec can be configured to pipe video to any encoder you want.
  1. Download a compiled version of pipedec: https://github.com/vadosnaprimer/pipedec/releases/tag/v1
  2. 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.
  3. 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
  4. 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.
  5. Copy the .pipedec file to %AppData%\pipedec (create the folder if it's not there).
  6. Start up an emulator that uses VFW for dumping, and starting dumping any kind of video so that the VFW codec selection dialog appears.
  7. 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.
  8. Select Pipe Codec from the list.
  9. 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.
  10. Stop dumping video as normal when finished.
  11. 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 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:
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)
If Bob was used instead (the dump features rapidly wobbling lines, also known as "Bobbing"), the following code is used instead:
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)
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):
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()
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):
Trim(0, last.FrameCount-2) # AviSynth+ bug? (last.FrameCount-1 just gives the same total framecount as last.FrameCount)

BizHawk

ResolutionSound
variable44.1KHz stereo

Windows

  1. Select Speed/Skip to 0 (never skip)
  2. Open the ROM.
  3. Pause emulation. (Pause key)
  4. Load the movie.
  5. 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 regular codecs you have installed on your OS.
      • Use FFmpeg writer if you want to 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.
  6. Choose a file name (such as raw.avi), and choose a lossless RGB codec of your choice (see Common settings for suggestions). Click OK.
  7. Unpause emulation. At this point, audio and video are now being captured.
  8. When you reach the desired end point, select File -> AVI/WAV -> Stop AVI.
  9. 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 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

Game Boy/Game Boy Color

Game Boy Advance

N64

NES

PCE

PCE (TurboNyma)

PSX

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)

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

SNES

Virtual Boy

Citra

ResolutionSound
400x480 roughly 32728Hz stereo
  1. 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.
  2. 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.
  3. 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
  4. 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.
  5. When the movie finishes, the emulator will pause. Select Emulation -> Continue to unpause emulation and dump the credits.
  6. 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

ResolutionSound
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, .kkapture is used for its ability to preserve all of the frames in the input at the expected frame rate.
  1. Open .kkapture.
  2. Under Demo, select the dega executable.
  3. Under target, select the desired target AVI file (such as raw.avi).
  4. Set the FPS to 60 for NTSC games or 50 for PAL games.
  5. Select kkapture!. This will start Dega.
  6. Make sure Sound -> Enhanced PSG is unchecked.
  7. Make sure Graphics -> Overlay is set to None.
  8. If applicable, check Sound -> FM chip; use of this is normally specified in the submission text.
  9. Load the ROM and start movie playback.
  10. At the appropriate end point, close Dega.

Linux

  1. Play back the movie, noting the desired end frame of the video recording.
  2. 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).
  3. 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

ResolutionSound
256x38444.1KHz stereo

Windows

  1. Select Config -> 3D Settings and select SoftRasterizer as the Renderer.
  2. Select Config -> Frame Skip -> 0.
  3. Optionally, uncheck Config -> Frame Skip -> Limit framerate.
  4. Open the ROM.
  5. Pause emulation. (Pause key)
  6. Load the movie.
  7. Select File -> Record AVI.
  8. Choose a file name (such as raw.avi), and choose a lossless RGB codec of your choice (see Common settings for suggestions). Click OK.
  9. Unpause emulation. At this point, audio and video are now being captured.
  10. 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 Wine.

Dolphin

ResolutionSound
variable, 4:3 or 16:932KHz or 48KHz stereo
See this dedicated page.

DOOM

ResolutionSound
320x200 (default)44.1kHz stereo
  1. If the WAD uses the original DOOM music, get the 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.
  2. 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
  3. 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.
  4. 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.
    • feos' build #2 is pre-configured to disable application shutdown after demo end (demo_endquit 0).

Famtasia

* Dacicus doesn't understand why so many people are having trouble with Famtasia 
<Grunt> Famtasia *is* trouble. 
ResolutionSound
256x224 (NTSC), 256x240 (PAL)44.1kHz mono
  1. Start Famtasia
  2. Config -> Display -> Option: Resolution should be "Window Mode," Size x1, Drawing method should be "Window 8bpp,x1 size"
  3. Config -> Display -> Option: Check "Disable system messages"
  4. Config -> Speed: Refresh should be 1, Auto unchecked, ExecSpeed 100, and Windows Occupation all the way to the left
  5. Config -> Sound: No Reverberation should be checked, Sampling Rate should be 44,100Hz 8Bits
  6. 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)
  7. Edit -> Movie -> Play -> Play Movie -> click "..." and select the movie you want to record
  8. When you're done recording, close Famtasia.

Making the video files AviSynth-compatible using VirtualDub

  1. Open the first segment (usually recording00.avi).
  2. Video -> Compression -> Select Lagarith/CamStudio/your favorite lossless RGB codec and click OK.
  3. Fix display using the instructions below for NTSC or PAL, as appropriate.
  4. Save as something else (e.g., recording00_fixed.avi).
  5. Repeat for each segment.

Fixing the display using VirtualDub (NTSC)

  1. Video -> Filters -> Click "Add..." Select "null transform" and click OK.
  2. With "null transform" selected, click "Cropping."
  3. Set Y1 offset to 7 and Y2 offset to 9. Click OK twice.

Fixing the display using VirtualDub (PAL)

  1. Download Emiliano Ferrari's Shift filter and extract the ef_shift.vdf file into VDub's plugins directory. (Note: Simon Walters' ShiftWrap filter can also do this, but the processing settings aren't saved correctly for batch processing.)
  2. Video -> Filters -> Click "Add..."
  3. 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.)
  4. In the Shift configuration dialog, check "Repeat the picture."
  5. Enter 1 into the Y text box, or click the down arrow once. Click OK twice.

FCEU/FCEUX

ResolutionSound
256x224 (NTSC), 256x240 (PAL)48KHz mono
Within FCEU/X:

Windows

  1. Start FCEU or FCEUX.
  2. Select Config -> Video, and check Disable hardware acceleration (lower left corner).
  3. Select Config -> Sound. Set Rate to 48000 and Quality to high. Set all volume controls to their maximum.
  4. In qFCEUX 2.5.0 and up, select Options -> Movie Options, and set "libgwavi" as the AVI Backend Driver.
  5. Open the ROM for the movie.
  6. Set the emulator speed to about 400% or more (= key); how fast you should go is limited only by the speed of your computer.
  7. Pause emulation (Pause key).
  8. Load the target movie file.
  9. 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.
  10. 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.
  11. Unpause emulation; audio and video are now being captured.
  12. 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:
while true do
    if movie.mode() == "playback" then
        emu.frameadvance()
    else
        os.exit()
    end
end
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

ResolutionSound
(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.
  1. Select Audio -> Plugin Options -> 48000Hz samplerate.
  2. Load the ROM.
  3. Pause emulation (Pause key).
  4. Start movie playback.
  5. Disable input display (, key) and frame display (. key).
  6. 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.
  7. Unpause emulation. You are now capturing audio/video in real-time.
  8. When you reach the desired end point, select Game -> Movie -> Stop AVI.

Gens

ResolutionSound
320x224 (NTSC), 320x240 (PAL), 256x224 (low resolution mode)44.1KHz stereo
WARNING: Use the build of Gens fixed for AVI dumping, Gens-SplitAVI. It fixes the frame drop on new segment start, and splits on resolution changes.
  1. Select Graphics -> Frame Skip -> 0. This enables turbo speed while not skipping frames.
  2. Make sure Graphics -> VSync is unchecked.
  3. Make sure Sound -> PSG High Quality is unchecked.[9] This option is not present in the latest svn.
  4. Check Sound -> YM2612 High Quality and Sound -> DAC High Quality.
  5. Uncheck Sound -> Soften Filter.
  6. Uncheck Graphics -> Proper Aspect Ratio in low-resolution mode.
  7. If the game is a Sega CD game, uncheck Options -> General -> Show Sega-CD LED.
  8. Check Tools -> AVI -> Clean AVI screen.
  9. Check Tools -> AVI -> Fit AVI to game height.
  10. Uncheck Tools -> AVI -> Sync AVI with movie.
  11. Uncheck Options -> General... -> Message -> Enable.
  12. If the game is a 32x game, check Sound -> PWM.
  13. 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.
  14. Open the ROM.
  15. Pause emulation (Pause key).
  16. Start movie playback.
  17. 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.
  18. Unpause emulation. You are now capturing audio/video.
  19. When you reach the desired end point, select Tools -> AVI -> Stop AVI dump.

Hourglass

ResolutionSound
(variable)(variable)
  1. Figure out the options to get the run to sync (must be mentioned in the submission if they aren't default).
  2. Movie File -> Browse. Pick the TAS file.
  3. Game Executable -> Browse. Select the game executable.
  4. AVI -> check Capture Video and Audio.
  5. Check Fast-Forward.
  6. Run and Play Existing Movie. It will then prompt you to locate the output video and to select the codec.
  7. When it's over, press Stop Playing.

JPC-RR

ResolutionSound
(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 this link, as it has all the tools needed for video dumping.
  1. 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.
  2. In System -> Assemble, set Fda image to "FreeDOS" and Hdd image to the HDD image you created. Click Assemble.
  3. Load the movie (JRSR) file under Snapshot -> Load -> Movie.
  4. Set up the video dump by going to System -> Start Dumping. Name the file you want to save the dump to.
  5. Start the video dump by clicking System -> Start. The movie playback and dumping will begin.
  6. When you have reached your desired endpoint, click System -> Quit. The emulator will terminate the dump properly.
  7. 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

ResolutionSound
(variable)(variable)
  1. Install ffmpeg, or else dumping won't work (e.g. under Ubuntu: sudo apt-get install ffmpeg).
  2. 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 Ruffle or a 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
  3. Check Movie recording, then click on Browse.... Select the movie file.
  4. 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.
  5. 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
  6. Start the encode by clicking on Tools -> Start encode. This will start the encode when launching the game.
  7. 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).
  8. 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:
AVISource("encode.avi", pixel_type="RGB24", fourCC="X264")

Emulators in libTAS

PCem

There's a 80ms audio buffer that needs to be trimmed out. This can be done with the following:
DelayAudio(-0.08)

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:
DelayAudio(-0.15-(5.0/(last.framerate)))
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 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:
video = AVISource("blah.avi")
blk = BlankClip(video, 1)
blk + video.Trim(1, 0)
or
last.Trim(0,1).crop(1,1,-1,-1).AddBorders(1,1,1,1) + last.Trim(2,0)
The audio buffer that needs trimming is 5 in-game frames. To remove it, use the following code:
DelayAudio(-5.0/(Float(last.FrameRateNumerator)/Float(last.FrameRateDenominator)))
For cdimono1 specifically (PAL CD-i Mono I), the top 22 rows of pixels need to be cropped out:
Crop(0, 22, -0, -0)

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:
a = AviSource("movie.avi", pixel_type=pixelType)
BlankClip(a, 1) + a

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.

lsnes

ResolutionSound
256/512x224/240/448/48044.1 KHz stereo
  1. Open the emulator, load the ROM.
  2. Select load movie/savestate tab, select the movie, check start paused and hit ok.
  3. 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.
  4. Select AVI capture (CamStudio / PCM) from capture menu.
  5. Set speed to turbo (or other desired speed).
  6. If you want to, you can mute audio by unchecking Config->Sounds enabled. This won't affect dumped audio.
  7. Unpause the emulator
  8. When reaching the end, select end avi dump.
  9. Close the emulator.

MAME-RR

ResolutionSound
Variable48KHz
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):
mame-rr myrom -aviwrite myrom.avi -playback myrom.mar
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:
@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
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.

Mednafen

ResolutionSound
(variable)[4]44.1KHz stereo

Windows or linux

  1. 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.
  2. Now transfert the .mmm file on Linux to convert it to .mov (quicktime).

Linux only

./autogen.sh
sudo ./configure
sudo make
sudo make install

Mupen64

ResolutionSound
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 download it here.
  1. Start Mupen.
  2. Options -> Settings -> General -> uncheck Limit FPS (auto).
  3. Options -> Settings -> Advanced -> uncheck Force Internal AVI Capture
  4. Options -> Settings -> Other -> select Audio-Authoritative Sync
  5. Options -> Settings -> Config Plugins -> select AngryLion as the video plugin and Jabo’s audio plugin for audio.
  6. 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.
  7. Load your game ROM
  8. 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).
  9. 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.
  10. 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.

Windows

Mupen64's built-in dumping is very unreliable and should not be used at all. Aktan has developed the following alternate dumping method using a modified build of .kkapture. It is recommended, where possible, to use the Glide64 'Final' video plugin and Azimer's audio plugin (both plugins are mirrored on that page); some segments of the following set of instructions may assume the use of those plugins.
  1. 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.
  2. 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.
  3. Edit Plugins/Glide64.ini; change instances of "filtering = 1" to "filtering = 0", and "hotkeys = 1" to "hotkeys = 0".
  4. Start Mupen.
  5. Options -> Settings -> General -> uncheck "Limit FPS (auto)".
  6. Options -> Settings -> Config Plugins -> select Glide64 Napalm WX as the video plugin and Azimer's audio plugin for audio.
  7. Go into the Glide64 configuration dialogue, check "show advanced emulation options", and close and reopen the dialogue.
  8. Set video options as seen here and here. (Note: "use frame buffer objects" may be necessary for some video cards).
  9. Select a video resolution that is a multiple of 320x240 (or 342x256), but smaller than your screen size (antialiasing).
  10. 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.
  11. 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.
  12. Make a save state.
  13. Close Mupen.
  14. 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).
  15. Start .kkapture; configure it as seen 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.
  16. Set "Demo" to your Mupen executable and set "Target" to a target filename, then click "kkapture!". Mupen will start.
  17. 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).
  18. Pause Mupen.
  19. Utilities -> Movies -> Start Movie Playback; select the movie as earlier, check "Open Read-Only", and click OK (don't specify a pause frame).
  20. Load your save state from earlier.
  21. 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.
  22. 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:
  1. The capture may have an extra 20 pixel border at the bottom, which should be cropped out.
  2. The audio plugin may add a audio delay of around 192 ms (could be a function of the sound card).
  3. Duplicate frame removal is strongly recommended for captures using this method, given the number of duplicate frames in the video dump.
  4. 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.
  5. 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 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

ResolutionSound
640x48044.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. 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
but it's highly recommended that the replay is in that folder, as it'll be a bit easier to load the replay file.

Windows

The easiest way is to use this script.
@echo off
cd /d "%~dp0"
echo record start -doublesize ./movie.avi > dump.tcl
openmsx %1 -script dump.tcl
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.
  1. Method 1: load manually from the console
    1. Open Catapult (openMSX GUI) or openMSX (non-GUI).
    2. In case you started Catapult, start openMSX with the Start button.
    3. In the openMSX window where the emulation is running, hit Pause to pause emulation.
    4. Hit F10 to bring up the openMSX console.
    5. 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.
  2. Method 2: auto load
    1. Drop the replay on openMSX.exe (or start openMSX from the command line with the replay file as only argument)
    2. In the openMSX window where the emulation is running, hit Pause to pause emulation.
    3. Hit F10 to bring up the openMSX console.
    4. Type reverse goto 0 to jump back to the beginning of the replay
  3. 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
  4. Unpause emulation. (Pause key)
  5. Hit F9 to speed up emulation (if you don't want to wait for the whole movie to play at normal time).
  6. 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

  1. 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).
  2. The hot keys to open the console, pause and speed up emulation are different on Mac, though, 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) in the openMSX FAQ part of the manual.
For more information about openMSX, please check the complete openMSX manual.

PCEjin

ResolutionSound
(variable)[5]44.1KHz stereo

Windows

  1. Load the ROM.
  2. Turn on Fast-Forward mode by pressing T.
  3. Pause emulation. (Pause key)
  4. Load the movie file.
  5. 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.
  6. Unpause emulation. At this point, audio and video are now being captured in real-time.
  7. When you reach the desired end point, select File -> Stop AVI.

Linux

PCEjin is Windows-only, but works well with Wine. You may also be able to play back the movie with recent builds of Mednafen (see above).

PCSX

ResolutionSound
(variable)[3]44.1KHz stereo
Spikestuff has compiled sync notes for each problematic movie.

Windows

PCSX's native AVI dumping is broken - it does not result in synchronised sound - so external capture software is required; for this purpose, 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 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 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 can be found here is highly recommended.
If the game has graphical issues where characters are not visible then grab Pete's Soft Driver 1.54 and Activate Special Game Fixes and Enable No Sprite Transparancy Abe games.
  1. Configure PCSX's plugins for playback and close PCSX.
  2. Go to Configuration -> Graphics (You must use TAS Soft Plugins 0.2)
  3. In Stretching, select 1:1 (faster with some cards)
  4. In Dithering, select Always dither g-shaded polygons (slowest)
  5. If you are using PCSX-Resync enable Skip SPU Loadstate in the Tools menu, this will correct any lost audio.
  6. Open .kkapture.
  7. Under Demo, select the pcsx executable.
  8. Under Arguments, enter -play movie.pxm (where movie.pxm is the name of the movie file).
  9. Under Target, select the desired target AVI file (such as raw.avi).
  10. Set the FPS to 60 for NTSC games or 50 for PAL games.
  11. Select kkapture!. This will start PCSX and start the dumping process.
  12. 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 glc modified to sync video and capture all frames for a successful PCSX encode in a Linux environment.

PSXjin

ResolutionSound
(variable)[3]44.1KHz stereo
  1. Go to Configuration -> Graphics
  2. In Stretching, select 1:1 (faster with some cards)
  3. In Dithering, select Always dither g-shaded polygons (slowest)
  4. Uncheck FPS limit
  5. Make sure Use Frame skipping is unchecked.
  6. Click OK.
  7. Go to Configuration -> Sound
  8. In Mode, select 2: Synchronous (tas safe, buffering glitches).
  9. Click OK.
  10. Load the ISO by going to File -> Open CD.
  11. Pause emulation. (Pause key)
  12. Select File -> Movie -> Start playback, or press CTRL + R to load a movie file.
  13. 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.
  14. Unpause emulation. At this point, an audio file and multiple video files (one per resolution change) are now being captured
  15. When you reach the desired end point, select File -> Stop AVI
  16. You'll need to resize each video part into the largest width and largest height captured.

Snes9x

ResolutionSound
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.
  1. Select Config -> Speed -> Frame skip -> skip 0.
  2. Select Config -> Sound -> Playback rate -> 48KHz.[1]
  3. If you're using v1.43, select Config -> Video -> Display Configuration... and make sure that "Bi-Linear Mode 7" is checked.
  4. Load the ROM.
  5. Set speed to about 400% (= key or Config -> Speed -> Set Speed).
  6. Pause emulation (Pause key).
  7. Load the movie file, with Sync Sound checked (it increases sound resolution).
  8. 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.
  9. Unpause emulation. You are now capturing audio/video.
  10. 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 Wine to get video output from v1.51 movies. A 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

ResolutionSound
384x22444.1KHz stereo
NOTE: Special encoding steps are required.

Windows

  1. Load the ROM.
  2. Pause emulation. (Pause key)
  3. Load the movie file.
  4. 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.
  5. Unpause emulation. At this point, audio and video are now being captured.
  6. When you reach the desired end point, select File -> Stop AVI.

Linux

VBjin is Windows-only, but works well with Wine.

VisualBoyAdvance

ResolutionSound
160x144 (GB), 240x160 (GBA)44.1KHz stereo
  1. Go to Options -> Sound -> 44 KHz.
  2. 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).
  3. Open the ROM.
  4. Speed up to 300% or more. (= key)
  5. Pause emulation. (Pause key)
  6. Select Tools -> Movie -> Play Movie and select the movie file you want to dump to AVI.
  7. 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).
  8. 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.
  9. Unpause emulation. At this point, audio and video are now being captured.
  10. When you reach the desired end point, select Tools -> Stop AVI Recording.

Yabause

ResolutionSound
320x24044.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 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.
Expand/Collapse collapse-content-_7d00d09cd35f47d783dcfa5778080454

EncodingGuide/VideoDumping last edited by fsvgm777 on 3/23/2024 10:16 AM
Page History Latest diff List referrers View Source