100 lines
3.6 KiB
Plaintext
100 lines
3.6 KiB
Plaintext
WCAP Tools
|
|
|
|
WCAP is the video capture format used by Weston (Weston CAPture).
|
|
It's a simple, lossless format, that encodes the difference between
|
|
frames as run-length ecoded rectangles. It's a variable framerate
|
|
format, that only records new frames along with a timestamp when
|
|
something actually changes.
|
|
|
|
Recording in Weston is started by pressing MOD+R and stopped by
|
|
pressing MOD+R again. Currently this leaves a capture.wcap file in
|
|
the cwd of the weston process. The file format is documented below
|
|
and Weston comes with two tools to convert the wcap file into
|
|
something more usable:
|
|
|
|
- wcap-snapshot; a simple tool that will extract a given frame from
|
|
the capture as a png. This will produce a lossless screenshot,
|
|
which is useful if you're trying to screenshot a brief glitch or
|
|
something like that that's hard to capture with the screenshot tool.
|
|
|
|
wcap-snapshot takes a wcap file as its first argument. Without
|
|
anything else, it will show the screen size and number of frames in
|
|
the file. With an integer second argument, it will extract that
|
|
frame as a png:
|
|
|
|
[krh@minato weston]$ wcap-snapshot capture.wcap
|
|
wcap file: size 1024x640, 176 frames
|
|
[krh@minato weston]$ wcap-snapshot capture.wcap 20
|
|
wrote wcap-frame-20.png
|
|
wcap file: size 1024x640, 176 frames
|
|
|
|
- wcap-decode; this is a copy of the vpxenc tool from the libvpx
|
|
repository, with wcap input file support added. The tool can
|
|
encode a wcap file into a webm video (http://www.webmproject.org/).
|
|
The command line arguments are identical to what the vpxenc tool
|
|
takes and wcap-decode will print them if run without any arguments.
|
|
|
|
The minimal command line requires a webm output file and a wcap
|
|
input file:
|
|
|
|
[krh@minato weston]$ wcap-decode -o foo.webm capture.wcap
|
|
|
|
but it's possible to select target bitrate and output framerate and
|
|
it's typically useful to pass -t 4 to let the tool use multiple
|
|
threads:
|
|
|
|
[krh@minato weston]$ wcap-decode --target-bitrate=1024 \
|
|
--best -t 4 -o foo.webm capture.wcap --fps=10/1
|
|
|
|
|
|
WCAP File format
|
|
|
|
The file format has a small header and then just consists of the
|
|
indivial frames. The header is
|
|
|
|
uint32_t magic
|
|
uint32_t format
|
|
uint32_t width
|
|
uint32_t height
|
|
|
|
all CPU endian 32 bit words. The magic number is
|
|
|
|
#define WCAP_HEADER_MAGIC 0x57434150
|
|
|
|
and makes it easy to recognize a wcap file and verify that it's the
|
|
right endian. There are four supported pixel formats:
|
|
|
|
#define WCAP_FORMAT_XRGB8888 0x34325258
|
|
#define WCAP_FORMAT_XBGR8888 0x34324258
|
|
#define WCAP_FORMAT_RGBX8888 0x34325852
|
|
#define WCAP_FORMAT_BGRX8888 0x34325842
|
|
|
|
Each frame has a header:
|
|
|
|
uint32_t msecs
|
|
uint32_t nrects
|
|
|
|
which specifies a timestamp in ms and the number of rectangles that
|
|
changed since previous frame. The timestamps are typically just a raw
|
|
system timestamp and the first frame doesn't start from 0ms.
|
|
|
|
A frame consists of a list of rectangles, each of which represents the
|
|
component-wise difference between the previous frame and the current
|
|
using a run-length encoding. The initial frame is decoded against a
|
|
previous frame of all 0x00000000 pixels. Each rectangle starts out
|
|
with
|
|
|
|
int32_t x1
|
|
int32_t y1
|
|
int32_t x2
|
|
int32_t y2
|
|
|
|
followed by (x2 - x1) * (y2 - y1) pixels, run-length encoded. The
|
|
run-length encoding uses the 'X' channel in the pixel format to encode
|
|
the length of the run. That is for WCAP_FORMAT_XRGB8888, for example,
|
|
the length of the run is in the upper 8 bits. For X values 0-0xdf,
|
|
the length is X + 1, for X above or equal to 0xe0, the run length is 1
|
|
<< (X - 0xe0 + 7). That is, a pixel value of 0xe3000100, means that
|
|
the next 1024 pixels differ by RGB(0x00, 0x01, 0x00) from the previous
|
|
pixels.
|