Searched defs:data (Results 1 - 24 of 24) sorted by relevance

/bootable/recovery/minui/
H A Dminui.h33 unsigned char* data; member in struct:__anon19
63 typedef int (*ev_callback)(int fd, uint32_t epevents, void *data);
64 typedef int (*ev_set_key_callback)(int code, int value, void *data);
66 int ev_init(ev_callback input_cb, void *data);
68 int ev_add_fd(int fd, ev_callback cb, void *data);
69 int ev_sync_key_state(ev_set_key_callback set_key_cb, void *data);
99 // frames this image represents. The pixel data itself is interlaced
110 // the subimages' size and intended locale in the pixel data. See
H A Devents.c39 void *data; member in struct:fd_info
52 int ev_init(ev_callback input_cb, void *data) argument
88 ev.data.ptr = (void *)&ev_fdinfo[ev_count];
97 ev_fdinfo[ev_count].data = data;
113 int ev_add_fd(int fd, ev_callback cb, void *data) argument
122 ev.data.ptr = (void *)&ev_fdinfo[ev_count];
127 ev_fdinfo[ev_count].data = data;
164 struct fd_info *fdi = polledevents[n].data
183 ev_sync_key_state(ev_set_key_callback set_key_cb, void *data) argument
[all...]
H A Dgraphics.c127 unsigned char* src_p = font->texture->data + (off * font->cwidth) +
129 unsigned char* dst_p = gr_draw->data + y*gr_draw->row_bytes + x*gr_draw->pixel_bytes;
153 unsigned char* src_p = icon->data;
154 unsigned char* dst_p = gr_draw->data + y*gr_draw->row_bytes + x*gr_draw->pixel_bytes;
173 memset(gr_draw->data, gr_current_r, gr_draw->height * gr_draw->row_bytes);
176 unsigned char* px = gr_draw->data;
199 unsigned char* p = gr_draw->data + y1 * gr_draw->row_bytes + x1 * gr_draw->pixel_bytes;
243 unsigned char* src_p = source->data + sy*source->row_bytes + sx*source->pixel_bytes;
244 unsigned char* dst_p = gr_draw->data + dy*gr_draw->row_bytes + dx*gr_draw->pixel_bytes;
290 gr_font->texture->data
292 unsigned char data; local
[all...]
/bootable/recovery/applypatch/
H A Dapplypatch.h31 unsigned char* data; member in struct:_FileContents
H A Dapplypatch.c35 static ssize_t FileSink(const unsigned char* data, ssize_t len, void* token);
53 file->data = NULL;
68 file->data = malloc(file->size);
73 free(file->data);
74 file->data = NULL;
78 ssize_t bytes_read = fread(file->data, 1, file->size, f);
82 free(file->data);
83 file->data = NULL;
88 SHA_hash(file->data, file->size, file->sha1);
117 // target data, whic
351 WriteToPartition(unsigned char* data, size_t len, const char* target) argument
623 FileSink(const unsigned char* data, ssize_t len, void* token) argument
644 MemorySink(const unsigned char* data, ssize_t len, void* token) argument
[all...]
H A Dimgdiff.c20 * data interspersed with uncompressed data. Doing a naive bsdiff of
21 * these files is not useful because small changes in the data lead to
23 * data are typically as large as the data itself.
28 * bsdiff is applied to the uncompressed data, then the patched data is
99 * data (target len)
104 * expanded len" is the size of the uncompressed source data. "target
105 * expected len" is the size of the uncompressed data afte
141 unsigned char* data; // data to be patched (uncompressed, for deflate chunks) member in struct:__anon2
632 unsigned char* data = malloc(st.st_size); local
[all...]
/bootable/recovery/minadbd/
H A Dutils.c48 buff_addb (char* buff, char* buffEnd, const void* data, int len) argument
58 memcpy(buff, data, len);
H A Dusb_linux_client.c46 int (*write)(usb_handle *h, const void *data, int len);
47 int (*read)(usb_handle *h, void *data, int len);
187 static int usb_adb_write(usb_handle *h, const void *data, int len) argument
192 n = adb_write(h->fd, data, len);
202 static int usb_adb_read(usb_handle *h, void *data, int len) argument
207 n = adb_read(h->fd, data, len);
367 static int usb_ffs_write(usb_handle *h, const void *data, int len) argument
372 n = bulk_write(h->bulk_in, data, len);
403 static int usb_ffs_read(usb_handle *h, void *data, int len) argument
408 n = bulk_read(h->bulk_out, data, le
475 usb_write(usb_handle *h, const void *data, int len) argument
480 usb_read(usb_handle *h, void *data, int len) argument
[all...]
H A Dadb.h54 unsigned data_check; /* checksum of data payload */
66 unsigned char data[MAX_PAYLOAD]; member in struct:apacket
106 /* enqueue is called by our peer when it has data
108 ** data or 1 if not. If we return 1, we must call
110 ** receive data.
115 ** us to send data via enqueue again
380 int usb_write(usb_handle *h, const void *data, int len);
381 int usb_read(usb_handle *h, void *data, int len);
H A Dtransport.c132 dump_hex(p->data, len);
221 x = (unsigned char *) p->data;
273 D("%s: data pump started\n", t->serial);
422 static void transport_registration_func(int _fd, unsigned ev, void *data) argument
792 x = p->data;
/bootable/recovery/tests/
H A Dasn1_decoder_test.cpp66 uint8_t data[] = { 0xA5, 0x02, 0x06, 0x01, 0x01, }; local
67 asn1_context_t* ctx = asn1_context_new(data, sizeof(data));
79 uint8_t data[] = { 0xA5, 0x03, 0x06, 0x01, 0x01, }; local
80 asn1_context_t* ctx = asn1_context_new(data, sizeof(data));
101 uint8_t data[] = { 0xA0, 0x03, 0x02, 0x01, 0x01, local
104 asn1_context_t* ctx = asn1_context_new(data, sizeof(data));
122 uint8_t data[] local
134 uint8_t data[] = { 0x30, 0x03, 0x06, 0x01, 0x01, }; local
155 uint8_t data[] = { 0x31, 0x02, 0x06, 0x01, 0x01, }; local
167 uint8_t data[] = { 0x31, 0x03, 0x06, 0x01, 0xBA, }; local
181 uint8_t data[] = { 0x06, 0x00, 0x01, }; local
190 uint8_t data[] = { 0x06, 0x01, }; local
199 uint8_t data[] = { 0x06, 0x01, 0x99, }; local
210 uint8_t data[] = { 0x04, 0x00, 0x55, }; local
219 uint8_t data[] = { 0x04, 0x01, }; local
228 uint8_t data[] = { 0x04, 0x01, 0xAA, }; local
[all...]
/bootable/recovery/tools/ota/
H A Dconvert-to-bmp.py27 "L" # offset to start of bitmap data)
37 "L" # size of image data (0 if uncompressed)
70 data = im.tostring() variable
73 f.write(data[i+2]) # B
74 f.write(data[i+1]) # G
75 f.write(data[i+0]) # R
76 f.write(data[i+3]) # A
/bootable/recovery/
H A Dbootloader.cpp88 char data[size]; local
89 ssize_t r = mtd_read_data(read, data, size);
94 memcpy(out, &data[write_size * MISC_COMMAND_PAGE], sizeof(*out));
114 char data[size]; local
115 ssize_t r = mtd_read_data(read, data, size);
120 memcpy(&data[write_size * MISC_COMMAND_PAGE], in, sizeof(*in));
127 if (mtd_write_data(write, data, size) != size) {
H A Dfuse_sideload.c20 // from it causes data to be fetched from the adb host. We can use
26 // same data as the first read at that position. That is, once a
28 // the same data. (Otherwise, a malicious adb host process could
96 static void fuse_reply(struct fuse_data* fd, __u64 unique, const void *data, size_t len) argument
108 vec[1].iov_base = data;
117 static int handle_init(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) { argument
118 const struct fuse_init_in* req = data;
147 static int handle_getattr(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) { argument
148 const struct fuse_getattr_in* req = data;
167 static int handle_lookup(void* data, struc argument
192 handle_open(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) argument
205 handle_flush(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) argument
209 handle_release(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) argument
268 handle_read(void* data, struct fuse_data* fd, const struct fuse_in_header* hdr) argument
437 void* data = request_buffer + sizeof(struct fuse_in_header); local
[all...]
H A Dui.cpp68 int RecoveryUI::input_callback(int fd, uint32_t epevents, void* data) argument
H A Drecovery.cpp97 * --wipe_data - erase user data (and cache), then reboot
98 * --wipe_cache - wipe cache (but not user data), then reboot
112 * 5. erase_volume() reformats /data
365 unsigned char* data; member in struct:_saved_log_file
403 p->data = (unsigned char*) malloc(p->st.st_size);
405 fread(p->data, 1, p->st.st_size, f);
431 fwrite(head->data, 1, head->st.st_size, f);
437 free(head->data);
642 const char* headers[] = { "Confirm wipe of all user data?",
656 " Yes -- delete all user data", // [
[all...]
/bootable/recovery/edify/
H A Dexpr.h33 // Optional pointer to app-specific data; the core of edify never
48 #define VAL_STRING 1 // data will be NULL-terminated; size doesn't count null
54 char* data; member in struct:__anon5
/bootable/recovery/minzip/
H A DHash.h37 typedef int (*HashForeachFunc)(void* data, void* arg);
40 * One entry in the hash table. "data" values are expected to be (or have
42 * value for "data" indicates an empty slot, and HASH_TOMBSTONE indicates
47 * When an entry is released, we will call (HashFreeFunc)(entry->data).
51 void* data; member in struct:HashEntry
124 * Remove an item from the hash table, given its "data" pointer. Does not
144 * MyData* data = (MyData*)mzHashIterData(&iter);
148 void* data; member in struct:HashIter
156 void* data = pIter->pHashTable->pEntries[i].data; local
[all...]
H A DHash.c84 if (pEnt->data == HASH_TOMBSTONE) {
86 pEnt->data = NULL;
87 } else if (pEnt->data != NULL) {
90 (*pHashTable->freeFunc)(pEnt->data);
91 pEnt->data = NULL;
120 if (pHashTable->pEntries[i].data == HASH_TOMBSTONE)
150 void* data = pHashTable->pEntries[i].data; local
151 if (data != NULL && data !
373 const void* data = (const void*)mzHashIterData(&iter); local
[all...]
H A DZip.c240 * Create data structures to hold entries.
499 /* Call processFunction on the uncompressed data of a STORED entry.
550 * Loop while we have data.
553 /* uncompress the data */
596 * Stream the uncompressed data through the supplied function,
628 static bool crcProcessFunction(const unsigned char *data, int dataLen, argument
631 *(unsigned long *)crc = crc32(*(unsigned long *)crc, data, dataLen);
664 static bool copyProcessFunction(const unsigned char *data, int dataLen, argument
669 memcpy(args->buf, data, dataLen);
697 static bool writeProcessFunction(const unsigned char *data, in argument
762 bufferProcessFunction(const unsigned char *data, int dataLen, void *cookie) argument
[all...]
/bootable/recovery/mtdutils/
H A Dflash_image.c57 void *data; local
H A Dmtdutils.c288 static int read_block(const MtdPartition *partition, int fd, char *data) argument
302 if (lseek64(fd, pos, SEEK_SET) != pos || read(fd, data, size) != size) {
329 ssize_t mtd_read_data(MtdReadContext *ctx, char *data, size_t len) argument
336 memcpy(data + read, ctx->buffer + ctx->consumed, copy);
344 if (read_block(ctx->partition, ctx->fd, data + read)) return -1;
407 static int write_block(MtdWriteContext *ctx, const char *data) argument
439 write(fd, data, size) != size) {
451 if (memcmp(data, verify, size) != 0) {
476 ssize_t mtd_write_data(MtdWriteContext *ctx, const char *data, size_t len) argument
484 memcpy(ctx->buffer + ctx->stored, data
[all...]
/bootable/recovery/updater/
H A Dblockimg.c83 static void readblock(int fd, uint8_t* data, size_t size) { argument
86 ssize_t r = read(fd, data+so_far, size-so_far);
96 static void writeblock(int fd, const uint8_t* data, size_t size) { argument
99 ssize_t w = write(fd, data+written, size-written);
144 static ssize_t RangeSinkWrite(const uint8_t* data, ssize_t size, void* token) { argument
156 writeblock(rss->fd, data, write_now);
157 data += write_now;
180 // All of the data for all the 'new' transfers is contained in one
186 // To achieve this, we expand the new data from the archive in a
188 // data' functio
211 receive_new_data(const unsigned char* data, int size, void* cookie) argument
[all...]
H A Dinstall.c557 v->data = NULL;
569 v->data = malloc(v->size);
570 if (v->data == NULL) {
577 (unsigned char *)v->data);
582 free(v->data);
583 v->data = NULL;
842 cap_data.data[0].permitted = (uint32_t) (parsed.capabilities & 0xffffffff);
843 cap_data.data[0].inheritable = 0;
844 cap_data.data[1].permitted = (uint32_t) (parsed.capabilities >> 32);
845 cap_data.data[
1031 write_raw_image_cb(const unsigned char* data, int data_len, void* ctx) argument
[all...]

Completed in 1880 milliseconds