Ticket #8434: mpeg-scale.diff

File mpeg-scale.diff, 12.4 KB (added by eriktorbjorn, 16 years ago)

Patch against a June 4 CVS snapshot

  • graphics/animation.cpp

    diff -ur ScummVM-cvs20050604/graphics/animation.cpp ScummVM-cvs20050604+gui/graphics/animation.cpp
    old new  
    3030
    3131namespace Graphics {
    3232
    33 BaseAnimationState::BaseAnimationState(Audio::Mixer *snd, OSystem *sys, int width, int height) 
     33BaseAnimationState::BaseAnimationState(Audio::Mixer *snd, OSystem *sys, int width, int height)
    3434        : _movieWidth(width), _movieHeight(height), _snd(snd), _sys(sys) {
    3535#ifndef BACKEND_8BIT
     36        const int screenW = _sys->getOverlayWidth();
     37        const int screenH = _sys->getOverlayHeight();
     38
     39        _movieScale = MIN(screenW / _movieWidth, screenH / _movieHeight);
     40
     41        assert (_movieScale >= 1);
     42        if (_movieScale > 3)
     43                _movieScale = 3;
     44
     45
    3646        _colorTab = NULL;
    3747        _rgbToPix = NULL;
    3848        _bitFormat = 0;
     
    115125        _lutCalcNum = (BITDEPTH + _palettes[_palNum].end + 2) / (_palettes[_palNum].end + 2);
    116126#else
    117127        buildLookup();
    118         _overlay = (OverlayColor*)calloc(_movieWidth * _movieHeight, sizeof(OverlayColor));
     128        _overlay = (OverlayColor*)calloc(_movieScale * _movieWidth * _movieScale * _movieHeight, sizeof(OverlayColor));
    119129        _sys->showOverlay();
    120130#endif
    121131
     
    421431}
    422432
    423433void BaseAnimationState::plotYUV(int width, int height, byte *const *dat) {
    424         OverlayColor *ptr = _overlay + (_movieHeight - height) / 2 * _movieWidth + (_movieWidth - width) / 2;
     434        switch (_movieScale) {
     435        case 1:
     436                plotYUV1x(width, height, dat);
     437                break;
     438        case 2:
     439                plotYUV2x(width, height, dat);
     440                break;
     441        case 3:
     442                plotYUV3x(width, height, dat);
     443                break;
     444        }
     445}
     446
     447void BaseAnimationState::plotYUV1x(int width, int height, byte *const *dat) {
     448        OverlayColor *ptr = _overlay + _movieWidth * (_movieHeight - height) / 2 + (_movieWidth - width) / 2;
    425449
    426450        byte *lum = dat[0];
    427451        byte *cr = dat[2];
     
    439463        int x, y;
    440464
    441465        for (y = 0; y < height; y += 2) {
     466                OverlayColor *r1 = row1;
     467                OverlayColor *r2 = row2;
     468
     469                for (x = 0; x < width; x += 2) {
     470                        register byte L;
     471
     472                        cr_r  = 0 * 768 + 256 + _colorTab[*cr + 0 * 256];
     473                        crb_g = 1 * 768 + 256 + _colorTab[*cr + 1 * 256] + _colorTab[*cb + 2 * 256];
     474                        cb_b  = 2 * 768 + 256 + _colorTab[*cb + 3 * 256];
     475                        ++cr;
     476                        ++cb;
     477
     478                        L = *lum++;
     479                        *r1++ = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     480
     481                        L = *lum++;
     482                        *r1++ = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     483                       
     484                        // Now, do second row.
     485
     486                        L = *lum2++;
     487                        *r2++ = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     488
     489                        L = *lum2++;
     490                        *r2++ = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     491                }
     492
     493                lum  += width;
     494                lum2 += width;
     495                row1 += 2 * _movieWidth;
     496                row2 += 2 * _movieWidth;
     497        }
     498}
     499
     500void BaseAnimationState::plotYUV2x(int width, int height, byte *const *dat) {
     501        OverlayColor *ptr = _overlay + 2 * _movieWidth * (_movieHeight - height) + _movieWidth - width;
     502
     503        byte *lum = dat[0];
     504        byte *cr = dat[2];
     505        byte *cb = dat[1];
     506
     507        byte *lum2 = lum + width;
     508
     509        int16 cr_r;
     510        int16 crb_g;
     511        int16 cb_b;
     512
     513        OverlayColor *row1 = ptr;
     514        OverlayColor *row2 = ptr + 2 * 2 * _movieWidth;
     515
     516        int x, y;
     517
     518        for (y = 0; y < height; y += 2) {
     519                OverlayColor *r1 = row1;
     520                OverlayColor *r2 = row2;
     521
    442522                for (x = 0; x < width; x += 2) {
    443523                        register byte L;
     524                        register OverlayColor C;
    444525
    445526                        cr_r  = 0 * 768 + 256 + _colorTab[*cr + 0 * 256];
    446527                        crb_g = 1 * 768 + 256 + _colorTab[*cr + 1 * 256] + _colorTab[*cb + 2 * 256];
     
    449530                        ++cb;
    450531
    451532                        L = *lum++;
    452                         *row1++ = (_rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b]);
     533                        C = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     534                        *r1++ = C;
     535                        *r1++ = C;
     536
     537                        L = *lum++;
     538                        C = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     539                        *r1++ = C;
     540                        *r1++ = C;
     541                       
     542                        // Now, do second row.
     543
     544                        L = *lum2++;
     545                        C = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     546                        *r2++ = C;
     547                        *r2++ = C;
     548
     549                        L = *lum2++;
     550                        C = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     551                        *r2++ = C;
     552                        *r2++ = C;
     553                }
     554
     555                memcpy(row1 + 2 * _movieWidth, row1, 2 * _movieWidth * sizeof(OverlayColor));
     556                memcpy(row2 + 2 * _movieWidth, row2, 2 * _movieWidth * sizeof(OverlayColor));
     557
     558                lum  += width;
     559                lum2 += width;
     560                row1 += 4 * 2 * _movieWidth;
     561                row2 += 4 * 2 * _movieWidth;
     562        }
     563}
     564
     565void BaseAnimationState::plotYUV3x(int width, int height, byte *const *dat) {
     566        OverlayColor *ptr = _overlay + (3 * (_movieHeight - height) / 2) * 3 * _movieWidth + 3 * (_movieWidth - width ) / 2;
     567
     568        byte *lum = dat[0];
     569        byte *cr = dat[2];
     570        byte *cb = dat[1];
     571
     572        byte *lum2 = lum + width;
     573
     574        int16 cr_r;
     575        int16 crb_g;
     576        int16 cb_b;
     577
     578        OverlayColor *row1 = ptr;
     579        OverlayColor *row2 = ptr + 3 * 3 * _movieWidth;
     580
     581        int x, y;
     582
     583        for (y = 0; y < height; y += 2) {
     584                OverlayColor *r1 = row1;
     585                OverlayColor *r2 = row2;
     586
     587                for (x = 0; x < width; x += 2) {
     588                        register byte L;
     589                        register OverlayColor C;
     590
     591                        cr_r  = 0 * 768 + 256 + _colorTab[*cr + 0 * 256];
     592                        crb_g = 1 * 768 + 256 + _colorTab[*cr + 1 * 256] + _colorTab[*cb + 2 * 256];
     593                        cb_b  = 2 * 768 + 256 + _colorTab[*cb + 3 * 256];
     594                        ++cr;
     595                        ++cb;
     596
    453597                        L = *lum++;
    454                         *row1++ = (_rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b]);
     598                        C = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     599                        *r1++ = C;
     600                        *r1++ = C;
     601                        *r1++ = C;
    455602
     603                        L = *lum++;
     604                        C = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     605                        *r1++ = C;
     606                        *r1++ = C;
     607                        *r1++ = C;
     608                       
    456609                        // Now, do second row.
    457610
    458611                        L = *lum2++;
    459                         *row2++ = (_rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b]);
     612                        C = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     613                        *r2++ = C;
     614                        *r2++ = C;
     615                        *r2++ = C;
     616
    460617                        L = *lum2++;
    461                         *row2++ = (_rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b]);
     618                        C = _rgbToPix[L + cr_r] | _rgbToPix[L + crb_g] | _rgbToPix[L + cb_b];
     619                        *r2++ = C;
     620                        *r2++ = C;
     621                        *r2++ = C;
    462622                }
    463623
    464                 // These values are at the start of the next line, (due
    465                 // to the ++'s above), but they need to be at the start
    466                 // of the line after that.
     624                memcpy(row1 + 3 * _movieWidth, row1, 3 * _movieWidth * sizeof(OverlayColor));
     625                memcpy(row1 + 2 * 3 * _movieWidth, row1, 3 * _movieWidth * sizeof(OverlayColor));
     626                memcpy(row2 + 3 * _movieWidth, row2, 3 * _movieWidth * sizeof(OverlayColor));
     627                memcpy(row2 + 2 * 3 * _movieWidth, row2, 3 * _movieWidth * sizeof(OverlayColor));
    467628
    468629                lum  += width;
    469630                lum2 += width;
    470                 row1 += (2 * _movieWidth - width);
    471                 row2 += (2 * _movieWidth - width);
     631                row1 += 6 * 3 * _movieWidth;
     632                row2 += 6 * 3 * _movieWidth;
    472633        }
    473634}
    474635
  • graphics/animation.h

    diff -ur ScummVM-cvs20050604/graphics/animation.h ScummVM-cvs20050604+gui/graphics/animation.h
    old new  
    7373protected:
    7474        const int _movieWidth;
    7575        const int _movieHeight;
     76
     77#ifndef BACKEND_8BIT
     78        int _movieScale;
     79#endif
    7680       
    7781        Audio::Mixer *_snd;
    7882        OSystem *_sys;
     
    137141        virtual void setPalette(byte *pal) = 0;
    138142#else
    139143        void plotYUV(int width, int height, byte *const *dat);
     144        void plotYUV1x(int width, int height, byte *const *dat);
     145        void plotYUV2x(int width, int height, byte *const *dat);
     146        void plotYUV3x(int width, int height, byte *const *dat);
    140147#endif
    141148};
    142149
  • sword1/animation.cpp

    diff -ur ScummVM-cvs20050604/sword1/animation.cpp ScummVM-cvs20050604+gui/sword1/animation.cpp
    old new  
    4747#endif
    4848
    4949void AnimationState::drawYUV(int width, int height, byte *const *dat) {
     50        _frameWidth = width;
     51        _frameHeight = height;
     52
    5053#ifdef BACKEND_8BIT
    5154        _scr->plotYUV(_lut, width, height, dat);
    5255#else
     
    5659
    5760void AnimationState::updateScreen(void) {
    5861#ifndef BACKEND_8BIT
    59         _sys->copyRectToOverlay(_overlay, _movieWidth, 0, 40, _movieWidth, _movieHeight);
     62        int width = _movieScale * _frameWidth;
     63        int height = _movieScale * _frameHeight;
     64        int pitch = _movieScale * _movieWidth;
     65        int x = _movieScale * ((_movieWidth - _frameWidth) / 2);
     66        int y = _movieScale * ((_movieHeight - _frameHeight) / 2);
     67
     68        _sys->copyRectToOverlay(_overlay + y * pitch + x, pitch, x, y + _movieScale * 40, width, height);
    6069#endif
    6170        _sys->updateScreen();
    6271}
  • sword1/animation.h

    diff -ur ScummVM-cvs20050604/sword1/animation.h ScummVM-cvs20050604+gui/sword1/animation.h
    old new  
    6060private:
    6161        Screen *_scr;
    6262
     63        int _frameWidth;
     64        int _frameHeight;
     65
    6366public:
    6467        AnimationState(Screen *scr, Audio::Mixer *snd, OSystem *sys);
    6568        ~AnimationState();
  • sword2/driver/animation.cpp

     void Dialog::registerWidget(Widget *widget) {
    diff -ur ScummVM-cvs20050604/sword2/driver/animation.cpp ScummVM-cvs20050604+gui/sword2/driver/animation.cpp
    old new  
    5151#else
    5252
    5353void AnimationState::drawTextObject(SpriteInfo *s, byte *src) {
    54         OverlayColor *dst = _overlay + RENDERWIDE * s->y + s->x;
    55 
    56         // FIXME: These aren't the "right" colours, but look good to me.
     54        OverlayColor *dst = _overlay + _movieScale * _movieWidth * _movieScale * s->y + _movieScale * s->x;
    5755
    5856        OverlayColor pen = _sys->RGBToColor(255, 255, 255);
    5957        OverlayColor border = _sys->RGBToColor(0, 0, 0);
    6058
     59        // TODO: Use the AdvMame scalers for the text? Pre-scale it?
     60
    6161        for (int y = 0; y < s->h; y++) {
     62                OverlayColor *ptr = dst;
     63
    6264                for (int x = 0; x < s->w; x++) {
    6365                        switch (src[x]) {
    6466                        case 1:
    65                                 dst[x] = border;
     67                                *ptr++ = border;
     68                                if (_movieScale > 1) {
     69                                        *ptr++ = border;
     70                                        if (_movieScale > 2)
     71                                                *ptr++ = border;
     72                                }
    6673                                break;
    6774                        case 255:
    68                                 dst[x] = pen;
     75                                *ptr++ = pen;
     76                                if (_movieScale > 1) {
     77                                        *ptr++ = pen;
     78                                        if (_movieScale > 2)
     79                                                *ptr++ = pen;
     80                                }
    6981                                break;
    7082                        default:
     83                                ptr += _movieScale;
    7184                                break;
    7285                        }
    7386                }
    74                 dst += RENDERWIDE;
     87
     88                if (_movieScale > 1) {
     89                        memcpy(dst + _movieScale * _movieWidth, dst, _movieScale * s->w * sizeof(OverlayColor));
     90                        if (_movieScale > 2)
     91                                memcpy(dst + 2 * _movieScale * _movieWidth, dst, _movieScale * s->w * sizeof(OverlayColor));
     92                }
     93
     94                dst += _movieScale * _movieScale * _movieWidth;
    7595                src += s->w;
    7696        }
    7797}
     
    7999#endif
    80100
    81101void AnimationState::clearScreen() {
     102        _frameWidth = _movieWidth;
     103        _frameHeight = _movieHeight;
     104
    82105#ifdef BACKEND_8BIT
    83106        memset(_vm->_screen->getScreen(), 0, _movieWidth * _movieHeight);
    84107#else
    85108        OverlayColor black = _sys->RGBToColor(0, 0, 0);
    86109
    87         for (int i = 0; i < _movieWidth * _movieHeight; i++)
     110        for (int i = 0; i < _movieScale * _movieWidth * _movieScale * _movieHeight; i++)
    88111                _overlay[i] = black;
    89112#endif
    90113}
    91114
    92115void AnimationState::updateScreen() {
     116        int x, y;
     117
     118        x = (_movieWidth - _frameWidth) / 2;
     119        y = (_movieHeight - _frameHeight) / 2;
     120
    93121#ifdef BACKEND_8BIT
    94         byte *buf = _vm->_screen->getScreen() + ((480 - _movieHeight) / 2) * RENDERWIDE + (640 - _movieWidth) / 2;
     122        byte *buf = _vm->_screen->getScreen() + y * RENDERWIDE + x;
    95123
    96124        _vm->_system->copyRectToScreen(buf, _movieWidth, (640 - _movieWidth) / 2, (480 - _movieHeight) / 2, _movieWidth, _movieHeight);
    97125#else
    98         _sys->copyRectToOverlay(_overlay, _movieWidth, 0, 0, _movieWidth, _movieHeight);
     126        int width = _movieScale * _frameWidth;
     127        int height = _movieScale * _frameHeight;
     128        int pitch = _movieScale * _movieWidth;
     129
     130        x *= _movieScale;
     131        y *= _movieScale;
     132
     133        _sys->copyRectToOverlay(_overlay + y * pitch + x, pitch, x, y, width, height);
    99134#endif
    100135        _vm->_system->updateScreen();
    101136}
    102137
    103138void AnimationState::drawYUV(int width, int height, byte *const *dat) {
     139        _frameWidth = width;
     140        _frameHeight = height;
     141
    104142#ifdef BACKEND_8BIT
    105143        _vm->_screen->plotYUV(_lut, width, height, dat);
    106144#else
  • sword2/driver/animation.h

    diff -ur ScummVM-cvs20050604/sword2/driver/animation.h ScummVM-cvs20050604+gui/sword2/driver/animation.h
    old new  
    4545private:
    4646        Sword2Engine *_vm;
    4747
     48        int _frameWidth;
     49        int _frameHeight;
     50
    4851public:
    4952        AnimationState(Sword2Engine *vm);
    5053        ~AnimationState();