Home | History | Annotate | Download | only in android 
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "qemu-common.h"
     18 #include "utils/panic.h"
     19 #include "android/hw-events.h"
     20 #include "android/charmap.h"
     21 #include "android/multitouch-screen.h"
     22 #include "android/sdk-controller-socket.h"
     23 #include "android/multitouch-port.h"
     24 #include "android/globals.h"  /* for android_hw */
     25 #include "android/opengles.h"
     26 #include "android/utils/misc.h"
     27 #include "android/utils/jpeg-compress.h"
     28 #include "android/utils/debug.h"
     29 
     30 #define  E(...)    derror(__VA_ARGS__)
     31 #define  W(...)    dwarning(__VA_ARGS__)
     32 #define  D(...)    VERBOSE_PRINT(mtport,__VA_ARGS__)
     33 #define  D_ACTIVE  VERBOSE_CHECK(mtport)
     34 
     35 #define TRACE_ON    1
     36 
     37 #if TRACE_ON
     38 #define  T(...)    VERBOSE_PRINT(mtport,__VA_ARGS__)
     39 #else
     40 #define  T(...)
     41 #endif
     42 
     43 /* Timeout (millisec) to use when communicating with SDK controller. */
     44 #define SDKCTL_MT_TIMEOUT      3000
     45 
     46 /*
     47  * Message types used in multi-touch emulation.
     48  */
     49 
     50 /* Pointer move message. */
     51 #define SDKCTL_MT_MOVE                  1
     52 /* First pointer down message. */
     53 #define SDKCTL_MT_FISRT_DOWN            2
     54 /* Last pointer up message. */
     55 #define SDKCTL_MT_LAST_UP               3
     56 /* Pointer down message. */
     57 #define SDKCTL_MT_POINTER_DOWN          4
     58 /* Pointer up message. */
     59 #define SDKCTL_MT_POINTER_UP            5
     60 /* Sends framebuffer update. */
     61 #define SDKCTL_MT_FB_UPDATE             6
     62 /* Framebuffer update has been received. */
     63 #define SDKCTL_MT_FB_UPDATE_RECEIVED    7
     64 /* Framebuffer update has been handled. */
     65 #define SDKCTL_MT_FB_UPDATE_HANDLED     8
     66 
     67 /* Multi-touch port descriptor. */
     68 struct AndroidMTSPort {
     69     /* Caller identifier. */
     70     void*               opaque;
     71     /* Communication socket. */
     72     SDKCtlSocket*       sdkctl;
     73     /* Initialized JPEG compressor instance. */
     74     AJPEGDesc*          jpeg_compressor;
     75     /* Direct packet descriptor for framebuffer updates. */
     76     SDKCtlDirectPacket* fb_packet;
     77 };
     78 
     79 /* Data sent with SDKCTL_MT_QUERY_START */
     80 typedef struct QueryDispData {
     81     /* Width of the emulator display. */
     82     int     width;
     83     /* Height of the emulator display. */
     84     int     height;
     85 } QueryDispData;
     86 
     87 /* Multi-touch event structure received from SDK controller port. */
     88 typedef struct AndroidMTEvent {
     89     /* Pointer identifier. */
     90     int     pid;
     91     /* Pointer 'x' coordinate. */
     92     int     x;
     93     /* Pointer 'y' coordinate. */
     94     int     y;
     95     /* Pointer pressure. */
     96     int     pressure;
     97 } AndroidMTEvent;
     98 
     99 /* Multi-touch pointer descriptor received from SDK controller port. */
    100 typedef struct AndroidMTPtr {
    101     /* Pointer identifier. */
    102     int     pid;
    103 } AndroidMTPtr;
    104 
    105 /* Destroys and frees the descriptor. */
    106 static void
    107 _mts_port_free(AndroidMTSPort* mtsp)
    108 {
    109     if (mtsp != NULL) {
    110         if (mtsp->fb_packet != NULL) {
    111             sdkctl_direct_packet_release(mtsp->fb_packet);
    112         }
    113         if (mtsp->jpeg_compressor != NULL) {
    114             jpeg_compressor_destroy(mtsp->jpeg_compressor);
    115         }
    116         if (mtsp->sdkctl != NULL) {
    117             sdkctl_socket_release(mtsp->sdkctl);
    118         }
    119         AFREE(mtsp);
    120     }
    121 }
    122 
    123 /********************************************************************************
    124  *                          Multi-touch action handlers
    125  *******************************************************************************/
    126 
    127 /*
    128  * Although there are a lot of similarities in the way the handlers below are
    129  * implemented, for the sake of tracing / debugging it's better to have a
    130  * separate handler for each distinctive action.
    131  */
    132 
    133 /* First pointer down event handler. */
    134 static void
    135 _on_action_down(int tracking_id, int x, int y, int pressure)
    136 {
    137     multitouch_update_pointer(MTES_DEVICE, tracking_id, x, y, pressure);
    138 }
    139 
    140 /* Last pointer up event handler. */
    141 static void
    142 _on_action_up(int tracking_id)
    143 {
    144     multitouch_update_pointer(MTES_DEVICE, tracking_id, 0, 0, 0);
    145 }
    146 
    147 /* Pointer down event handler. */
    148 static void
    149 _on_action_pointer_down(int tracking_id, int x, int y, int pressure)
    150 {
    151     multitouch_update_pointer(MTES_DEVICE, tracking_id, x, y, pressure);
    152 }
    153 
    154 /* Pointer up event handler. */
    155 static void
    156 _on_action_pointer_up(int tracking_id)
    157 {
    158     multitouch_update_pointer(MTES_DEVICE, tracking_id, 0, 0, 0);
    159 }
    160 
    161 /* Pointer move event handler. */
    162 static void
    163 _on_action_move(int tracking_id, int x, int y, int pressure)
    164 {
    165     multitouch_update_pointer(MTES_DEVICE, tracking_id, x, y, pressure);
    166 }
    167 
    168 /********************************************************************************
    169  *                          Multi-touch event handlers
    170  *******************************************************************************/
    171 
    172 /* Handles "pointer move" event.
    173  * Param:
    174  *  param - Array of moving pointers.
    175  *  pointers_count - Number of pointers in the array.
    176  */
    177 static void
    178 _on_move(const AndroidMTEvent* param, int pointers_count)
    179 {
    180     int n;
    181     for (n = 0; n < pointers_count; n++, param++) {
    182         T("Multi-touch: MOVE(%d): %d-> %d:%d:%d",
    183           n, param->pid, param->x, param->y, param->pressure);
    184          _on_action_move(param->pid, param->x, param->y, param->pressure);
    185     }
    186 }
    187 
    188 /* Handles "first pointer down" event. */
    189 static void
    190 _on_down(const AndroidMTEvent* param)
    191 {
    192     T("Multi-touch: 1-ST DOWN: %d-> %d:%d:%d",
    193       param->pid, param->x, param->y, param->pressure);
    194     _on_action_down(param->pid, param->x, param->y, param->pressure);
    195 }
    196 
    197 /* Handles "last pointer up" event. */
    198 static void
    199 _on_up(const AndroidMTPtr* param)
    200 {
    201     T("Multi-touch: LAST UP: %d", param->pid);
    202     _on_action_up(param->pid);
    203 }
    204 
    205 /* Handles "next pointer down" event. */
    206 static void
    207 _on_pdown(const AndroidMTEvent* param)
    208 {
    209     T("Multi-touch: DOWN: %d-> %d:%d:%d",
    210       param->pid, param->x, param->y, param->pressure);
    211     _on_action_pointer_down(param->pid, param->x, param->y, param->pressure);
    212 }
    213 
    214 /* Handles "next pointer up" event. */
    215 static void
    216 _on_pup(const AndroidMTPtr* param)
    217 {
    218     T("Multi-touch: UP: %d", param->pid);
    219     _on_action_pointer_up(param->pid);
    220 }
    221 
    222 /********************************************************************************
    223  *                      Device communication callbacks
    224  *******************************************************************************/
    225 
    226 /* A callback that is invoked on SDK controller socket connection events. */
    227 static AsyncIOAction
    228 _on_multitouch_socket_connection(void* opaque,
    229                                  SDKCtlSocket* sdkctl,
    230                                  AsyncIOState status)
    231 {
    232     if (status == ASIO_STATE_FAILED) {
    233         /* Reconnect (after timeout delay) on failures */
    234         if (sdkctl_socket_is_handshake_ok(sdkctl)) {
    235             sdkctl_socket_reconnect(sdkctl, SDKCTL_DEFAULT_TCP_PORT,
    236                                     SDKCTL_MT_TIMEOUT);
    237         }
    238     }
    239     return ASIO_ACTION_DONE;
    240 }
    241 
    242 /* A callback that is invoked on SDK controller port connection events. */
    243 static void
    244 _on_multitouch_port_connection(void* opaque,
    245                                SDKCtlSocket* sdkctl,
    246                                SdkCtlPortStatus status)
    247 {
    248     switch (status) {
    249         case SDKCTL_PORT_CONNECTED:
    250             D("Multi-touch: SDK Controller is connected");
    251             break;
    252 
    253         case SDKCTL_PORT_DISCONNECTED:
    254             D("Multi-touch: SDK Controller is disconnected");
    255             // Disable OpenGLES framebuffer updates.
    256             if (android_hw->hw_gpu_enabled) {
    257                 android_setPostCallback(NULL, NULL);
    258             }
    259             break;
    260 
    261         case SDKCTL_PORT_ENABLED:
    262             D("Multi-touch: SDK Controller port is enabled.");
    263             // Enable OpenGLES framebuffer updates.
    264             if (android_hw->hw_gpu_enabled) {
    265                 android_setPostCallback(multitouch_opengles_fb_update, NULL);
    266             }
    267             /* Refresh (possibly stale) device screen. */
    268             multitouch_refresh_screen();
    269             break;
    270 
    271         case SDKCTL_PORT_DISABLED:
    272             D("Multi-touch: SDK Controller port is disabled.");
    273             // Disable OpenGLES framebuffer updates.
    274             if (android_hw->hw_gpu_enabled) {
    275                 android_setPostCallback(NULL, NULL);
    276             }
    277             break;
    278 
    279         case SDKCTL_HANDSHAKE_CONNECTED:
    280             D("Multi-touch: Handshake succeeded with connected port.");
    281             break;
    282 
    283         case SDKCTL_HANDSHAKE_NO_PORT:
    284             D("Multi-touch: Handshake succeeded with disconnected port.");
    285             break;
    286 
    287         case SDKCTL_HANDSHAKE_DUP:
    288             W("Multi-touch: Handshake failed due to port duplication.");
    289             sdkctl_socket_disconnect(sdkctl);
    290             break;
    291 
    292         case SDKCTL_HANDSHAKE_UNKNOWN_QUERY:
    293             W("Multi-touch: Handshake failed due to unknown query.");
    294             sdkctl_socket_disconnect(sdkctl);
    295             break;
    296 
    297         case SDKCTL_HANDSHAKE_UNKNOWN_RESPONSE:
    298         default:
    299             W("Multi-touch: Handshake failed due to unknown reason.");
    300             sdkctl_socket_disconnect(sdkctl);
    301             break;
    302     }
    303 }
    304 
    305 /* A callback that is invoked when a message is received from the device. */
    306 static void
    307 _on_multitouch_message(void* client_opaque,
    308                        SDKCtlSocket* sdkctl,
    309                        SDKCtlMessage* message,
    310                        int msg_type,
    311                        void* msg_data,
    312                        int msg_size)
    313 {
    314     switch (msg_type) {
    315         case SDKCTL_MT_MOVE: {
    316             assert((msg_size / sizeof(AndroidMTEvent)) && !(msg_size % sizeof(AndroidMTEvent)));
    317             _on_move((const AndroidMTEvent*)msg_data, msg_size / sizeof(AndroidMTEvent));
    318             break;
    319         }
    320 
    321         case SDKCTL_MT_FISRT_DOWN:
    322             assert(msg_size / sizeof(AndroidMTEvent) && !(msg_size % sizeof(AndroidMTEvent)));
    323             _on_down((const AndroidMTEvent*)msg_data);
    324             break;
    325 
    326         case SDKCTL_MT_LAST_UP:
    327             _on_up((const AndroidMTPtr*)msg_data);
    328             break;
    329 
    330         case SDKCTL_MT_POINTER_DOWN:
    331             assert(msg_size / sizeof(AndroidMTEvent) && !(msg_size % sizeof(AndroidMTEvent)));
    332             _on_pdown((const AndroidMTEvent*)msg_data);
    333             break;
    334 
    335         case SDKCTL_MT_POINTER_UP:
    336             _on_pup((const AndroidMTPtr*)msg_data);
    337             break;
    338 
    339         case SDKCTL_MT_FB_UPDATE_RECEIVED:
    340             D("Framebuffer update ACK.");
    341             break;
    342 
    343         case SDKCTL_MT_FB_UPDATE_HANDLED:
    344             D("Framebuffer update handled.");
    345             multitouch_fb_updated();
    346             break;
    347 
    348         default:
    349             W("Multi-touch: Unknown message %d", msg_type);
    350             break;
    351     }
    352 }
    353 
    354 /********************************************************************************
    355  *                          MTS port API
    356  *******************************************************************************/
    357 
    358 AndroidMTSPort*
    359 mts_port_create(void* opaque)
    360 {
    361     AndroidMTSPort* mtsp;
    362 
    363     ANEW0(mtsp);
    364     mtsp->opaque                = opaque;
    365 
    366     /* Initialize default MTS descriptor. */
    367     multitouch_init(mtsp);
    368 
    369     /* Create JPEG compressor. Put message header + MTFrameHeader in front of the
    370      * compressed data. this way we will have entire query ready to be
    371      * transmitted to the device. */
    372     mtsp->jpeg_compressor =
    373         jpeg_compressor_create(sdkctl_message_get_header_size() + sizeof(MTFrameHeader), 4096);
    374 
    375     mtsp->sdkctl = sdkctl_socket_new(SDKCTL_MT_TIMEOUT, "multi-touch",
    376                                      _on_multitouch_socket_connection,
    377                                      _on_multitouch_port_connection,
    378                                      _on_multitouch_message, mtsp);
    379     sdkctl_init_recycler(mtsp->sdkctl, 64, 8);
    380 
    381     /* Create a direct packet that will wrap up framebuffer updates. Note that
    382      * we need to do this after we have initialized the recycler! */
    383     mtsp->fb_packet = sdkctl_direct_packet_new(mtsp->sdkctl);
    384 
    385     /* Now we can initiate connection witm MT port on the device. */
    386     sdkctl_socket_connect(mtsp->sdkctl, SDKCTL_DEFAULT_TCP_PORT,
    387                           SDKCTL_MT_TIMEOUT);
    388 
    389     return mtsp;
    390 }
    391 
    392 void
    393 mts_port_destroy(AndroidMTSPort* mtsp)
    394 {
    395     _mts_port_free(mtsp);
    396 }
    397 
    398 /********************************************************************************
    399  *                       Handling framebuffer updates
    400  *******************************************************************************/
    401 
    402 /* Compresses a framebuffer region into JPEG image.
    403  * Param:
    404  *  mtsp - Multi-touch port descriptor with initialized JPEG compressor.
    405  *  fmt Descriptor for framebuffer region to compress.
    406  *  fb Beginning of the framebuffer.
    407  *  jpeg_quality JPEG compression quality. A number from 1 to 100. Note that
    408  *      value 10 provides pretty decent image for the purpose of multi-touch
    409  *      emulation.
    410  */
    411 static void
    412 _fb_compress(const AndroidMTSPort* mtsp,
    413              const MTFrameHeader* fmt,
    414              const uint8_t* fb,
    415              int jpeg_quality,
    416              int ydir)
    417 {
    418     T("Multi-touch: compressing %d bytes frame buffer", fmt->w * fmt->h * fmt->bpp);
    419 
    420     jpeg_compressor_compress_fb(mtsp->jpeg_compressor, fmt->x, fmt->y, fmt->w,
    421                                 fmt->h, fmt->disp_height, fmt->bpp, fmt->bpl,
    422                                 fb, jpeg_quality, ydir);
    423 }
    424 
    425 int
    426 mts_port_send_frame(AndroidMTSPort* mtsp,
    427                     MTFrameHeader* fmt,
    428                     const uint8_t* fb,
    429                     on_sdkctl_direct_cb cb,
    430                     void* cb_opaque,
    431                     int ydir)
    432 {
    433     /* Make sure that port is connected. */
    434     if (!sdkctl_socket_is_port_ready(mtsp->sdkctl)) {
    435         return -1;
    436     }
    437 
    438     /* Compress framebuffer region. 10% quality seems to be sufficient. */
    439     fmt->format = MTFB_JPEG;
    440     _fb_compress(mtsp, fmt, fb, 10, ydir);
    441 
    442     /* Total size of the update data: header + JPEG image. */
    443     const int update_size =
    444         sizeof(MTFrameHeader) + jpeg_compressor_get_jpeg_size(mtsp->jpeg_compressor);
    445 
    446     /* Update message starts at the beginning of the buffer allocated by the
    447      * compressor's destination manager. */
    448     uint8_t* const msg = (uint8_t*)jpeg_compressor_get_buffer(mtsp->jpeg_compressor);
    449 
    450     /* Initialize message header. */
    451     sdkctl_init_message_header(msg, SDKCTL_MT_FB_UPDATE, update_size);
    452 
    453     /* Copy framebuffer update header to the message. */
    454     memcpy(msg + sdkctl_message_get_header_size(), fmt, sizeof(MTFrameHeader));
    455 
    456     /* Compression rate... */
    457     const float comp_rate = ((float)jpeg_compressor_get_jpeg_size(mtsp->jpeg_compressor) / (fmt->w * fmt->h * fmt->bpp)) * 100;
    458 
    459     /* Zeroing the rectangle in the update header we indicate that it contains
    460      * no updates. */
    461     fmt->x = fmt->y = fmt->w = fmt->h = 0;
    462 
    463     /* Send update to the device. */
    464     sdkctl_direct_packet_send(mtsp->fb_packet, msg, cb, cb_opaque);
    465 
    466     T("Multi-touch: Sent %d bytes in framebuffer update. Compression rate is %.2f%%",
    467       update_size, comp_rate);
    468 
    469     return 0;
    470 }
    471