vncinput.hh revision 9330 
1/*
2 * Copyright (c) 2010 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder.  You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions are
16 * met: redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer;
18 * redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution;
21 * neither the name of the copyright holders nor the names of its
22 * contributors may be used to endorse or promote products derived from
23 * this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 *
37 * Authors: Ali Saidi
38 *          William Wang
39 */
40
41/** @file
42 * Declaration of a VNC input
43 */
44
45#ifndef __BASE_VNC_VNC_INPUT_HH__
46#define __BASE_VNC_VNC_INPUT_HH__
47
48#include <iostream>
49
50#include "base/vnc/convert.hh"
51#include "base/bitmap.hh"
52#include "params/VncInput.hh"
53#include "sim/sim_object.hh"
54
55/**
56 * A device that expects to receive input from the vnc server should derrive
57 * (through mulitple inheritence if necessary from VncKeyboard or VncMouse
58 * and call setKeyboard() or setMouse() respectively on the vnc server.
59 */
60class VncKeyboard
61{
62  public:
63    /**
64     * Called when the vnc server receives a key press event from the
65     * client.
66     * @param key the key passed is an x11 keysym
67     * @param down is the key now down or up?
68     */
69    virtual void keyPress(uint32_t key, bool down) = 0;
70};
71
72class VncMouse
73{
74  public:
75    /**
76     * called whenever the mouse moves or it's button state changes
77     * buttons is a simple mask with each button (0-8) corresponding to
78     * a bit position in the byte with 1 being down and 0 being up
79     * @param x the x position of the mouse
80     * @param y the y position of the mouse
81     * @param buttos the button state as described above
82     */
83    virtual void mouseAt(uint16_t x, uint16_t y, uint8_t buttons) = 0;
84};
85
86class VncInput : public SimObject
87{
88  public:
89
90    /** Client -> Server message IDs */
91    enum ClientMessages {
92        ClientSetPixelFormat    = 0,
93        ClientSetEncodings      = 2,
94        ClientFrameBufferUpdate = 3,
95        ClientKeyEvent          = 4,
96        ClientPointerEvent      = 5,
97        ClientCutText           = 6
98    };
99
100    struct PixelFormat {
101        uint8_t bpp;
102        uint8_t depth;
103        uint8_t bigendian;
104        uint8_t truecolor;
105        uint16_t redmax;
106        uint16_t greenmax;
107        uint16_t bluemax;
108        uint8_t redshift;
109        uint8_t greenshift;
110        uint8_t blueshift;
111        uint8_t padding[3];
112    } M5_ATTR_PACKED;
113
114    struct PixelFormatMessage {
115        uint8_t type;
116        uint8_t padding[3];
117        PixelFormat px;
118    } M5_ATTR_PACKED;
119
120    struct PixelEncodingsMessage {
121        uint8_t type;
122        uint8_t padding;
123        uint16_t num_encodings;
124    } M5_ATTR_PACKED;
125
126    struct FrameBufferUpdateReq {
127        uint8_t type;
128        uint8_t incremental;
129        uint16_t x;
130        uint16_t y;
131        uint16_t width;
132        uint16_t height;
133    } M5_ATTR_PACKED;
134
135    struct KeyEventMessage {
136        uint8_t type;
137        uint8_t down_flag;
138        uint8_t padding[2];
139        uint32_t key;
140    } M5_ATTR_PACKED;
141
142    struct PointerEventMessage {
143        uint8_t type;
144        uint8_t button_mask;
145        uint16_t x;
146        uint16_t y;
147    } M5_ATTR_PACKED;
148
149    struct ClientCutTextMessage {
150        uint8_t type;
151        uint8_t padding[3];
152        uint32_t length;
153    } M5_ATTR_PACKED;
154
155    typedef VncInputParams Params;
156    VncInput(const Params *p);
157
158    /** Set the address of the frame buffer we are going to show.
159     * To avoid copying, just have the display controller
160     * tell us where the data is instead of constanly copying it around
161     * @param rfb frame buffer that we're going to use
162     */
163    void
164    setFramebufferAddr(uint8_t* rfb)
165    {
166        fbPtr = rfb;
167    }
168
169    /** Set up the device that would like to receive notifications when keys are
170     * pressed in the vnc client keyboard
171     * @param _keyboard an object that derrives from VncKeyboard
172     */
173    void setKeyboard(VncKeyboard *_keyboard) { keyboard = _keyboard; }
174
175    /** Setup the device that would like to receive notifications when mouse
176     * movements or button presses are received from the vnc client.
177     * @param _mouse an object that derrives from VncMouse
178     */
179    void setMouse(VncMouse *_mouse) { mouse = _mouse; }
180
181    /** What is the width of the screen we're displaying.
182     * This is used for pointer/tablet devices that need to know to calculate
183     * the correct value to send to the device driver.
184     * @return the width of the simulated screen
185     */
186    uint16_t videoWidth() const { return _videoWidth; }
187
188    /** What is the height of the screen we're displaying.
189     * This is used for pointer/tablet devices that need to know to calculate
190     * the correct value to send to the device driver.
191     * @return the height of the simulated screen
192     */
193    uint16_t videoHeight() const { return _videoHeight; }
194
195    /** The frame buffer uses this call to notify the vnc server that
196     * the frame buffer has been updated and a new image needs to be sent to the
197     * client
198     */
199    virtual void setDirty()
200    {
201        if (captureEnabled)
202            captureFrameBuffer();
203    }
204
205    /** Set the mode of the data the frame buffer will be sending us
206     * @param mode the mode
207     */
208    virtual void setFrameBufferParams(VideoConvert::Mode mode, uint16_t width, uint16_t height);
209
210  protected:
211    /** The device to notify when we get key events */
212    VncKeyboard *keyboard;
213
214    /** The device to notify when we get mouse events */
215    VncMouse *mouse;
216
217    /** The video converter that transforms data for us */
218    VideoConvert *vc;
219
220    /** pointer to the actual data that is stored in the frame buffer device */
221    uint8_t* fbPtr;
222
223    /** The mode of data we're getting frame buffer in */
224    VideoConvert::Mode videoMode;
225
226    /** the width of the frame buffer we are sending to the client */
227    uint16_t _videoWidth;
228
229    /** the height of the frame buffer we are sending to the client */
230    uint16_t _videoHeight;
231
232    /** Flag indicating whether to capture snapshots of frame buffer or not */
233    bool captureEnabled;
234
235    /** Current frame number being captured to a file */
236    int captureCurrentFrame;
237
238    /** Directory to store captured frames to */
239    std::string captureOutputDirectory;
240
241    /** Computed hash of the last captured frame */
242    uint64_t captureLastHash;
243
244    /** Cached bitmap object for writing out frame buffers to file */
245    Bitmap *captureBitmap;
246
247    /** Captures the current frame buffer to a file */
248    void captureFrameBuffer();
249};
250#endif
251