gtkbitmap.cpp

FreeAMP(MP3播放)程序源代码-用来研究MP3解码

                                    ptr = data_end;

                            }

                            if ((l & 3) == 1) {
                                tempchar = *(buffer_ptr++);
                                tempchar = *(buffer_ptr++);
                            }
                            else if ((l & 3) == 2)
                                buffer_ptr++;
                            break;
                    }
                }
            }
        }
        else if (comp == BI_RGB) {
            skip = ((((w + 7) / 8) * 8) - w) / 2;
            for (y = 0; y < h; y++) {
                for (x = 0; x < w && buffer_ptr < buffer_end; x++) {
                    if ((x & 1) == 0)
                        byte = *(buffer_ptr++);
                    k = (byte & 0xF0) >> 4;
                    *ptr++ = rgbQuads[k].rgbRed;
                    *ptr++ = rgbQuads[k].rgbGreen;
                    *ptr++ = rgbQuads[k].rgbBlue;
                    byte <<= 4;
                }
                buffer_ptr += skip;
                ptr -= w * 6;
            }
        }
    }
    if (bitcount == 8) {
        if (comp == BI_RLE8) {
            x = 0;
            y = 0;
            for (i = 0, g = 1; i < imgsize && buffer_ptr < buffer_end && g; i++) {
                byte = *(buffer_ptr++);
                if (byte) {
                    l = byte;
                    byte = *(buffer_ptr++);
                    for (j = 0; j < l; j++) {
                        if (x >= w)
                            break;

                        *ptr++ = rgbQuads[byte].rgbRed;
                        *ptr++ = rgbQuads[byte].rgbGreen;
                        *ptr++ = rgbQuads[byte].rgbBlue;
                        x++;
                        if (ptr > data_end)
                            ptr = data_end;
                    }
                }
                else {
                    byte = *(buffer_ptr++);
                    switch (byte) {
                        case 0:
                            x = 0;
                            y++;
                            ptr = data + ((h - y - 1) * w * 3) + (x * 3);
                            if (ptr > data_end)
                                ptr = data_end;
                            break;
                        case 1:
                            g = 0;
                            break;
                        case 2:
                            x += *(buffer_ptr++);
                            y += *(buffer_ptr++);
                            ptr = data + ((h - y - 1) * w * 3) + (x * 3);
                            if (ptr > data_end)
                                ptr = data_end;
                            break;
                        default:
                            l = byte;
                            for (j = 0; j < l; j++) {
                                byte = *(buffer_ptr++);

                                if (x >= w) {
                                    buffer_ptr += l - j;
                                    break;
                                }

                                *ptr++ = rgbQuads[byte].rgbRed;
                                *ptr++ = rgbQuads[byte].rgbGreen;
                                *ptr++ = rgbQuads[byte].rgbBlue;
                                x++;

                                if (ptr > data_end)
                                    ptr = data_end;
                            }
                            if (l & 1)
                                buffer_ptr++;
                            break;
                    }
                }
            }
        }
        else if (comp == BI_RGB) {
            skip = (((w + 3) / 4) * 4) - w;
            for (y = 0; y < h; y++) {
                for (x = 0; x < w && buffer_ptr < buffer_end; x++) {
                    byte = *(buffer_ptr++);
                    *ptr++ = rgbQuads[byte].rgbRed;
                    *ptr++ = rgbQuads[byte].rgbGreen;
                    *ptr++ = rgbQuads[byte].rgbBlue;
                }
                ptr -= w * 6;
                buffer_ptr += skip;
            }
        }

    }
    else if (bitcount == 16) {
        skip = (((w * 16 + 31) / 32) * 4) - (w * 2);
        for (y = 0; y < h; y++) {
            for (x = 0; x < w && buffer_ptr < buffer_end; x++) {
                r = ((gushort)(*buffer_ptr) & rmask) >> rshift;
                g = ((gushort)(*buffer_ptr) & gmask) >> gshift;
                b = ((gushort)(*(buffer_ptr++)) & bmask) >> bshift;
                *ptr++ = r;
                *ptr++ = g;
                *ptr++ = b;
            }
            ptr -= w * 6;
            buffer_ptr += skip;
        }
    }
    else if (bitcount == 24) {
        skip = (4 - ((w * 3) % 4)) & 3;
        for (y = 0; y < h; y++) {
            for (x = 0; x < w && buffer_ptr < buffer_end; x++) {
                b = *(buffer_ptr++);
                g = *(buffer_ptr++);
                r = *(buffer_ptr++);
                *ptr++ = r;
                *ptr++ = g;
                *ptr++ = b;
            }
            ptr -= w * 6;
            buffer_ptr += skip;
        }
    }
    else if (bitcount == 32) {
        skip = (((w * 32 + 31) / 32) * 4) - (w * 4);
        for (y = 0; y < h; y++) {
            for (x = 0; x < w && buffer_ptr < buffer_end; x++) {
                r = ((gulong)(*buffer_ptr) & rmask) >> rshift;
                g = ((gulong)(*buffer_ptr) & gmask) >> gshift;
                b = ((gulong)(*buffer_ptr) & bmask) >> bshift;
                *ptr++ = r;
                *ptr++ = g;
                *ptr++ = b;
                r = *(buffer_ptr++);
                r = *(buffer_ptr++);
            }
            ptr -= w * 6;
            buffer_ptr += skip;
        }
    }

    gdk_threads_enter();
    if (m_bHasTransColor) {
        ptr = data;
        m_MaskBitmap = gdk_pixmap_new(NULL, w, h, 1);
        GdkGC *gc = gdk_gc_new(m_MaskBitmap);
        GdkColor color;
        color.pixel = 1;
        gdk_gc_set_foreground(gc, &color);
        gdk_draw_rectangle(m_MaskBitmap, gc, TRUE, 0, 0, w, h);
        color.pixel = 0;
        gdk_gc_set_foreground(gc, &color);
        for (y = 0; y < h; y++)
            for (x = 0; x < w; x++) {
                guchar r = *ptr++;
                guchar g = *ptr++;
                guchar b = *ptr++;
                if (r == m_oTransColor.red && g == m_oTransColor.green &&
                    b == m_oTransColor.blue)
                    gdk_draw_point(m_MaskBitmap, gc, x, y);
            }
        gdk_gc_destroy(gc);
    }

    m_Bitmap = gdk_pixmap_new(NULL, w, h, gdk_visual_get_best_depth());
    gdk_draw_rgb_image(m_Bitmap, m_GC, 0, 0, w, h, GDK_RGB_DITHER_MAX, data, 
                       w * 3);

    gdk_threads_leave();
    g_free(data);
    g_free(buffer);

    m_width = w;
    m_height = h;

    return kError_NoErr;
}

bool GTKBitmap::IsPosVisible(Pos &oPos)
{
    Color col;
   
    GetColor(oPos, col);

    if (col.IsEqual(m_oTransColor))
        return false;
    return true;
}

Error GTKBitmap::BlitRect(Bitmap *pSrcBitmap, Rect &oSrcRect, 
                          Rect &oDestRect)
{
    GdkWindow *src = (GdkWindow *)(((GTKBitmap *)pSrcBitmap)->m_Bitmap);
    GdkWindow *dest = (GdkWindow *)m_Bitmap;

    gdk_threads_enter();
    gdk_window_copy_area(dest, m_GC, oDestRect.x1, oDestRect.y1, src,
                         oSrcRect.x1, oSrcRect.y1, oDestRect.Width(),
                         oDestRect.Height());
    gdk_threads_leave();

    return kError_NoErr;
}

Error GTKBitmap::MaskBlitRect(Bitmap *pSrcBitmap, Rect &oSrcRect,
                              Rect &oDestRect)
{
    GTKBitmap *src = (GTKBitmap *)pSrcBitmap;
    GdkWindow *dest = (GdkWindow *)m_Bitmap;
    int w = oDestRect.Width();
    int h = oDestRect.Height();

    if (!src->GetMask())
        return BlitRect(pSrcBitmap, oSrcRect, oDestRect);

    gdk_threads_enter();
    gdk_gc_set_clip_mask(m_GC, src->GetMask());
    gdk_gc_set_clip_origin(m_GC, oDestRect.x1 - oSrcRect.x1, oDestRect.y1 - 
                           oSrcRect.y1);
    gdk_draw_pixmap(dest, m_GC, src->GetBitmap(), oSrcRect.x1, oSrcRect.y1, 
                    oDestRect.x1, oDestRect.y1, w, h);
    gdk_threads_leave();    
    return kError_NoErr;
}

Error GTKBitmap::BlitRectMaskBitmap(Bitmap *pSrcBitmap, Rect &oSrcRect, 
                                    Rect &oDestRect)
{
    GdkWindow *src = (GdkWindow *)(((GTKBitmap *)pSrcBitmap)->m_MaskBitmap);
    GdkWindow *dest = (GdkWindow *)m_MaskBitmap;

    gdk_threads_enter();
    GdkGC *tempgc = gdk_gc_new(dest);
    gdk_window_copy_area(dest, tempgc, oDestRect.x1, oDestRect.y1, src,
                         oSrcRect.x1, oSrcRect.y1, oDestRect.Width(),
                         oDestRect.Height());
    gdk_gc_unref(tempgc);
    gdk_threads_leave();

    return kError_NoErr;
}

Bitmap *GTKBitmap::Clone(void)
{
   GTKBitmap *pTemp;
   Rect       oRect;

   pTemp = new GTKBitmap(m_width, m_height, m_oBitmapName);
   pTemp->m_oTransColor = m_oTransColor;
   pTemp->m_bHasTransColor = m_bHasTransColor;
   pTemp->shape_set = false;
   oRect.x1 = oRect.y1 = 0;
   oRect.x2 = m_width;
   oRect.y2 = m_height;
   pTemp->BlitRect(this, oRect, oRect);
   pTemp->BlitRectMaskBitmap(this, oRect, oRect);

   return pTemp;
} 

Error GTKBitmap::MakeTransparent(Rect &oRect)
{
    GdkColor   oGdkColor;
    GdkWindow *dest = (GdkWindow *)m_MaskBitmap;

    oGdkColor.pixel = 1;

    gdk_threads_enter();

    gdk_gc_set_foreground(m_GC, &oGdkColor);
    GdkGC *tempgc = gdk_gc_new(dest);
    gdk_draw_rectangle(dest, tempgc, 1, oRect.x1, oRect.y1, 
                       oRect.Width(), oRect.Height());
    gdk_gc_unref(tempgc);
    gdk_threads_leave();    
    return kError_NoErr;
}

void GTKBitmap::GetColor(Pos oPos, Color &oColor)
{
    gdk_threads_enter();

    if (!m_cache) {
        m_image = gdk_image_get(m_Bitmap, 0, 0, m_width, m_height);
        m_cmap = gdk_rgb_get_cmap();
        m_v = gdk_colormap_get_visual(m_cmap);
        m_cache = true;
    }

    guint32 pixel = gdk_image_get_pixel(m_image, oPos.x, oPos.y);

    switch (m_v->type) {
        case GDK_VISUAL_STATIC_GRAY:
        case GDK_VISUAL_GRAYSCALE:
        case GDK_VISUAL_STATIC_COLOR:
        case GDK_VISUAL_PSEUDO_COLOR: {
            oColor.red = m_cmap->colors[pixel].red;
            oColor.green = m_cmap->colors[pixel].green;
            oColor.blue = m_cmap->colors[pixel].blue;
            break; }
        case GDK_VISUAL_TRUE_COLOR: {
            uint32 component = 0;
            uint32 i;
            for (i = 24; i < 32; i += m_v->red_prec)
                component |= ((pixel & m_v->red_mask) << 
                              (32 - m_v->red_shift - m_v->red_prec)) >> i;
            oColor.red = component;
            component = 0;
            for (i = 24; i < 32; i += m_v->green_prec)
                component |= ((pixel & m_v->green_mask) << 
                              (32 - m_v->green_shift - m_v->green_prec)) >> i;
            oColor.green = component;
            component = 0;
            for (i = 24; i < 32; i += m_v->blue_prec)
                component |= ((pixel & m_v->blue_mask) << 
                              (32 - m_v->blue_shift - m_v->blue_prec)) >> i;
            oColor.blue = component;

            break; }
        case GDK_VISUAL_DIRECT_COLOR: {
            oColor.red = m_cmap->colors[((pixel & m_v->red_mask) << 
                                      (32 - m_v->red_shift - m_v->red_prec)) 
                                      >> 24].red;
            oColor.green = m_cmap->colors[((pixel & m_v->green_mask) << 
                                      (32 - m_v->green_shift - m_v->green_prec))
                                      >> 24].green;
            oColor.blue = m_cmap->colors[((pixel & m_v->blue_mask) << 
                                      (32 - m_v->blue_shift - m_v->blue_prec)) 
                                      >> 24].blue;
            break; }
        default:
            break;
    }
    gdk_image_destroy(m_image);
    m_image = NULL;
    m_cache = false;
    gdk_threads_leave();
}

void GTKBitmap::GetSize(Pos &oPos)
{
    oPos.x = m_width;
    oPos.y = m_height;
}