Cross Reference: /system/media/camera/src/camera

Lines Matching defs:metadata
44  * A single metadata entry, storing an array of values of a given type. If the
61  * A packet of metadata. This is a list of entries, each of which may point to
91  * In short, the entries and data are contiguous in memory after the metadata
109  * A datum of metadata. This corresponds to camera_metadata_entry_t::data
157         const camera_metadata_t *metadata) {
159             ((uint8_t*)metadata + metadata->entries_start);
162 static uint8_t *get_data(const camera_metadata_t *metadata) {
163     return (uint8_t*)metadata + metadata->data_start;
177     camera_metadata_t *metadata = (camera_metadata_t*) buffer;
178     if (validate_camera_metadata_structure(metadata, &src_size) != OK) {
183     return metadata;
209     camera_metadata_t *metadata = (camera_metadata_t*)dst;
210     metadata->version = CURRENT_METADATA_VERSION;
211     metadata->flags = 0;
212     metadata->entry_count = 0;
213     metadata->entry_capacity = entry_capacity;
214     metadata->entries_start =
216     metadata->data_count = 0;
217     metadata->data_capacity = data_capacity;
218     metadata->size = memory_needed;
219     size_t data_unaligned = (uint8_t*)(get_entries(metadata) +
220             metadata->entry_capacity) - (uint8_t*)metadata;
221     metadata->data_start = ALIGN_TO(data_unaligned, DATA_ALIGNMENT);
222     metadata->user = NULL;
224     return metadata;
226 void free_camera_metadata(camera_metadata_t *metadata) {
227     free(metadata);
242 size_t get_camera_metadata_size(const camera_metadata_t *metadata) {
243     if (metadata == NULL) return ERROR;
245     return metadata->size;
248 size_t get_camera_metadata_compact_size(const camera_metadata_t *metadata) {
249     if (metadata == NULL) return ERROR;
251     return calculate_camera_metadata_size(metadata->entry_count,
252                                           metadata->data_count);
255 size_t get_camera_metadata_entry_count(const camera_metadata_t *metadata) {
256     return metadata->entry_count;
259 size_t get_camera_metadata_entry_capacity(const camera_metadata_t *metadata) {
260     return metadata->entry_capacity;
263 size_t get_camera_metadata_data_count(const camera_metadata_t *metadata) {
264     return metadata->data_count;
267 size_t get_camera_metadata_data_capacity(const camera_metadata_t *metadata) {
268     return metadata->data_capacity;
278     camera_metadata_t *metadata =
281     metadata->flags = src->flags;
282     metadata->entry_count = src->entry_count;
283     metadata->data_count = src->data_count;
285     memcpy(get_entries(metadata), get_entries(src),
286             sizeof(camera_metadata_buffer_entry_t[metadata->entry_count]));
287     memcpy(get_data(metadata), get_data(src),
288             sizeof(uint8_t[metadata->data_count]));
289     metadata->user = NULL;
291     return metadata;
294 int validate_camera_metadata_structure(const camera_metadata_t *metadata,
297     if (metadata == NULL) {
301     // Check that the metadata pointer is well-aligned first.
322             uintptr_t aligned_ptr = ALIGN_TO(metadata, alignments[i].alignment);
324             if ((uintptr_t)metadata != aligned_ptr) {
327                       __FUNCTION__, metadata,
335      * Check that the metadata contents are correct
338     if (expected_size != NULL && metadata->size > *expected_size) {
340               __FUNCTION__, metadata->size, *expected_size);
344     if (metadata->entry_count > metadata->entry_capacity) {
346               __FUNCTION__, metadata->entry_count, metadata->entry_capacity);
350     uptrdiff_t entries_end = metadata->entries_start + metadata->entry_capacity;
351     if (entries_end < metadata->entries_start || // overflow check
352         entries_end > metadata->data_start) {
356               (metadata->entries_start + metadata->entry_capacity),
357               metadata->data_start);
361     uptrdiff_t data_end = metadata->data_start + metadata->data_capacity;
362     if (data_end < metadata->data_start || // overflow check
363         data_end > metadata->size) {
367               (metadata->data_start + metadata->data_capacity),
368               metadata->size);
373     size_t entry_count = metadata->entry_count;
374     camera_metadata_buffer_entry_t *entries = get_entries(metadata);
409                     (camera_metadata_data_t*) (get_data(metadata) +
423                 data_entry_end > metadata->data_capacity) {
427                       metadata->data_capacity);
818 void dump_camera_metadata(const camera_metadata_t *metadata,
821     dump_indented_camera_metadata(metadata, fd, verbosity, 0);
824 void dump_indented_camera_metadata(const camera_metadata_t *metadata,
828     if (metadata == NULL) {
829         fdprintf(fd, "%*sDumping camera metadata array: Not allocated\n",
835             "%*sDumping camera metadata array: %d / %d entries, "
837             metadata->entry_count, metadata->entry_capacity,
838             metadata->data_count, metadata->data_capacity);
841             metadata->version, metadata->flags);
842     camera_metadata_buffer_entry_t *entry = get_entries(metadata);
843     for (i=0; i < metadata->entry_count; i++, entry++) {
875             if (entry->data.offset >= metadata->data_count) {
879                         metadata->data_count);
882             data_ptr = get_data(metadata) + entry->data.offset;