workbench/libs/muimaster/classes/bodychunk.c

   1 /*
   2     Copyright © 2002-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <graphics/gfx.h>
   7 #include <graphics/view.h>
   8 #include <clib/alib_protos.h>
   9 #include <proto/exec.h>
  10 #include <proto/graphics.h>
  11 #include <proto/utility.h>
  12 #include <proto/intuition.h>
  13 #include <proto/muimaster.h>
  14
  15 #include "mui.h"
  16 #include "muimaster_intern.h"
  17 #include "support.h"
  18
  19 extern struct Library *MUIMasterBase;
  20
  21 struct MUI_BodychunkData
  22 {
  23     struct BitMap   *bm;
  24     UBYTE           *body;
  25     LONG             width, height, depth;
  26     UBYTE            compression;
  27     UBYTE            masking;
  28 };
  29
  30 static void planar2chunky(UBYTE *src, UBYTE *dest, WORD width, WORD depth, LONG bpr)
  31 {
  32     UBYTE *s, *d, byte;
  33     UBYTE pmask, dmask = 1, notdmask = ~1;
  34     WORD  x, pl;
  35
  36     for(pl = 0; pl < depth; pl++)
  37     {
  38         pmask = 0x80;
  39         s = src;
  40         d = dest;
  41
  42         byte = *s++;
  43
  44         for(x = 0; x < width; x++)
  45         {
  46             if (byte & pmask)
  47             {
  48                 *d++ |= dmask;
  49             }
  50             else
  51             {
  52                 *d++ &= notdmask;
  53             }
  54
  55             if (pmask == 0x1)
  56             {
  57                 pmask = 0x80;
  58                 byte = *s++;
  59             }
  60             else
  61             {
  62                 pmask >>= 1;
  63             }
  64         }
  65
  66         dmask <<= 1; notdmask = ~dmask;
  67
  68         src += bpr;
  69     }
  70 }
  71
  72 static UBYTE *unpack_byterun1(UBYTE *src, UBYTE *dest, LONG unpackedsize)
  73 {
  74     UBYTE r;
  75     BYTE  c;
  76
  77     for(;;)
  78     {
  79         c = (BYTE)(*src++);
  80         if (c >= 0)
  81         {
  82             while(c-- >= 0)
  83             {
  84                 *dest++ = *src++;
  85                 if (--unpackedsize <= 0) return src;
  86             }
  87         }
  88         else if (c != -128)
  89         {
  90             c = -c;
  91             r = *src++;
  92
  93             while(c-- >= 0)
  94             {
  95                 *dest++ = r;
  96                 if (--unpackedsize <= 0) return src;
  97             }
  98         }
  99     }
 100
 101 }
 102
 103 static BOOL make_bitmap(struct IClass *cl, Object *obj)
 104 {
 105     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 106     struct RastPort          bmrp, temprp;
 107     UBYTE                    *chunkyline;
 108     UBYTE                    *bodyptr, *unpackptr;
 109     LONG                     w16, bpr, bpl;
 110     WORD                     x, y, totdepth;
 111
 112     if (!data->body             ||
 113         (data->width  < 1)      ||
 114         (data->height < 1)      ||
 115         (data->depth  < 1)      ||
 116         (data->depth  > 8)      ||
 117         (data->compression > 1) )
 118     {
 119         return FALSE;
 120     }
 121
 122     chunkyline = AllocVec(2 * (data->width + 16), MEMF_PUBLIC | MEMF_CLEAR);
 123     if (!chunkyline) return FALSE;
 124
 125     unpackptr = chunkyline + data->width + 16;
 126
 127     data->bm = AllocBitMap(data->width, data->height, data->depth, BMF_CLEAR, NULL);
 128     if (!data->bm)
 129     {
 130         FreeVec(chunkyline);
 131         return FALSE;
 132     }
 133
 134     InitRastPort(&temprp);
 135     temprp.BitMap = AllocBitMap(data->width, 1, 1, 0, NULL);
 136
 137     InitRastPort(&bmrp);
 138     bmrp.BitMap = data->bm;
 139
 140     bodyptr = data->body;
 141     w16 = (data->width + 15) & ~15;
 142     bpr = w16 / 8;
 143
 144     totdepth = data->depth + ((data->masking == 1) ? 1 : 0);
 145     bpl = bpr * totdepth;
 146
 147     for(y = 0; y < data->height; y++)
 148     {
 149         if (data->compression)
 150         {
 151             bodyptr = unpack_byterun1(bodyptr, unpackptr, bpl);
 152             planar2chunky(unpackptr, chunkyline, data->width, data->depth, bpr);
 153         }
 154         else
 155         {
 156             planar2chunky(bodyptr, chunkyline, data->width, data->depth, bpr);
 157             bodyptr += bpl;
 158         }
 159
 160         if (temprp.BitMap)
 161         {
 162             WritePixelLine8(&bmrp, 0, y, data->width, chunkyline, &temprp);
 163         }
 164         else
 165         {
 166             for(x = 0; x < data->width; x++)
 167             {
 168                 SetAPen(&bmrp, chunkyline[x]);
 169                 WritePixel(&bmrp, x, y);
 170             }
 171         }
 172     }
 173
 174     DeinitRastPort(&temprp);
 175     DeinitRastPort(&bmrp);
 176
 177     if (temprp.BitMap)
 178     {
 179         WaitBlit();
 180         FreeBitMap(temprp.BitMap);
 181     }
 182
 183     FreeVec(chunkyline);
 184
 185     return TRUE;
 186 }
 187
 188 /**************************************************************************
 189  OM_NEW
 190 **************************************************************************/
 191 IPTR Bodychunk__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 192 {
 193     struct MUI_BodychunkData    *data;
 194     struct TagItem              *tag, *tags;
 195
 196     obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
 197     if (!obj) return FALSE;
 198
 199     data = INST_DATA(cl, obj);
 200
 201     /* parse initial taglist */
 202
 203     for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem**)&tags)); )
 204     {
 205         switch (tag->ti_Tag)
 206         {
 207             case MUIA_Bodychunk_Body:
 208                 data->body = (UBYTE *)tag->ti_Data;
 209                 break;
 210
 211             case MUIA_Bodychunk_Compression:
 212                 data->compression = (UBYTE)tag->ti_Data;
 213                 break;
 214
 215             case MUIA_Bodychunk_Depth:
 216                 data->depth = (LONG)tag->ti_Data;
 217                 break;
 218
 219             case MUIA_Bodychunk_Masking:
 220                 data->masking = (UBYTE)tag->ti_Data;
 221                 break;
 222
 223             case MUIA_Bitmap_Width:
 224                 data->width = (LONG)tag->ti_Data;
 225                 break;
 226
 227             case MUIA_Bitmap_Height:
 228                 data->height = (LONG)tag->ti_Data;
 229                 break;
 230
 231         }
 232     }
 233
 234     return (IPTR)obj;
 235 }
 236
 237 /**************************************************************************
 238  OM_DISPOSE
 239 **************************************************************************/
 240 IPTR Bodychunk__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 241 {
 242     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 243
 244     if (data->bm)
 245     {
 246         WaitBlit();
 247         FreeBitMap(data->bm);
 248     }
 249
 250     return DoSuperMethodA(cl, obj, msg);
 251 }
 252
 253 /**************************************************************************
 254  OM_SET
 255 **************************************************************************/
 256 IPTR Bodychunk__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 257 {
 258     struct MUI_BodychunkData    *data  = INST_DATA(cl, obj);
 259     struct TagItem              *tags  = msg->ops_AttrList;
 260     struct TagItem              *tag;
 261
 262     while ((tag = NextTagItem((const struct TagItem**)&tags)) != NULL)
 263     {
 264         switch (tag->ti_Tag)
 265         {
 266             case MUIA_Bodychunk_Body:
 267                 data->body = (UBYTE *)tag->ti_Data;
 268                 break;
 269
 270             case MUIA_Bodychunk_Compression:
 271                 data->compression = (UBYTE)tag->ti_Data;
 272                 break;
 273
 274             case MUIA_Bodychunk_Depth:
 275                 data->depth = (LONG)tag->ti_Data;
 276                 break;
 277
 278             case MUIA_Bodychunk_Masking:
 279                 data->masking = (UBYTE)tag->ti_Data;
 280                 break;
 281
 282             case MUIA_Bitmap_Width:
 283                 data->width = (LONG)tag->ti_Data;
 284                 break;
 285
 286             case MUIA_Bitmap_Height:
 287                 data->height = (LONG)tag->ti_Data;
 288                 break;
 289
 290         }
 291     }
 292
 293     return DoSuperMethodA(cl, obj, (Msg)msg);
 294 }
 295
 296 /**************************************************************************
 297  OM_GET
 298 **************************************************************************/
 299 IPTR Bodychunk__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 300 {
 301 #define STORE *(msg->opg_Storage)
 302
 303     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 304
 305     switch(msg->opg_AttrID)
 306     {
 307         case MUIA_Bodychunk_Body:
 308             STORE = (IPTR)data->body;
 309             return TRUE;
 310
 311         case MUIA_Bodychunk_Compression:
 312             STORE = (IPTR)data->compression;
 313             return TRUE;
 314
 315         case MUIA_Bodychunk_Depth:
 316             STORE = (IPTR)data->depth;
 317             return TRUE;
 318
 319         case MUIA_Bodychunk_Masking:
 320             STORE = (IPTR)data->masking;
 321             return TRUE;
 322
 323     }
 324
 325     return DoSuperMethodA(cl, obj, (Msg)msg);
 326 #undef STORE
 327 }
 328
 329 /**************************************************************************
 330  MUIM_Setup
 331 **************************************************************************/
 332 IPTR Bodychunk__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
 333 {
 334     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 335
 336     if (!make_bitmap(cl, obj)) return FALSE;
 337
 338     set(obj, MUIA_Bitmap_Bitmap, (IPTR)data->bm);
 339
 340     if (!DoSuperMethodA(cl, obj, (Msg)msg))
 341     {
 342         set(obj, MUIA_Bitmap_Bitmap, NULL);
 343         WaitBlit();
 344         FreeBitMap(data->bm);
 345         data->bm = NULL;
 346
 347         return FALSE;
 348     }
 349
 350     return TRUE;
 351 }
 352
 353 /**************************************************************************
 354  MUIM_Cleanup
 355 **************************************************************************/
 356 IPTR Bodychunk__MUIM_Cleanup(struct IClass *cl, Object *obj, struct MUIP_Cleanup *msg)
 357 {
 358     struct MUI_BodychunkData *data = INST_DATA(cl, obj);
 359     IPTR                      retval;
 360
 361     retval = DoSuperMethodA(cl, obj, (Msg)msg);
 362     if (data->bm)
 363     {
 364         set(obj, MUIA_Bitmap_Bitmap, NULL);
 365
 366         WaitBlit();
 367
 368         FreeBitMap(data->bm);
 369         data->bm = NULL;
 370     }
 371
 372     return retval;
 373 }
 374
 375
 376 BOOPSI_DISPATCHER(IPTR, Bodychunk_Dispatcher, cl, obj, msg)
 377 {
 378     switch (msg->MethodID)
 379     {
 380         case OM_NEW:       return Bodychunk__OM_NEW(cl, obj, (struct opSet *)msg);
 381         case OM_DISPOSE:   return Bodychunk__OM_DISPOSE(cl, obj, msg);
 382         case OM_SET:       return Bodychunk__OM_SET(cl, obj, (struct opSet *)msg);
 383         case OM_GET:       return Bodychunk__OM_GET(cl, obj, (struct opGet *)msg);
 384         case MUIM_Setup:   return Bodychunk__MUIM_Setup(cl, obj, (struct MUIP_Setup *)msg);
 385         case MUIM_Cleanup: return Bodychunk__MUIM_Cleanup(cl, obj, (struct MUIP_Cleanup *)msg);
 386     }
 387
 388     return DoSuperMethodA(cl, obj, msg);
 389 }
 390 BOOPSI_DISPATCHER_END
 391
 392 /*
 393  * Class descriptor.
 394  */
 395 const struct __MUIBuiltinClass _MUI_Bodychunk_desc = {
 396     MUIC_Bodychunk,
 397     MUIC_Bitmap,
 398     sizeof(struct MUI_BodychunkData),
 399     (void*)Bodychunk_Dispatcher
 400 };