Rename hid event "buffer" to "data"

This fields contains the HID event data (there is no "bufferization").

PR #4473 <https://github.com/Genymobile/scrcpy/pull/4473>

app/src/usb/aoa_hid.c

@@ -27,7 +27,7 @@ sc_hid_event_log(const struct sc_hid_event *event) {
         return;
     }
     for (unsigned i = 0; i < event->size; ++i) {
-        snprintf(buffer + i * 3, 4, " %02x", event->buffer[i]);
+        snprintf(buffer + i * 3, 4, " %02x", event->data[i]);
     }
     LOGV("HID Event: [%d]%s", event->accessory_id, buffer);
     free(buffer);
@@ -35,16 +35,16 @@ sc_hid_event_log(const struct sc_hid_event *event) {
 
 void
 sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
-                  unsigned char *buffer, uint16_t buffer_size) {
+                  unsigned char *data, uint16_t size) {
     hid_event->accessory_id = accessory_id;
-    hid_event->buffer = buffer;
-    hid_event->size = buffer_size;
+    hid_event->data = data;
+    hid_event->size = size;
     hid_event->ack_to_wait = SC_SEQUENCE_INVALID;
 }
 
 void
 sc_hid_event_destroy(struct sc_hid_event *hid_event) {
-    free(hid_event->buffer);
+    free(hid_event->data);
 }
 
 bool
@@ -177,7 +177,7 @@ sc_aoa_send_hid_event(struct sc_aoa *aoa, const struct sc_hid_event *event) {
     // index (arg1): 0 (unused)
     uint16_t value = event->accessory_id;
     uint16_t index = 0;
-    unsigned char *data = event->buffer;
+    unsigned char *data = event->data;
     uint16_t length = event->size;
     int result = libusb_control_transfer(aoa->usb->handle, request_type,
                                          request, value, index, data, length,

app/src/usb/aoa_hid.h

@@ -14,7 +14,7 @@
 
 struct sc_hid_event {
     uint16_t accessory_id;
-    unsigned char *buffer;
+    unsigned char *data;
     uint16_t size;
     uint64_t ack_to_wait;
 };
@@ -22,7 +22,7 @@ struct sc_hid_event {
 // Takes ownership of buffer
 void
 sc_hid_event_init(struct sc_hid_event *hid_event, uint16_t accessory_id,
-                  unsigned char *buffer, uint16_t buffer_size);
+                  unsigned char *data, uint16_t size);
 
 void
 sc_hid_event_destroy(struct sc_hid_event *hid_event);

app/src/usb/hid_keyboard.c

@@ -233,17 +233,17 @@ sdl_keymod_to_hid_modifiers(uint16_t mod) {
 
 static bool
 sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) {
-    unsigned char *buffer = malloc(HID_KEYBOARD_EVENT_SIZE);
-    if (!buffer) {
+    unsigned char *data = malloc(HID_KEYBOARD_EVENT_SIZE);
+    if (!data) {
         LOG_OOM();
         return false;
     }
 
-    buffer[HID_KEYBOARD_INDEX_MODIFIER] = HID_MODIFIER_NONE;
-    buffer[1] = HID_RESERVED;
-    memset(&buffer[HID_KEYBOARD_INDEX_KEYS], 0, HID_KEYBOARD_MAX_KEYS);
+    data[HID_KEYBOARD_INDEX_MODIFIER] = HID_MODIFIER_NONE;
+    data[1] = HID_RESERVED;
+    memset(&data[HID_KEYBOARD_INDEX_KEYS], 0, HID_KEYBOARD_MAX_KEYS);
 
-    sc_hid_event_init(hid_event, HID_KEYBOARD_ACCESSORY_ID, buffer,
+    sc_hid_event_init(hid_event, HID_KEYBOARD_ACCESSORY_ID, data,
                       HID_KEYBOARD_EVENT_SIZE);
     return true;
 }
@@ -282,9 +282,9 @@ convert_hid_keyboard_event(struct sc_hid_keyboard *kb,
              kb->keys[scancode] ? "true" : "false");
     }
 
-    hid_event->buffer[HID_KEYBOARD_INDEX_MODIFIER] = modifiers;
+    hid_event->data[HID_KEYBOARD_INDEX_MODIFIER] = modifiers;
 
-    unsigned char *keys_buffer = &hid_event->buffer[HID_KEYBOARD_INDEX_KEYS];
+    unsigned char *keys_data = &hid_event->data[HID_KEYBOARD_INDEX_KEYS];
     // Re-calculate pressed keys every time
     int keys_pressed_count = 0;
     for (int i = 0; i < SC_HID_KEYBOARD_KEYS; ++i) {
@@ -296,11 +296,11 @@ convert_hid_keyboard_event(struct sc_hid_keyboard *kb,
                 //  - Modifiers
                 //  - Reserved
                 //  - ErrorRollOver * HID_MAX_KEYS
-                memset(keys_buffer, HID_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
+                memset(keys_data, HID_ERROR_ROLL_OVER, HID_KEYBOARD_MAX_KEYS);
                 goto end;
             }
 
-            keys_buffer[keys_pressed_count] = i;
+            keys_data[keys_pressed_count] = i;
             ++keys_pressed_count;
         }
     }
@@ -331,11 +331,11 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t mods_state) {
 
     unsigned i = 0;
     if (capslock) {
-        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
+        hid_event.data[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK;
         ++i;
     }
     if (numlock) {
-        hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
+        hid_event.data[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_NUMLOCK;
         ++i;
     }
 

app/src/usb/hid_mouse.c

@@ -133,13 +133,13 @@ static const unsigned char mouse_report_desc[]  = {
 
 static bool
 sc_hid_mouse_event_init(struct sc_hid_event *hid_event) {
-    unsigned char *buffer = calloc(1, HID_MOUSE_EVENT_SIZE);
-    if (!buffer) {
+    unsigned char *data = calloc(1, HID_MOUSE_EVENT_SIZE);
+    if (!data) {
         LOG_OOM();
         return false;
     }
 
-    sc_hid_event_init(hid_event, HID_MOUSE_ACCESSORY_ID, buffer,
+    sc_hid_event_init(hid_event, HID_MOUSE_ACCESSORY_ID, data,
                       HID_MOUSE_EVENT_SIZE);
     return true;
 }
@@ -175,11 +175,11 @@ sc_mouse_processor_process_mouse_motion(struct sc_mouse_processor *mp,
         return;
     }
 
-    unsigned char *buffer = hid_event.buffer;
-    buffer[0] = buttons_state_to_hid_buttons(event->buttons_state);
-    buffer[1] = CLAMP(event->xrel, -127, 127);
-    buffer[2] = CLAMP(event->yrel, -127, 127);
-    buffer[3] = 0; // wheel coordinates only used for scrolling
+    unsigned char *data = hid_event.data;
+    data[0] = buttons_state_to_hid_buttons(event->buttons_state);
+    data[1] = CLAMP(event->xrel, -127, 127);
+    data[2] = CLAMP(event->yrel, -127, 127);
+    data[3] = 0; // wheel coordinates only used for scrolling
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
@@ -197,11 +197,11 @@ sc_mouse_processor_process_mouse_click(struct sc_mouse_processor *mp,
         return;
     }
 
-    unsigned char *buffer = hid_event.buffer;
-    buffer[0] = buttons_state_to_hid_buttons(event->buttons_state);
-    buffer[1] = 0; // no x motion
-    buffer[2] = 0; // no y motion
-    buffer[3] = 0; // wheel coordinates only used for scrolling
+    unsigned char *data = hid_event.data;
+    data[0] = buttons_state_to_hid_buttons(event->buttons_state);
+    data[1] = 0; // no x motion
+    data[2] = 0; // no y motion
+    data[3] = 0; // wheel coordinates only used for scrolling
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {
         sc_hid_event_destroy(&hid_event);
@@ -219,13 +219,13 @@ sc_mouse_processor_process_mouse_scroll(struct sc_mouse_processor *mp,
         return;
     }
 
-    unsigned char *buffer = hid_event.buffer;
-    buffer[0] = 0; // buttons state irrelevant (and unknown)
-    buffer[1] = 0; // no x motion
-    buffer[2] = 0; // no y motion
+    unsigned char *data = hid_event.data;
+    data[0] = 0; // buttons state irrelevant (and unknown)
+    data[1] = 0; // no x motion
+    data[2] = 0; // no y motion
     // In practice, vscroll is always -1, 0 or 1, but in theory other values
     // are possible
-    buffer[3] = CLAMP(event->vscroll, -127, 127);
+    data[3] = CLAMP(event->vscroll, -127, 127);
     // Horizontal scrolling ignored
 
     if (!sc_aoa_push_hid_event(mouse->aoa, &hid_event)) {