main/mveplay.c

   1 #include "mvelib.h"                                             /* next buffer */
   2 #include "mve_audio.h"
   3
   4 #include <string.h>
   5 #include <errno.h>
   6 #include <time.h>
   7 #include <sys/time.h>
   8 #include <SDL/SDL.h>
   9 #include <SDL/SDL_thread.h>
  10
  11 #ifndef MIN
  12 #define MIN(a,b) ((a)<(b)?(a):(b))
  13 #endif
  14
  15 int doPlay(const char *filename);
  16
  17 void usage(void)
  18 {
  19     fprintf(stderr, "usage: mveplay filename\n");
  20     exit(1);
  21 }
  22
  23 int g_spdFactorNum=0;
  24 int g_spdFactorDenom=10;
  25
  26 void initializeMovie(MVESTREAM *mve);
  27 void playMovie(MVESTREAM *mve);
  28 void shutdownMovie(MVESTREAM *mve);
  29
  30 short get_short(unsigned char *data)
  31 {
  32     short value;
  33     value = data[0] | (data[1] << 8);
  34     return value;
  35 }
  36
  37 int get_int(unsigned char *data)
  38 {
  39     int value;
  40     value = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
  41     return value;
  42 }
  43
  44 int default_seg_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
  45 {
  46     fprintf(stderr, "unknown chunk type %02x/%02x\n", major, minor);
  47     return 1;
  48 }
  49
  50 /*************************
  51  * general handlers
  52  *************************/
  53 int end_movie_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
  54 {
  55     return 0;
  56 }
  57
  58 /*************************
  59  * timer handlers
  60  *************************/
  61
  62 /*
  63  * timer variables
  64  */
  65 int micro_frame_delay=0;
  66 int timer_started=0;
  67 Uint32 timer_expire = 0;
  68
  69 int create_timer_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
  70 {
  71     long long temp;
  72     micro_frame_delay = get_int(data) * (int)get_short(data+4);
  73     if (g_spdFactorNum != 0)
  74     {
  75         temp = micro_frame_delay;
  76         temp *= g_spdFactorNum;
  77         temp /= g_spdFactorDenom;
  78         micro_frame_delay = (int)temp;
  79     }
  80
  81     return 1;
  82 }
  83
  84 void timer_start(void)
  85 {
  86     timer_expire = SDL_GetTicks();
  87     timer_expire += micro_frame_delay / 1000;
  88     timer_started=1;
  89 }
  90
  91 void do_timer_wait(void)
  92 {
  93     Uint32 ts, tv;
  94     if (! timer_started)
  95         return;
  96
  97     tv = SDL_GetTicks();
  98     if (tv > timer_expire)
  99         goto end;
 100
 101     ts = timer_expire - tv;
 102     SDL_Delay(ts);
 103
 104 end:
 105     timer_expire += micro_frame_delay / 1000;
 106 }
 107
 108 /*************************
 109  * audio handlers
 110  *************************/
 111 void mve_audio_callback(void *userdata, Uint8 *stream, int len);
 112 short *mve_audio_buffers[64];
 113 int    mve_audio_buflens[64];
 114 int    mve_audio_curbuf_curpos=0;
 115 int mve_audio_bufhead=0;
 116 int mve_audio_buftail=0;
 117 int mve_audio_playing=0;
 118 int mve_audio_canplay=0;
 119 SDL_AudioSpec *mve_audio_spec=NULL;
 120 SDL_mutex *mve_audio_mutex=NULL;
 121
 122 void mve_audio_callback(void *userdata, Uint8 *stream, int len)
 123 {
 124     int total=0;
 125     int length;
 126     if (mve_audio_bufhead == mve_audio_buftail)
 127         return /* 0 */;
 128
 129 fprintf(stderr, "+ <%d (%d), %d, %d>\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len);
 130
 131     if (!mve_audio_mutex) {
 132         fprintf(stderr, "mve_audio_callback: creating mutex");
 133         mve_audio_mutex = SDL_CreateMutex();
 134     }
 135     SDL_mutexP(mve_audio_mutex);
 136
 137     while (mve_audio_bufhead != mve_audio_buftail                                       /* while we have more buffers  */
 138             &&  len > (mve_audio_buflens[mve_audio_bufhead]-mve_audio_curbuf_curpos))   /* and while we need more data */
 139     {
 140         length = mve_audio_buflens[mve_audio_bufhead]-mve_audio_curbuf_curpos;
 141         __builtin_memcpy(stream,                                                        /* cur output position */
 142                 mve_audio_buffers[mve_audio_bufhead]+mve_audio_curbuf_curpos,           /* cur input position  */
 143                 length);                                                                /* cur input length    */
 144
 145         total += length;
 146         stream += length;                                                               /* advance output */
 147         len -= length;                                                                  /* decrement avail ospace */
 148         free(mve_audio_buffers[mve_audio_bufhead]);                                     /* free the buffer */
 149         mve_audio_buffers[mve_audio_bufhead]=NULL;                                      /* free the buffer */
 150         mve_audio_buflens[mve_audio_bufhead]=0;                                         /* free the buffer */
 151
 152         if (++mve_audio_bufhead == 64)                                                  /* next buffer */
 153             mve_audio_bufhead = 0;
 154         mve_audio_curbuf_curpos = 0;
 155     }
 156
 157 fprintf(stderr, "= <%d (%d), %d, %d>: %d\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len, total);
 158 /*    return total; */
 159
 160     if (len != 0                                                                        /* ospace remaining  */
 161             &&  mve_audio_bufhead != mve_audio_buftail)                                 /* buffers remaining */
 162     {
 163         __builtin_memcpy(stream,                                                        /* dest */
 164                 mve_audio_buffers[mve_audio_bufhead] + mve_audio_curbuf_curpos,         /* src */
 165                 len);                                                                   /* length */
 166
 167         mve_audio_curbuf_curpos += len;                                                 /* advance input */
 168         stream += len;                                                                  /* advance output (unnecessary) */
 169         len -= len;                                                                     /* advance output (unnecessary) */
 170
 171         if (mve_audio_curbuf_curpos >= mve_audio_buflens[mve_audio_bufhead])            /* if this ends the current chunk */
 172         {
 173             free(mve_audio_buffers[mve_audio_bufhead]);                                 /* free buffer */
 174             mve_audio_buffers[mve_audio_bufhead]=NULL;
 175             mve_audio_buflens[mve_audio_bufhead]=0;
 176
 177             if (++mve_audio_bufhead == 64)                                              /* next buffer */
 178                 mve_audio_bufhead = 0;
 179             mve_audio_curbuf_curpos = 0;
 180         }
 181     }
 182
 183 fprintf(stderr, "- <%d (%d), %d, %d>\n", mve_audio_bufhead, mve_audio_curbuf_curpos, mve_audio_buftail, len);
 184     SDL_mutexV(mve_audio_mutex);
 185 }
 186
 187 int create_audiobuf_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 188 {
 189     int sample_rate;
 190     int desired_buffer;
 191
 192 fprintf(stderr, "creating audio buffers\n");
 193
 194     sample_rate = get_short(data + 4);
 195     desired_buffer = get_int(data + 6);
 196     mve_audio_spec = (SDL_AudioSpec *)malloc(sizeof(SDL_AudioSpec));
 197     mve_audio_spec->freq = sample_rate;
 198     mve_audio_spec->format = AUDIO_S16LSB;
 199     mve_audio_spec->channels = 2;
 200     mve_audio_spec->samples = 32768;
 201     mve_audio_spec->callback = mve_audio_callback;
 202     mve_audio_spec->userdata = NULL;
 203     if (SDL_OpenAudio(mve_audio_spec, NULL) >= 0)
 204     {
 205 fprintf(stderr, "   success\n");
 206         mve_audio_canplay = 1;
 207     }
 208     else
 209     {
 210 fprintf(stderr, "   failure : %s\n", SDL_GetError());
 211         mve_audio_canplay = 0;
 212     }
 213
 214     memset(mve_audio_buffers, 0, sizeof(mve_audio_buffers));
 215     memset(mve_audio_buflens, 0, sizeof(mve_audio_buflens));
 216
 217     return 1;
 218 }
 219
 220 int play_audio_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 221 {
 222     if (mve_audio_canplay  &&  !mve_audio_playing  &&  mve_audio_bufhead != mve_audio_buftail)
 223     {
 224         SDL_PauseAudio(0);
 225         mve_audio_playing = 1;
 226     }
 227
 228     return 1;
 229 }
 230
 231 int audio_data_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 232 {
 233     const int selected_chan=1;
 234     int chan;
 235     int nsamp;
 236     if (mve_audio_canplay)
 237     {
 238         if (mve_audio_playing)
 239             SDL_LockAudio();
 240
 241         chan = get_short(data + 2);
 242         nsamp = get_short(data + 4);
 243         if (chan & selected_chan)
 244         {
 245             if (!mve_audio_mutex) {
 246                 fprintf(stderr, "audio_data_handler: creating mutex");
 247                 mve_audio_mutex = SDL_CreateMutex();
 248             }
 249             SDL_mutexP(mve_audio_mutex);
 250             mve_audio_buflens[mve_audio_buftail] = nsamp;
 251             mve_audio_buffers[mve_audio_buftail] = (short *)malloc(nsamp);
 252             if (major == 8)
 253                 mveaudio_uncompress(mve_audio_buffers[mve_audio_buftail], data, -1); /* XXX */
 254             else
 255                 memset(mve_audio_buffers[mve_audio_buftail], 0, nsamp); /* XXX */
 256
 257             if (++mve_audio_buftail == 64)
 258                 mve_audio_buftail = 0;
 259
 260             if (mve_audio_buftail == mve_audio_bufhead)
 261                 fprintf(stderr, "d'oh!  buffer ring overrun (%d)\n", mve_audio_bufhead);
 262             SDL_mutexV(mve_audio_mutex);
 263         }
 264
 265         if (mve_audio_playing)
 266             SDL_UnlockAudio();
 267     }
 268
 269     return 1;
 270 }
 271
 272 /*************************
 273  * video handlers
 274  *************************/
 275 SDL_Surface *g_screen;
 276 int g_screenWidth, g_screenHeight;
 277 int g_width, g_height;
 278 unsigned char g_palette[768];
 279 unsigned char *g_vBackBuf1, *g_vBackBuf2;
 280 unsigned char *g_pCurMap=NULL;
 281 int g_nMapLength=0;
 282
 283 int create_videobuf_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 284 {
 285     short w, h;
 286     w = get_short(data);
 287     h = get_short(data+2);
 288     g_width = w << 3;
 289     g_height = h << 3;
 290     g_vBackBuf1 = malloc(g_width * g_height);
 291     g_vBackBuf2 = malloc(g_width * g_height);
 292     memset(g_vBackBuf1, 0, g_width * g_height);
 293     memset(g_vBackBuf2, 0, g_width * g_height);
 294     return 1;
 295 }
 296
 297 int stupefaction=0;
 298 int display_video_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 299 {
 300     int i;
 301     unsigned char *pal = g_palette;
 302     unsigned char *pDest;
 303     unsigned char *pixels = g_vBackBuf1;
 304     SDL_Surface *screenSprite;
 305     SDL_Rect renderArea;
 306     int x, y;
 307
 308     SDL_Surface *initSprite = SDL_CreateRGBSurface(SDL_SWSURFACE, g_width, g_height, 8, 0, 0, 0, 0);
 309     for(i = 0; i < 256; i++)
 310     {
 311         initSprite->format->palette->colors[i].r = (*pal++) << 2;
 312         initSprite->format->palette->colors[i].g = (*pal++) << 2;
 313         initSprite->format->palette->colors[i].b = (*pal++) << 2;
 314         initSprite->format->palette->colors[i].unused = 0;
 315     }
 316
 317     pDest = initSprite->pixels;
 318     for (i=0; i<g_height; i++)
 319     {
 320         memcpy(pDest, pixels, g_width);
 321         pixels += g_width;
 322         pDest += initSprite->pitch;
 323     }
 324
 325     screenSprite = SDL_DisplayFormat(initSprite);
 326     SDL_FreeSurface(initSprite);
 327
 328     if (g_screenWidth > screenSprite->w) x = (g_screenWidth - screenSprite->w) >> 1;
 329     else x=0;
 330     if (g_screenHeight > screenSprite->h) y = (g_screenHeight - screenSprite->h) >> 1;
 331     else y=0;
 332     renderArea.x = x;
 333     renderArea.y = y;
 334     renderArea.w = MIN(g_screenWidth  - x, screenSprite->w);
 335     renderArea.h = MIN(g_screenHeight - y, screenSprite->h);
 336     SDL_BlitSurface(screenSprite, NULL, g_screen, &renderArea);
 337     if ( (g_screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF )
 338         SDL_Flip(g_screen);
 339     else
 340         SDL_UpdateRects(g_screen, 1, &renderArea);
 341     SDL_FreeSurface(screenSprite);
 342     return 1;
 343 }
 344
 345 int init_video_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 346 {
 347     short width, height;
 348     width = get_short(data);
 349     height = get_short(data+2);
 350     g_screen = SDL_SetVideoMode(width, height, 16, SDL_ANYFORMAT);
 351     g_screenWidth = width;
 352     g_screenHeight = height;
 353     memset(g_palette, 0, 768);
 354     return 1;
 355 }
 356
 357 int video_palette_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 358 {
 359     short start, count;
 360     start = get_short(data);
 361     count = get_short(data+2);
 362     memcpy(g_palette + 3*start, data+4, 3*count);
 363     return 1;
 364 }
 365
 366 int video_codemap_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 367 {
 368     g_pCurMap = data;
 369     g_nMapLength = len;
 370     return 1;
 371 }
 372
 373 void decodeFrame(unsigned char *pFrame, unsigned char *pMap, int mapRemain, unsigned char *pData, int dataRemain);
 374
 375 int video_data_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 376 {
 377     short nFrameHot, nFrameCold;
 378     short nXoffset, nYoffset;
 379     short nXsize, nYsize;
 380     short nFlags;
 381     unsigned char *temp;
 382
 383     nFrameHot  = get_short(data);
 384     nFrameCold = get_short(data+2);
 385     nXoffset   = get_short(data+4);
 386     nYoffset   = get_short(data+6);
 387     nXsize     = get_short(data+8);
 388     nYsize     = get_short(data+10);
 389     nFlags     = get_short(data+12);
 390
 391     if (nFlags & 1)
 392     {
 393         temp = g_vBackBuf1;
 394         g_vBackBuf1 = g_vBackBuf2;
 395         g_vBackBuf2 = temp;
 396     }
 397
 398     /* convert the frame */
 399     decodeFrame(g_vBackBuf1, g_pCurMap, g_nMapLength, data+14, len-14);
 400
 401     return 1;
 402 }
 403
 404 int end_chunk_handler(unsigned char major, unsigned char minor, unsigned char *data, int len, void *context)
 405 {
 406     g_pCurMap=NULL;
 407     return 1;
 408 }
 409
 410 void initializeMovie(MVESTREAM *mve)
 411 {
 412     mve_set_handler(mve, 0x00, end_movie_handler);
 413     mve_set_handler(mve, 0x01, end_chunk_handler);
 414     mve_set_handler(mve, 0x02, create_timer_handler);
 415     mve_set_handler(mve, 0x03, create_audiobuf_handler);
 416     mve_set_handler(mve, 0x04, play_audio_handler);
 417     mve_set_handler(mve, 0x05, create_videobuf_handler);
 418     mve_set_handler(mve, 0x07, display_video_handler);
 419     mve_set_handler(mve, 0x08, audio_data_handler);
 420     mve_set_handler(mve, 0x09, audio_data_handler);
 421     mve_set_handler(mve, 0x0a, init_video_handler);
 422     mve_set_handler(mve, 0x0c, video_palette_handler);
 423     mve_set_handler(mve, 0x0f, video_codemap_handler);
 424     mve_set_handler(mve, 0x11, video_data_handler);
 425 }
 426
 427 void playMovie(MVESTREAM *mve)
 428 {
 429     int init_timer=0;
 430     int cont=1;
 431     while (cont)
 432     {
 433         cont = mve_play_next_chunk(mve);
 434         if (micro_frame_delay  &&  !init_timer)
 435         {
 436             timer_start();
 437             init_timer = 1;
 438         }
 439
 440         do_timer_wait();
 441     }
 442 }
 443
 444 void shutdownMovie(MVESTREAM *mve)
 445 {
 446 }
 447
 448 void dispatchDecoder(unsigned char **pFrame, unsigned char codeType, unsigned char **pData, int *pDataRemain, int *curXb, int *curYb);
 449
 450 void decodeFrame(unsigned char *pFrame, unsigned char *pMap, int mapRemain, unsigned char *pData, int dataRemain)
 451 {
 452     int i, j;
 453     int xb, yb;
 454
 455     xb = g_width >> 3;
 456     yb = g_height >> 3;
 457     for (j=0; j<yb; j++)
 458     {
 459         for (i=0; i<xb/2; i++)
 460         {
 461             dispatchDecoder(&pFrame, (*pMap) & 0xf, &pData, &dataRemain, &i, &j);
 462             if (pFrame < g_vBackBuf1)
 463                 fprintf(stderr, "danger!  pointing out of bounds below after dispatch decoder: %d, %d (1) [%x]\n", i, j, (*pMap) & 0xf);
 464             else if (pFrame >= g_vBackBuf1 + g_width*g_height)
 465                 fprintf(stderr, "danger!  pointing out of bounds above after dispatch decoder: %d, %d (1) [%x]\n", i, j, (*pMap) & 0xf);
 466             dispatchDecoder(&pFrame, (*pMap) >> 4, &pData, &dataRemain, &i, &j);
 467             if (pFrame < g_vBackBuf1)
 468                 fprintf(stderr, "danger!  pointing out of bounds below after dispatch decoder: %d, %d (2) [%x]\n", i, j, (*pMap) >> 4);
 469             else if (pFrame >= g_vBackBuf1 + g_width*g_height)
 470                 fprintf(stderr, "danger!  pointing out of bounds above after dispatch decoder: %d, %d (2) [%x]\n", i, j, (*pMap) >> 4);
 471
 472             ++pMap;
 473             --mapRemain;
 474         }
 475
 476         pFrame += 7*g_width;
 477     }
 478 }
 479
 480 void relClose(int i, int *x, int *y)
 481 {
 482     int ma, mi;
 483
 484     ma = i >> 4;
 485     mi = i & 0xf;
 486
 487     *x = mi - 8;
 488     *y = ma - 8;
 489 }
 490
 491 void relFar(int i, int sign, int *x, int *y)
 492 {
 493     if (i < 56)
 494     {
 495         *x = sign * (8 + (i % 7));
 496         *y = sign *      (i / 7);
 497     }
 498     else
 499     {
 500         *x = sign * (-14 + (i - 56) % 29);
 501         *y = sign *   (8 + (i - 56) / 29);
 502     }
 503 }
 504
 505 void copyFrame(unsigned char *pDest, unsigned char *pSrc)
 506 {
 507     int i;
 508
 509     for (i=0; i<8; i++)
 510     {
 511         memcpy(pDest, pSrc, 8);
 512         pDest += g_width;
 513         pSrc += g_width;
 514     }
 515 }
 516
 517 void patternRow4Pixels(unsigned char *pFrame,
 518                               unsigned char pat0, unsigned char pat1,
 519                               unsigned char *p)
 520 {
 521     unsigned short mask=0x0003;
 522     unsigned short shift=0;
 523     unsigned short pattern = (pat1 << 8) | pat0;
 524
 525     while (mask != 0)
 526     {
 527         *pFrame++ = p[(mask & pattern) >> shift];
 528         mask <<= 2;
 529         shift += 2;
 530     }
 531 }
 532
 533 void patternRow4Pixels2(unsigned char *pFrame,
 534                                unsigned char pat0,
 535                                unsigned char *p)
 536 {
 537     unsigned char mask=0x03;
 538     unsigned char shift=0;
 539     unsigned char pel;
 540     int skip=1;
 541
 542     while (mask != 0)
 543     {
 544         pel = p[(mask & pat0) >> shift];
 545         pFrame[0] = pel;
 546         pFrame[2] = pel;
 547         pFrame[g_width + 0] = pel;
 548         pFrame[g_width + 2] = pel;
 549         pFrame += skip;
 550         skip = 4 - skip;
 551         mask <<= 2;
 552         shift += 2;
 553     }
 554 }
 555
 556 void patternRow4Pixels2x1(unsigned char *pFrame, unsigned char pat, unsigned char *p)
 557 {
 558     unsigned char mask=0x03;
 559     unsigned char shift=0;
 560     unsigned char pel;
 561
 562     while (mask != 0)
 563     {
 564         pel = p[(mask & pat) >> shift];
 565         pFrame[0] = pel;
 566         pFrame[1] = pel;
 567         pFrame += 2;
 568         mask <<= 2;
 569         shift += 2;
 570     }
 571 }
 572
 573 void patternQuadrant4Pixels(unsigned char *pFrame, unsigned char pat0, unsigned char pat1, unsigned char pat2, unsigned char pat3, unsigned char *p)
 574 {
 575     unsigned long mask = 0x00000003UL;
 576     int shift=0;
 577     int i;
 578     unsigned long pat = (pat3 << 24) | (pat2 << 16) | (pat1 << 8) | pat0;
 579
 580     for (i=0; i<16; i++)
 581     {
 582         pFrame[i&3] = p[(pat & mask) >> shift];
 583
 584         if ((i&3) == 3)
 585             pFrame += g_width;
 586
 587         mask <<= 2;
 588         shift += 2;
 589     }
 590 }
 591
 592
 593 void patternRow2Pixels(unsigned char *pFrame, unsigned char pat, unsigned char *p)
 594 {
 595     unsigned char mask=0x01;
 596
 597     while (mask != 0)
 598     {
 599         *pFrame++ = p[(mask & pat) ? 1 : 0];
 600         mask <<= 1;
 601     }
 602 }
 603
 604 void patternRow2Pixels2(unsigned char *pFrame, unsigned char pat, unsigned char *p)
 605 {
 606     unsigned char pel;
 607     unsigned char mask=0x1;
 608     int skip=1;
 609
 610     while (mask != 0x10)
 611     {
 612         pel = p[(mask & pat) ? 1 : 0];
 613         pFrame[0] = pel;
 614         pFrame[2] = pel;
 615         pFrame[g_width + 0] = pel;
 616         pFrame[g_width + 2] = pel;
 617         pFrame += skip;
 618         skip = 4 - skip;
 619         mask <<= 1;
 620     }
 621 }
 622
 623 void patternQuadrant2Pixels(unsigned char *pFrame, unsigned char pat0, unsigned char pat1, unsigned char *p)
 624 {
 625     unsigned short mask = 0x0001;
 626     int i;
 627     unsigned short pat = (pat1 << 8) | pat0;
 628
 629     for (i=0; i<16; i++)
 630     {
 631         pFrame[i&3] = p[(pat & mask) ? 1 : 0];
 632
 633         if ((i&3) == 3)
 634             pFrame += g_width;
 635
 636         mask <<= 1;
 637     }
 638 }
 639
 640 void dispatchDecoder(unsigned char **pFrame, unsigned char codeType, unsigned char **pData, int *pDataRemain, int *curXb, int *curYb)
 641 {
 642     unsigned char p[4];
 643     unsigned char pat[16];
 644     int i, j, k;
 645     int x, y;
 646
 647     switch(codeType)
 648     {
 649         case 0x0:
 650                   copyFrame(*pFrame, *pFrame + (g_vBackBuf2 - g_vBackBuf1));
 651         case 0x1:
 652                   *pFrame += 8;
 653                   break;
 654
 655         case 0x2:
 656                   relFar(*(*pData)++, 1, &x, &y);
 657                   copyFrame(*pFrame, *pFrame + x + y*g_width);
 658                   *pFrame += 8;
 659                   --*pDataRemain;
 660                   break;
 661
 662         case 0x3:
 663                   relFar(*(*pData)++, -1, &x, &y);
 664                   copyFrame(*pFrame, *pFrame + x + y*g_width);
 665                   *pFrame += 8;
 666                   --*pDataRemain;
 667                   break;
 668
 669         case 0x4:
 670                   relClose(*(*pData)++, &x, &y);
 671                   copyFrame(*pFrame, *pFrame + (g_vBackBuf2 - g_vBackBuf1) + x + y*g_width);
 672                   *pFrame += 8;
 673                   --*pDataRemain;
 674                   break;
 675
 676         case 0x5:
 677                   x = (char)*(*pData)++;
 678                   y = (char)*(*pData)++;
 679                   copyFrame(*pFrame, *pFrame + (g_vBackBuf2 - g_vBackBuf1) + x + y*g_width);
 680                   *pFrame += 8;
 681                   *pDataRemain -= 2;
 682                   break;
 683
 684         case 0x6:
 685                   for (i=0; i<2; i++)
 686                   {
 687                       *pFrame += 16;
 688                       if (++*curXb == (g_width >> 3))
 689                       {
 690                           *pFrame += 7*g_width;
 691                           *curXb = 0;
 692                           if (++*curYb == (g_height >> 3))
 693                               return;
 694                       }
 695                   }
 696                   break;
 697
 698         case 0x7:
 699                   p[0] = *(*pData)++;
 700                   p[1] = *(*pData)++;
 701                   if (p[0] <= p[1])
 702                   {
 703                       for (i=0; i<8; i++)
 704                       {
 705                           patternRow2Pixels(*pFrame, *(*pData)++, p);
 706                           *pFrame += g_width;
 707                       }
 708                   }
 709                   else
 710                   {
 711                       for (i=0; i<2; i++)
 712                       {
 713                           patternRow2Pixels2(*pFrame, *(*pData) & 0xf, p);
 714                           *pFrame += 2*g_width;
 715                           patternRow2Pixels2(*pFrame, *(*pData)++ >> 4, p);
 716                           *pFrame += 2*g_width;
 717                       }
 718                   }
 719                   *pFrame -= (8*g_width - 8);
 720                   break;
 721
 722         case 0x8:
 723                   if ( (*pData)[0] <= (*pData)[1])
 724                   {
 725                       for (i=0; i<4; i++)
 726                       {
 727                           p[0] = *(*pData)++;
 728                           p[1] = *(*pData)++;
 729                           pat[0] = *(*pData)++;
 730                           pat[1] = *(*pData)++;
 731                           patternQuadrant2Pixels(*pFrame, pat[0], pat[1], p);
 732
 733                           if (i & 1)
 734                               *pFrame -= (4*g_width - 4);
 735                           else
 736                               *pFrame += 4*g_width;
 737                       }
 738                   }
 739                   else if ( (*pData)[6] <= (*pData)[7])
 740                   {
 741                       for (i=0; i<4; i++)
 742                       {
 743                           if ((i & 1) == 0)
 744                           {
 745                               p[0] = *(*pData)++;
 746                               p[1] = *(*pData)++;
 747                           }
 748                           pat[0] = *(*pData)++;
 749                           pat[1] = *(*pData)++;
 750                           patternQuadrant2Pixels(*pFrame, pat[0], pat[1], p);
 751
 752                           if (i & 1)
 753                               *pFrame -= (4*g_width - 4);
 754                           else
 755                               *pFrame += 4*g_width;
 756                       }
 757                   }
 758                   else
 759                   {
 760                       for (i=0; i<8; i++)
 761                       {
 762                           if ((i & 3) == 0)
 763                           {
 764                               p[0] = *(*pData)++;
 765                               p[1] = *(*pData)++;
 766                           }
 767                           patternRow2Pixels(*pFrame, *(*pData)++, p);
 768                           *pFrame += g_width;
 769                       }
 770                       *pFrame -= (8*g_width - 8);
 771                   }
 772                   break;
 773
 774         case 0x9:
 775                   if ( (*pData)[0] <= (*pData)[1])
 776                   {
 777                       if ( (*pData)[2] <= (*pData)[3])
 778                       {
 779                           p[0] = *(*pData)++;
 780                           p[1] = *(*pData)++;
 781                           p[2] = *(*pData)++;
 782                           p[3] = *(*pData)++;
 783
 784                           for (i=0; i<8; i++)
 785                           {
 786                               pat[0] = *(*pData)++;
 787                               pat[1] = *(*pData)++;
 788                               patternRow4Pixels(*pFrame, pat[0], pat[1], p);
 789                               *pFrame += g_width;
 790                           }
 791
 792                           *pFrame -= (8*g_width - 8);
 793                       }
 794                       else
 795                       {
 796                           p[0] = *(*pData)++;
 797                           p[1] = *(*pData)++;
 798                           p[2] = *(*pData)++;
 799                           p[3] = *(*pData)++;
 800
 801                           patternRow4Pixels2(*pFrame, *(*pData)++, p);
 802                           *pFrame += 2*g_width;
 803                           patternRow4Pixels2(*pFrame, *(*pData)++, p);
 804                           *pFrame += 2*g_width;
 805                           patternRow4Pixels2(*pFrame, *(*pData)++, p);
 806                           *pFrame += 2*g_width;
 807                           patternRow4Pixels2(*pFrame, *(*pData)++, p);
 808                           *pFrame -= (6*g_width - 8);
 809                       }
 810                   }
 811                   else
 812                   {
 813                       if ( (*pData)[2] <= (*pData)[3])
 814                       {
 815                           p[0] = *(*pData)++;
 816                           p[1] = *(*pData)++;
 817                           p[2] = *(*pData)++;
 818                           p[3] = *(*pData)++;
 819
 820                           for (i=0; i<8; i++)
 821                           {
 822                               pat[0] = *(*pData)++;
 823                               patternRow4Pixels2x1(*pFrame, pat[0], p);
 824                               *pFrame += g_width;
 825                           }
 826
 827                           *pFrame -= (8*g_width - 8);
 828                       }
 829                       else
 830                       {
 831                           p[0] = *(*pData)++;
 832                           p[1] = *(*pData)++;
 833                           p[2] = *(*pData)++;
 834                           p[3] = *(*pData)++;
 835
 836                           for (i=0; i<4; i++)
 837                           {
 838                               pat[0] = *(*pData)++;
 839                               pat[1] = *(*pData)++;
 840                               patternRow4Pixels(*pFrame, pat[0], pat[1], p);
 841                               *pFrame += g_width;
 842                               patternRow4Pixels(*pFrame, pat[0], pat[1], p);
 843                               *pFrame += g_width;
 844                           }
 845
 846                           *pFrame -= (8*g_width - 8);
 847                       }
 848                   }
 849                   break;
 850
 851         case 0xa:
 852                   if ( (*pData)[0] <= (*pData)[1])
 853                   {
 854                       for (i=0; i<4; i++)
 855                       {
 856                           p[0] = *(*pData)++;
 857                           p[1] = *(*pData)++;
 858                           p[2] = *(*pData)++;
 859                           p[3] = *(*pData)++;
 860                           pat[0] = *(*pData)++;
 861                           pat[1] = *(*pData)++;
 862                           pat[2] = *(*pData)++;
 863                           pat[3] = *(*pData)++;
 864
 865                           patternQuadrant4Pixels(*pFrame, pat[0], pat[1], pat[2], pat[3], p);
 866
 867                           if (i & 1)
 868                               *pFrame -= (4*g_width - 4);
 869                           else
 870                               *pFrame += 4*g_width;
 871                       }
 872                   }
 873                   else
 874                   {
 875                       if ( (*pData)[12] <= (*pData)[13])
 876                       {
 877                           for (i=0; i<4; i++)
 878                           {
 879                               if ((i&1) == 0)
 880                               {
 881                                   p[0] = *(*pData)++;
 882                                   p[1] = *(*pData)++;
 883                                   p[2] = *(*pData)++;
 884                                   p[3] = *(*pData)++;
 885                               }
 886
 887                               pat[0] = *(*pData)++;
 888                               pat[1] = *(*pData)++;
 889                               pat[2] = *(*pData)++;
 890                               pat[3] = *(*pData)++;
 891
 892                               patternQuadrant4Pixels(*pFrame, pat[0], pat[1], pat[2], pat[3], p);
 893
 894                               if (i & 1)
 895                                   *pFrame -= (4*g_width - 4);
 896                               else
 897                                   *pFrame += 4*g_width;
 898                           }
 899                       }
 900                       else
 901                       {
 902                           for (i=0; i<8; i++)
 903                           {
 904                               if ((i&3) == 0)
 905                               {
 906                                   p[0] = *(*pData)++;
 907                                   p[1] = *(*pData)++;
 908                                   p[2] = *(*pData)++;
 909                                   p[3] = *(*pData)++;
 910                               }
 911
 912                               pat[0] = *(*pData)++;
 913                               pat[1] = *(*pData)++;
 914                               patternRow4Pixels(*pFrame, pat[0], pat[1], p);
 915                               *pFrame += g_width;
 916                           }
 917
 918                           *pFrame -= (8*g_width - 8);
 919                       }
 920                   }
 921                   break;
 922
 923         case 0xb:
 924                   for (i=0; i<8; i++)
 925                   {
 926                       memcpy(*pFrame, *pData, 8);
 927                       *pFrame += g_width;
 928                       *pData += 8;
 929                       *pDataRemain -= 8;
 930                   }
 931                   *pFrame -= (8*g_width - 8);
 932                   break;
 933
 934         case 0xc:
 935                   for (i=0; i<4; i++)
 936                   {
 937                       for (j=0; j<2; j++)
 938                       {
 939                           for (k=0; k<4; k++)
 940                           {
 941                               (*pFrame)[j+2*k] = (*pData)[k];
 942                               (*pFrame)[g_width+j+2*k] = (*pData)[k];
 943                           }
 944                           *pFrame += g_width;
 945                       }
 946                       *pData += 4;
 947                       *pDataRemain -= 4;
 948                   }
 949                   *pFrame -= (8*g_width - 8);
 950                   break;
 951
 952         case 0xd:
 953                   for (i=0; i<2; i++)
 954                   {
 955                       for (j=0; j<4; j++)
 956                       {
 957                           for (k=0; k<4; k++)
 958                           {
 959                               (*pFrame)[k*g_width+j] = (*pData)[0];
 960                               (*pFrame)[k*g_width+j+4] = (*pData)[1];
 961                           }
 962                       }
 963                       *pFrame += 4*g_width;
 964                       *pData += 2;
 965                       *pDataRemain -= 2;
 966                   }
 967                   *pFrame -= (8*g_width - 8);
 968                   break;
 969
 970         case 0xe:
 971                   for (i=0; i<8; i++)
 972                   {
 973                       memset(*pFrame, **pData, 8);
 974                       *pFrame += g_width;
 975                   }
 976                   ++*pData;
 977                   --*pDataRemain;
 978                   *pFrame -= (8*g_width - 8);
 979                   break;
 980
 981         case 0xf:
 982                   for (i=0; i<8; i++)
 983                   {
 984                       for (j=0; j<8; j++)
 985                       {
 986                           (*pFrame)[j] = (*pData)[(i+j)&1];
 987                       }
 988                       *pFrame += g_width;
 989                   }
 990                   *pData += 2;
 991                   *pDataRemain -= 2;
 992                   *pFrame -= (8*g_width - 8);
 993                   break;
 994
 995         default:
 996             break;
 997     }
 998 }