Return to framebuffer.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / hw

Annotation of qemu/hw/framebuffer.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Framebuffer device helper routines
                      3:  *
                      4:  * Copyright (c) 2009 CodeSourcery
                      5:  * Written by Paul Brook <[email protected]>
                      6:  *
                      7:  * This code is licensed under the GNU GPLv2.
                      8:  */
                      9: 
                     10: /* TODO:
                     11:    - Do something similar for framebuffers with local ram
                     12:    - Handle rotation here instead of hacking dest_pitch
                     13:    - Use common pixel conversion routines instead of per-device drawfn
                     14:    - Remove all DisplayState knowledge from devices.
                     15:  */
                     16: 
                     17: #include "hw.h"
                     18: #include "console.h"
                     19: #include "framebuffer.h"
                     20: 
                     21: /* Render an image from a shared memory framebuffer.  */
                     22:    
                     23: void framebuffer_update_display(
                     24:     DisplayState *ds,
                     25:     target_phys_addr_t base,
                     26:     int cols, /* Width in pixels.  */
                     27:     int rows, /* Leight in pixels.  */
                     28:     int src_width, /* Length of source line, in bytes.  */
                     29:     int dest_row_pitch, /* Bytes between adjacent horizontal output pixels.  */
                     30:     int dest_col_pitch, /* Bytes between adjacent vertical output pixels.  */
                     31:     int invalidate, /* nonzero to redraw the whole image.  */
                     32:     drawfn fn,
                     33:     void *opaque,
                     34:     int *first_row, /* Input and output.  */
                     35:     int *last_row /* Output only */)
                     36: {
                     37:     target_phys_addr_t src_len;
                     38:     uint8_t *dest;
                     39:     uint8_t *src;
                     40:     uint8_t *src_base;
                     41:     int first, last = 0;
                     42:     int dirty;
                     43:     int i;
                     44:     ram_addr_t addr;
                     45:     ram_addr_t pd;
                     46:     ram_addr_t pd2;
                     47: 
                     48:     i = *first_row;
                     49:     *first_row = -1;
                     50:     src_len = src_width * rows;
                     51: 
                     52:     cpu_physical_sync_dirty_bitmap(base, base + src_len);
                     53:     pd = cpu_get_physical_page_desc(base);
                     54:     pd2 = cpu_get_physical_page_desc(base + src_len - 1);
                     55:     /* We should reall check that this is a continuous ram region.
                     56:        Instead we just check that the first and last pages are
                     57:        both ram, and the right distance apart.  */
                     58:     if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM
                     59:         || (pd2 & ~TARGET_PAGE_MASK) > IO_MEM_ROM) {
                     60:         return;
                     61:     }
                     62:     pd = (pd & TARGET_PAGE_MASK) + (base & ~TARGET_PAGE_MASK);
                     63:     if (((pd + src_len - 1) & TARGET_PAGE_MASK) != (pd2 & TARGET_PAGE_MASK)) {
                     64:         return;
                     65:     }
                     66: 
                     67:     src_base = cpu_physical_memory_map(base, &src_len, 0);
                     68:     /* If we can't map the framebuffer then bail.  We could try harder,
                     69:        but it's not really worth it as dirty flag tracking will probably
                     70:        already have failed above.  */
                     71:     if (!src_base)
                     72:         return;
                     73:     if (src_len != src_width * rows) {
                     74:         cpu_physical_memory_unmap(src_base, src_len, 0, 0);
                     75:         return;
                     76:     }
                     77:     src = src_base;
                     78:     dest = ds_get_data(ds);
                     79:     if (dest_col_pitch < 0)
                     80:         dest -= dest_col_pitch * (cols - 1);
                     81:     first = -1;
                     82:     addr = pd;
                     83: 
                     84:     addr += i * src_width;
                     85:     src += i * src_width;
                     86:     dest += i * dest_row_pitch;
                     87: 
                     88:     for (; i < rows; i++) {
                     89:         target_phys_addr_t dirty_offset;
                     90:         dirty = 0;
                     91:         dirty_offset = 0;
                     92:         while (addr + dirty_offset < TARGET_PAGE_ALIGN(addr + src_width)) {
                     93:             dirty |= cpu_physical_memory_get_dirty(addr + dirty_offset,
                     94:                                                    VGA_DIRTY_FLAG);
                     95:             dirty_offset += TARGET_PAGE_SIZE;
                     96:         }
                     97: 
                     98:         if (dirty || invalidate) {
                     99:             fn(opaque, dest, src, cols, dest_col_pitch);
                    100:             if (first == -1)
                    101:                 first = i;
                    102:             last = i;
                    103:         }
                    104:         addr += src_width;
                    105:         src += src_width;
                    106:         dest += dest_row_pitch;
                    107:     }
                    108:     cpu_physical_memory_unmap(src_base, src_len, 0, 0);
                    109:     if (first < 0) {
                    110:         return;
                    111:     }
                    112:     cpu_physical_memory_reset_dirty(pd, pd + src_len, VGA_DIRTY_FLAG);
                    113:     *first_row = first;
                    114:     *last_row = last;
                    115:     return;
                    116: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.