1/*
2 * Copyright (c) 2010, 2015 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#include <memory>
50
51#include "base/imgwriter.hh"
52#include "params/VncInput.hh"
53#include "sim/sim_object.hh"
54
55class OutputDirectory;
56
57/**
58 * A device that expects to receive input from the vnc server should derrive
59 * (through mulitple inheritence if necessary from VncKeyboard or VncMouse
60 * and call setKeyboard() or setMouse() respectively on the vnc server.
61 */
62class VncKeyboard
63{
64  public:
65    /**
66     * Called when the vnc server receives a key press event from the
67     * client.
68     * @param key the key passed is an x11 keysym
69     * @param down is the key now down or up?
70     */
71    virtual void keyPress(uint32_t key, bool down) = 0;
72};
73
74class VncMouse
75{
76  public:
77    /**
78     * called whenever the mouse moves or it's button state changes
79     * buttons is a simple mask with each button (0-8) corresponding to
80     * a bit position in the byte with 1 being down and 0 being up
81     * @param x the x position of the mouse
82     * @param y the y position of the mouse
83     * @param buttos the button state as described above
84     */
85    virtual void mouseAt(uint16_t x, uint16_t y, uint8_t buttons) = 0;
86};
87
88class VncInput : public SimObject
89{
90  public:
91
92    /** Client -> Server message IDs */
93    enum ClientMessages {
94        ClientSetPixelFormat    = 0,
95        ClientSetEncodings      = 2,
96        ClientFrameBufferUpdate = 3,
97        ClientKeyEvent          = 4,
98        ClientPointerEvent      = 5,
99        ClientCutText           = 6
100    };
101
102    struct PixelFormat {
103        uint8_t bpp;
104        uint8_t depth;
105        uint8_t bigendian;
106        uint8_t truecolor;
107        uint16_t redmax;
108        uint16_t greenmax;
109        uint16_t bluemax;
110        uint8_t redshift;
111        uint8_t greenshift;
112        uint8_t blueshift;
113        uint8_t padding[3];
114    } M5_ATTR_PACKED;
115
116    struct PixelFormatMessage {
117        uint8_t type;
118        uint8_t padding[3];
119        PixelFormat px;
120    } M5_ATTR_PACKED;
121
122    struct PixelEncodingsMessage {
123        uint8_t type;
124        uint8_t padding;
125        uint16_t num_encodings;
126    } M5_ATTR_PACKED;
127
128    struct FrameBufferUpdateReq {
129        uint8_t type;
130        uint8_t incremental;
131        uint16_t x;
132        uint16_t y;
133        uint16_t width;
134        uint16_t height;
135    } M5_ATTR_PACKED;
136
137    struct KeyEventMessage {
138        uint8_t type;
139        uint8_t down_flag;
140        uint8_t padding[2];
141        uint32_t key;
142    } M5_ATTR_PACKED;
143
144    struct PointerEventMessage {
145        uint8_t type;
146        uint8_t button_mask;
147        uint16_t x;
148        uint16_t y;
149    } M5_ATTR_PACKED;
150
151    struct ClientCutTextMessage {
152        uint8_t type;
153        uint8_t padding[3];
154        uint32_t length;
155    } M5_ATTR_PACKED;
156
157    typedef VncInputParams Params;
158    VncInput(const Params *p);
159
160    /** Set the address of the frame buffer we are going to show.
161     * To avoid copying, just have the display controller
162     * tell us where the data is instead of constanly copying it around
163     * @param rfb frame buffer that we're going to use
164     */
165    virtual void setFrameBuffer(const FrameBuffer *rfb);
166
167    /** Set up the device that would like to receive notifications when keys are
168     * pressed in the vnc client keyboard
169     * @param _keyboard an object that derrives from VncKeyboard
170     */
171    void setKeyboard(VncKeyboard *_keyboard) { keyboard = _keyboard; }
172
173    /** Setup the device that would like to receive notifications when mouse
174     * movements or button presses are received from the vnc client.
175     * @param _mouse an object that derrives from VncMouse
176     */
177    void setMouse(VncMouse *_mouse) { mouse = _mouse; }
178
179    /** What is the width of the screen we're displaying.
180     * This is used for pointer/tablet devices that need to know to calculate
181     * the correct value to send to the device driver.
182     * @return the width of the simulated screen
183     */
184    uint16_t videoWidth() const { return _videoWidth; }
185
186    /** What is the height of the screen we're displaying.
187     * This is used for pointer/tablet devices that need to know to calculate
188     * the correct value to send to the device driver.
189     * @return the height of the simulated screen
190     */
191    uint16_t videoHeight() const { return _videoHeight; }
192
193    /** The frame buffer uses this call to notify the vnc server that
194     * the frame buffer has been updated and a new image needs to be sent to the
195     * client
196     */
197    virtual void setDirty();
198
199  protected:
200    virtual void frameBufferResized() {};
201
202    /** The device to notify when we get key events */
203    VncKeyboard *keyboard;
204
205    /** The device to notify when we get mouse events */
206    VncMouse *mouse;
207
208    /** pointer to the actual data that is stored in the frame buffer device */
209    const FrameBuffer *fb;
210
211    /** the width of the frame buffer we are sending to the client */
212    uint16_t _videoWidth;
213
214    /** the height of the frame buffer we are sending to the client */
215    uint16_t _videoHeight;
216
217    /** Flag indicating whether to capture snapshots of frame buffer or not */
218    bool captureEnabled;
219
220    /** Current frame number being captured to a file */
221    int captureCurrentFrame;
222
223    /** Directory to store captured frames to */
224    OutputDirectory *captureOutputDirectory;
225
226    /** Computed hash of the last captured frame */
227    uint64_t captureLastHash;
228
229    /** Cached ImgWriter object for writing out frame buffers to file */
230    std::unique_ptr<ImgWriter> captureImage;
231
232    /** image format */
233    Enums::ImageFormat imgFormat;
234
235    /** Captures the current frame buffer to a file */
236    void captureFrameBuffer();
237};
238#endif
239