qtffthread.cpp

#include "qtffthread.h"
#include "qtffutil.h"

qtffthread::qtffthread()
{
}

qtffthread::~qtffthread()
{
        EXIT_INPUT_THREAD=1;
        wait();
}

void qtffthread::init(VideoState *is)
{
        is->parse_tid = SDL_CreateThread(decode_thread, is);
    if (!is->parse_tid) {
        av_free(is);
        
    }

}

void qtffthread::togglePause()
{
        //toggle_pause();
        // why doesnt this work?
        SDL_Event evt;
        evt.type = SDL_KEYDOWN;
        evt.key.keysym.sym = SDLK_SPACE;
        while ( SDL_PushEvent( &evt ) == -1) {}
}
/* schedule a video refresh in 'delay' ms */
//void qtffthread::schedule_refresh(VideoState *is, int delay)
//{
    //SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
//}

/* handle an event sent by the GUI */
void qtffthread::run()
{
    SDL_Event event;
    double incr, pos, frac;
    while (!EXIT_INPUT_THREAD)
    {
        SDL_WaitEvent(&event);
        switch(event.type) {
            case SDL_KEYDOWN:
                switch(event.key.keysym.sym) {
                    case SDLK_ESCAPE:
                    case SDLK_q:
                        do_exit();
                        break;
                    case SDLK_f:
                        toggle_full_screen();
                        break;
                    case SDLK_p:
                    case SDLK_SPACE:
                        toggle_pause();
                        break;
                        case SDLK_s: //S: Step to next frame
                            step_to_next_frame();
                            break;
                    case SDLK_a:
                        if (cur_stream)
                            stream_cycle_channel(cur_stream, CODEC_TYPE_AUDIO);
                        break;
                    case SDLK_v:
                        if (cur_stream)
                            stream_cycle_channel(cur_stream, CODEC_TYPE_VIDEO);
                        break;
                    case SDLK_t:
                        if (cur_stream)
                            stream_cycle_channel(cur_stream, CODEC_TYPE_SUBTITLE);
                        break;
                    case SDLK_w:
                        toggle_audio_display();
                        break;
                    case SDLK_LEFT:
                        incr = -10.0;
                        goto do_seek;
                    case SDLK_RIGHT:
                        incr = 10.0;
                        goto do_seek;
                    case SDLK_UP:
                        incr = 60.0;
                        goto do_seek;
                    case SDLK_DOWN:
                        incr = -60.0;
            do_seek:
                        if (cur_stream) {
                pos = get_master_clock(cur_stream);
                pos += incr;
                stream_seek(cur_stream, (int64_t)(pos * AV_TIME_BASE), incr);
                        }
                        break;
                    default:
                        break;
                }
                break;
            case SDL_MOUSEBUTTONDOWN:
                if (cur_stream) {
                    int ns, hh, mm, ss;
                    int tns, thh, tmm, tss;
                    tns = cur_stream->ic->duration/1000000LL;
                    thh = tns/3600;
                    tmm = (tns%3600)/60;
                    tss = (tns%60);
                    frac = (double)event.button.x/(double)cur_stream->width;
                    ns = frac*tns;
                    hh = ns/3600;
                    mm = (ns%3600)/60;
                    ss = (ns%60);
                    fprintf(stderr, "Seek to %2.0f%% (%2d:%02d:%02d) of total duration (%2d:%02d:%02d)       \n", frac*100,
                            hh, mm, ss, thh, tmm, tss);
                    stream_seek(cur_stream, (int64_t)(cur_stream->ic->start_time+frac*cur_stream->ic->duration), 0);
                }
                break;
            case SDL_VIDEORESIZE:
                if (cur_stream) {
                    myscreen = SDL_SetVideoMode(event.resize.w, event.resize.h, 0,
                                              SDL_HWSURFACE|SDL_RESIZABLE|SDL_ASYNCBLIT|SDL_HWACCEL);
                    cur_stream->width = event.resize.w;
                    cur_stream->height = event.resize.h;
                }
                break;
            case SDL_QUIT:
            case FF_QUIT_EVENT:
                do_exit();
                break;
            case FF_ALLOC_EVENT:
                alloc_picture(event.user.data1);
                break;
            case FF_REFRESH_EVENT:
                video_refresh_timer(event.user.data1);
                break;
            default:
                break;
        }
    }
}

void qtffthread::do_exit(void)
{
        EXIT_INPUT_THREAD=1;
        //wait();
    if (cur_stream) {
        stream_close(cur_stream);
        cur_stream = NULL;
    }
    if (show_status)
        printf("\n");
    SDL_Quit();
    exit(0);
}

void qtffthread::toggle_full_screen(void)
{
    int w, h, flags;
    is_full_screen = !is_full_screen;
    if (!fs_screen_width) {
        /* use default SDL method */
        SDL_WM_ToggleFullScreen(myscreen);
    } else {
        /* use the recorded resolution */
        flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
        if (is_full_screen) {
            w = fs_screen_width;
            h = fs_screen_height;
            flags |= SDL_FULLSCREEN;
        } else {
            w = screen_width;
            h = screen_height;
            flags |= SDL_RESIZABLE;
        }
        myscreen = SDL_SetVideoMode(w, h, 0, flags);
        cur_stream->width = w;
        cur_stream->height = h;
    }
}

void qtffthread::toggle_pause(void)
{
    if (cur_stream)
        stream_pause(cur_stream);
    step = 0;
}

void qtffthread::stream_cycle_channel(VideoState *is, int codec_type)
{
    AVFormatContext *ic = is->ic;
    int start_index, stream_index;
    AVStream *st;

    if (codec_type == CODEC_TYPE_VIDEO)
        start_index = is->video_stream;
    else if (codec_type == CODEC_TYPE_AUDIO)
        start_index = is->audio_stream;
    else
        start_index = is->subtitle_stream;
    if (start_index < (codec_type == CODEC_TYPE_SUBTITLE ? -1 : 0))
        return;
    stream_index = start_index;
    for(;;) {
        if (++stream_index >= is->ic->nb_streams)
        {
            if (codec_type == CODEC_TYPE_SUBTITLE)
            {
                stream_index = -1;
                goto the_end;
            } else
                stream_index = 0;
        }
        if (stream_index == start_index)
            return;
        st = ic->streams[stream_index];
        if (st->codec->codec_type == codec_type) {
            /* check that parameters are OK */
            switch(codec_type) {
                case CODEC_TYPE_AUDIO:
                    if (st->codec->sample_rate != 0 &&
                        st->codec->channels != 0)
                        goto the_end;
                    break;
                case CODEC_TYPE_VIDEO:
                case CODEC_TYPE_SUBTITLE:
                    goto the_end;
                default:
                    break;
            }
        }
    }
 the_end:
         stream_component_close(is, start_index);
 stream_component_open(is, stream_index);
}




void qtffthread::step_to_next_frame(void)
{
    if (cur_stream) {
        if (cur_stream->paused)
            cur_stream->paused=0;
        cur_stream->video_current_pts = get_video_clock(cur_stream);
    }
    step = 1;
}


void qtffthread::toggle_audio_display(void)
{
    if (cur_stream) {
        cur_stream->show_audio = !cur_stream->show_audio;
    }
}

/* seek in the stream */
void qtffthread::stream_seek(VideoState *is, int64_t pos, int rel)
{
    if (!is->seek_req) {
        is->seek_pos = pos;
        is->seek_flags = rel < 0 ? AVSEEK_FLAG_BACKWARD : 0;
        is->seek_req = 1;
    }
}

/* allocate a picture (needs to do that in main thread to avoid
   potential locking problems */
 void qtffthread::alloc_picture(void *opaque)
{
    VideoState *is = (VideoState*)opaque;
    VideoPicture *vp;

    vp = &is->pictq[is->pictq_windex];

    if (vp->bmp)
        SDL_FreeYUVOverlay(vp->bmp);

    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,
                                   is->video_st->codec->height,
                                   SDL_YV12_OVERLAY,
                                   myscreen);
    vp->width = is->video_st->codec->width;
    vp->height = is->video_st->codec->height;

    SDL_LockMutex(is->pictq_mutex);
    vp->allocated = 1;
    SDL_CondSignal(is->pictq_cond);
    SDL_UnlockMutex(is->pictq_mutex);
}

/* called to display each frame */
 void qtffthread::video_refresh_timer(void *opaque)
{
    VideoState *is = (VideoState*)opaque;
    VideoPicture *vp;
    double actual_delay, delay, sync_threshold, ref_clock, diff;

    SubPicture *sp, *sp2;

    if (is->video_st) {
        if (is->pictq_size == 0) {
            /* if no picture, need to wait */
            schedule_refresh(is, 1);
        } else {
            /* dequeue the picture */
            vp = &is->pictq[is->pictq_rindex];

            /* update current video pts */
            is->video_current_pts = vp->pts;
            is->video_current_pts_time = av_gettime();

            /* compute nominal delay */
            delay = vp->pts - is->frame_last_pts;
            if (delay <= 0 || delay >= 1.0) {
                /* if incorrect delay, use previous one */
                delay = is->frame_last_delay;
            }
            is->frame_last_delay = delay;
            is->frame_last_pts = vp->pts;

            /* update delay to follow master synchronisation source */
            if (((is->av_sync_type == AV_SYNC_AUDIO_MASTER && is->audio_st) ||
                  is->av_sync_type == AV_SYNC_EXTERNAL_CLOCK)) {
                /* if video is slave, we try to correct big delays by
                duplicating or deleting a frame */
                ref_clock = get_master_clock(is);
                diff = vp->pts - ref_clock;

                /* skip or repeat frame. We take into account the
                delay to compute the threshold. I still don't know
                if it is the best guess */
                sync_threshold = AV_SYNC_THRESHOLD;
                if (delay > sync_threshold)
                    sync_threshold = delay;
                if (fabs(diff) < AV_NOSYNC_THRESHOLD) {
                    if (diff <= -sync_threshold)
                        delay = 0;
                    else if (diff >= sync_threshold)
                        delay = 2 * delay;
                }
                  }

                  is->frame_timer += delay;
            /* compute the REAL delay (we need to do that to avoid
                  long term errors */
                  actual_delay = is->frame_timer - (av_gettime() / 1000000.0);
                  if (actual_delay < 0.010) {
                      /* XXX: should skip picture */
                      actual_delay = 0.010;
                  }
                  /* launch timer for next picture */
                  schedule_refresh(is, (int)(actual_delay * 1000 + 0.5));

#if defined(DEBUG_SYNC)
            printf("video: delay=%0.3f actual_delay=%0.3f pts=%0.3f A-V=%f\n",
                   delay, actual_delay, vp->pts, -diff);
#endif

            if(is->subtitle_st) {
    if (is->subtitle_stream_changed) {
        SDL_LockMutex(is->subpq_mutex);

        while (is->subpq_size) {
            free_subpicture(&is->subpq[is->subpq_rindex]);

            /* update queue size and signal for next picture */
            if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
                is->subpq_rindex = 0;

            is->subpq_size--;
        }
        is->subtitle_stream_changed = 0;

        SDL_CondSignal(is->subpq_cond);
        SDL_UnlockMutex(is->subpq_mutex);
    } else {
        if (is->subpq_size > 0) {
            sp = &is->subpq[is->subpq_rindex];

            if (is->subpq_size > 1)
                sp2 = &is->subpq[(is->subpq_rindex + 1) % SUBPICTURE_QUEUE_SIZE];
            else
                sp2 = NULL;

            if ((is->video_current_pts > (sp->pts + ((float) sp->sub.end_display_time / 1000)))
                 || (sp2 && is->video_current_pts > (sp2->pts + ((float) sp2->sub.start_display_time / 1000))))
            {
                free_subpicture(sp);

                /* update queue size and signal for next picture */
                if (++is->subpq_rindex == SUBPICTURE_QUEUE_SIZE)
                    is->subpq_rindex = 0;

                SDL_LockMutex(is->subpq_mutex);
                is->subpq_size--;
                SDL_CondSignal(is->subpq_cond);
                SDL_UnlockMutex(is->subpq_mutex);
            }
        }
    }
            }

            /* display picture */
            video_display(is);

            /* update queue size and signal for next picture */
            if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE)
                is->pictq_rindex = 0;

            SDL_LockMutex(is->pictq_mutex);
            is->pictq_size--;
            SDL_CondSignal(is->pictq_cond);
            SDL_UnlockMutex(is->pictq_mutex);
        }
    } else if (is->audio_st) {
        /* draw the next audio frame */

        schedule_refresh(is, 40);

        /* if only audio stream, then display the audio bars (better
        than nothing, just to test the implementation */

        /* display picture */
        video_display(is);
    } else {
        schedule_refresh(is, 100);
    }
    if (show_status) {
        static int64_t last_time;
        int64_t cur_time;
        int aqsize, vqsize, sqsize;
        double av_diff;

        cur_time = av_gettime();
        if (!last_time || (cur_time - last_time) >= 500 * 1000) {
            aqsize = 0;
            vqsize = 0;
            sqsize = 0;
            if (is->audio_st)
                aqsize = is->audioq.size;
            if (is->video_st)
                vqsize = is->videoq.size;
            if (is->subtitle_st)
                sqsize = is->subtitleq.size;
            av_diff = 0;
            if (is->audio_st && is->video_st)
                av_diff = get_audio_clock(is) - get_video_clock(is);
            printf("%7.2f A-V:%7.3f aq=%5dKB vq=%5dKB sq=%5dB    \r",
                   get_master_clock(is), av_diff, aqsize / 1024, vqsize / 1024, sqsize);
            fflush(stdout);
            last_time = cur_time;
        }
    }
}

void qtffthread::free_subpicture(SubPicture *sp)
{
    int i;

    for (i = 0; i < sp->sub.num_rects; i++)
    {
        av_free(sp->sub.rects[i].bitmap);
        av_free(sp->sub.rects[i].rgba_palette);
    }

    av_free(sp->sub.rects);

    memset(&sp->sub, 0, sizeof(AVSubtitle));
}

/* schedule a video refresh in 'delay' ms */
void qtffthread::schedule_refresh(VideoState *is, int delay)
{
    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);
}

/* display the current picture, if any */
void qtffthread::video_display(VideoState *is)
{
    if (is->audio_st && is->show_audio)
        video_audio_display(is);
    else if (is->video_st)
        video_image_display(is);
}
void qtffthread::stream_close(VideoState *is)
{
    VideoPicture *vp;
    int i;
    /* XXX: use a special url_shutdown call to abort parse cleanly */
    is->abort_request = 1;
    SDL_WaitThread(is->parse_tid, NULL);

    /* free all pictures */
    for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE; i++) {
        vp = &is->pictq[i];
        if (vp->bmp) {
            SDL_FreeYUVOverlay(vp->bmp);
            vp->bmp = NULL;
        }
    }
    SDL_DestroyMutex(is->pictq_mutex);
    SDL_DestroyCond(is->pictq_cond);
    SDL_DestroyMutex(is->subpq_mutex);
    SDL_DestroyCond(is->subpq_cond);
    SDL_DestroyMutex(is->subtitle_decoder_mutex);
    SDL_DestroyMutex(is->audio_decoder_mutex);
    SDL_DestroyMutex(is->video_decoder_mutex);
}

void qtffthread::video_audio_display(VideoState *s)
{
    int i, i_start, x, y1, y, ys, delay, n, nb_display_channels;
    int ch, channels, h, h2, bgcolor, fgcolor;
    int16_t time_diff;

    /* compute display index : center on currently output samples */
    channels = s->audio_st->codec->channels;
    nb_display_channels = channels;
    if (!s->paused) {
        n = 2 * channels;
        delay = audio_write_get_buf_size(s);
        delay /= n;

        /* to be more precise, we take into account the time spent since
        the last buffer computation */
        if (audio_callback_time) {
            time_diff = av_gettime() - audio_callback_time;
            delay += (time_diff * s->audio_st->codec->sample_rate) / 1000000;
        }

        delay -= s->width / 2;
        if (delay < s->width)
            delay = s->width;
        i_start = compute_mod(s->sample_array_index - delay * channels, SAMPLE_ARRAY_SIZE);
        s->last_i_start = i_start;
    } else {
        i_start = s->last_i_start;
    }

    bgcolor = SDL_MapRGB(myscreen->format, 0x00, 0x00, 0x00);
    fill_rectangle(myscreen,
                   s->xleft, s->ytop, s->width, s->height,
                   bgcolor);

    fgcolor = SDL_MapRGB(myscreen->format, 0xff, 0xff, 0xff);

    /* total height for one channel */
    h = s->height / nb_display_channels;
    /* graph height / 2 */
    h2 = (h * 9) / 20;
    for(ch = 0;ch < nb_display_channels; ch++) {
        i = i_start + ch;
        y1 = s->ytop + ch * h + (h / 2); /* position of center line */
        for(x = 0; x < s->width; x++) {
            y = (s->sample_array[i] * h2) >> 15;
            if (y < 0) {
                y = -y;
                ys = y1 - y;
            } else {
                ys = y1;
            }
            fill_rectangle(myscreen,
                           s->xleft + x, ys, 1, y,
                           fgcolor);
            i += channels;
            if (i >= SAMPLE_ARRAY_SIZE)
                i -= SAMPLE_ARRAY_SIZE;
        }
    }

    fgcolor = SDL_MapRGB(myscreen->format, 0x00, 0x00, 0xff);

    for(ch = 1;ch < nb_display_channels; ch++) {
        y = s->ytop + ch * h;
        fill_rectangle(myscreen,
                       s->xleft, y, s->width, 1,
                       fgcolor);
    }
    SDL_UpdateRect(myscreen, s->xleft, s->ytop, s->width, s->height);
}

void qtffthread::video_image_display(VideoState *is)
{
    VideoPicture *vp;
    SubPicture *sp;
    AVPicture pict;
    float aspect_ratio;
    int width, height, x, y;
    SDL_Rect rect;
    int i;

    vp = &is->pictq[is->pictq_rindex];
    if (vp->bmp) {
        /* XXX: use variable in the frame */
        if (is->video_st->codec->sample_aspect_ratio.num == 0)
            aspect_ratio = 0;
        else
            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)
                    * is->video_st->codec->width / is->video_st->codec->height;;
        if (aspect_ratio <= 0.0)
            aspect_ratio = (float)is->video_st->codec->width /
                    (float)is->video_st->codec->height;
        /* if an active format is indicated, then it overrides the
        mpeg format */
        
if (is->subtitle_st)
{
    if (is->subpq_size > 0)
    {
        sp = &is->subpq[is->subpq_rindex];

        if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 1000))
        {
            SDL_LockYUVOverlay (vp->bmp);

            pict.data[0] = vp->bmp->pixels[0];
            pict.data[1] = vp->bmp->pixels[2];
            pict.data[2] = vp->bmp->pixels[1];

            pict.linesize[0] = vp->bmp->pitches[0];
            pict.linesize[1] = vp->bmp->pitches[2];
            pict.linesize[2] = vp->bmp->pitches[1];

            for (i = 0; i < sp->sub.num_rects; i++)
                blend_subrect(&pict, &sp->sub.rects[i]);

            SDL_UnlockYUVOverlay (vp->bmp);
        }
    }
}


        /* XXX: we suppose the myscreen has a 1.0 pixel ratio */
        height = is->height;
        width = ((int)rint(height * aspect_ratio)) & -3;
        if (width > is->width) {
            width = is->width;
            height = ((int)rint(width / aspect_ratio)) & -3;
        }
        x = (is->width - width) / 2;
        y = (is->height - height) / 2;
        if (!is->no_background) {
            /* fill the background */
            //            fill_border(is, x, y, width, height, QERGB(0x00, 0x00, 0x00));
        } else {
            is->no_background = 0;
        }
        rect.x = is->xleft + x;
        rect.y = is->xleft + y;
        rect.w = width;
        rect.h = height;
        SDL_DisplayYUVOverlay(vp->bmp, &rect);
    } else {

    }
}

void qtffthread::blend_subrect(AVPicture *dst, const AVSubtitleRect *rect)
{
    int wrap, wrap3, width2, skip2;
    int y, u, v, a, u1, v1, a1, w, h;
    uint8_t *lum, *cb, *cr;
    const uint8_t *p;
    const uint32_t *pal;

    lum = dst->data[0] + rect->y * dst->linesize[0];
    cb = dst->data[1] + (rect->y >> 1) * dst->linesize[1];
    cr = dst->data[2] + (rect->y >> 1) * dst->linesize[2];

    width2 = (rect->w + 1) >> 1;
    skip2 = rect->x >> 1;
    wrap = dst->linesize[0];
    wrap3 = rect->linesize;
    p = rect->bitmap;
    pal = rect->rgba_palette;  /* Now in YCrCb! */

    if (rect->y & 1) {
        lum += rect->x;
        cb += skip2;
        cr += skip2;

        if (rect->x & 1) {
            YUVA_IN(y, u, v, a, p, pal);
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
            cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
            cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
            cb++;
            cr++;
            lum++;
            p += BPP;
        }
        for(w = rect->w - (rect->x & 1); w >= 2; w -= 2) {
            YUVA_IN(y, u, v, a, p, pal);
            u1 = u;
            v1 = v;
            a1 = a;
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            YUVA_IN(y, u, v, a, p + BPP, pal);
            u1 += u;
            v1 += v;
            a1 += a;
            lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
            cb++;
            cr++;
            p += 2 * BPP;
            lum += 2;
        }
        if (w) {
            YUVA_IN(y, u, v, a, p, pal);
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
            cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
            cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
        }
        p += wrap3 + (wrap3 - rect->w * BPP);
        lum += wrap + (wrap - rect->w - rect->x);
        cb += dst->linesize[1] - width2 - skip2;
        cr += dst->linesize[2] - width2 - skip2;
    }
    for(h = rect->h - (rect->y & 1); h >= 2; h -= 2) {
        lum += rect->x;
        cb += skip2;
        cr += skip2;

        if (rect->x & 1) {
            YUVA_IN(y, u, v, a, p, pal);
            u1 = u;
            v1 = v;
            a1 = a;
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
            p += wrap3;
            lum += wrap;
            YUVA_IN(y, u, v, a, p, pal);
            u1 += u;
            v1 += v;
            a1 += a;
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
            cb++;
            cr++;
            p += -wrap3 + BPP;
            lum += -wrap + 1;
        }
        for(w = rect->w - (rect->x & 1); w >= 2; w -= 2) {
            YUVA_IN(y, u, v, a, p, pal);
            u1 = u;
            v1 = v;
            a1 = a;
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            YUVA_IN(y, u, v, a, p, pal);
            u1 += u;
            v1 += v;
            a1 += a;
            lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
            p += wrap3;
            lum += wrap;

            YUVA_IN(y, u, v, a, p, pal);
            u1 += u;
            v1 += v;
            a1 += a;
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            YUVA_IN(y, u, v, a, p, pal);
            u1 += u;
            v1 += v;
            a1 += a;
            lum[1] = ALPHA_BLEND(a, lum[1], y, 0);

            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 2);
            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 2);

            cb++;
            cr++;
            p += -wrap3 + 2 * BPP;
            lum += -wrap + 2;
        }
        if (w) {
            YUVA_IN(y, u, v, a, p, pal);
            u1 = u;
            v1 = v;
            a1 = a;
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
            p += wrap3;
            lum += wrap;
            YUVA_IN(y, u, v, a, p, pal);
            u1 += u;
            v1 += v;
            a1 += a;
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u1, 1);
            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v1, 1);
            cb++;
            cr++;
            p += -wrap3 + BPP;
            lum += -wrap + 1;
        }
        p += wrap3 + (wrap3 - rect->w * BPP);
        lum += wrap + (wrap - rect->w - rect->x);
        cb += dst->linesize[1] - width2 - skip2;
        cr += dst->linesize[2] - width2 - skip2;
    }
    /* handle odd height */
    if (h) {
        lum += rect->x;
        cb += skip2;
        cr += skip2;

        if (rect->x & 1) {
            YUVA_IN(y, u, v, a, p, pal);
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
            cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
            cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
            cb++;
            cr++;
            lum++;
            p += BPP;
        }
        for(w = rect->w - (rect->x & 1); w >= 2; w -= 2) {
            YUVA_IN(y, u, v, a, p, pal);
            u1 = u;
            v1 = v;
            a1 = a;
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);

            YUVA_IN(y, u, v, a, p + BPP, pal);
            u1 += u;
            v1 += v;
            a1 += a;
            lum[1] = ALPHA_BLEND(a, lum[1], y, 0);
            cb[0] = ALPHA_BLEND(a1 >> 2, cb[0], u, 1);
            cr[0] = ALPHA_BLEND(a1 >> 2, cr[0], v, 1);
            cb++;
            cr++;
            p += 2 * BPP;
            lum += 2;
        }
        if (w) {
            YUVA_IN(y, u, v, a, p, pal);
            lum[0] = ALPHA_BLEND(a, lum[0], y, 0);
            cb[0] = ALPHA_BLEND(a >> 2, cb[0], u, 0);
            cr[0] = ALPHA_BLEND(a >> 2, cr[0], v, 0);
        }
    }
}

inline int qtffthread::compute_mod(int a, int b)
{
    a = a % b;
    if (a >= 0)
        return a;
    else
        return a + b;
}

inline void qtffthread::fill_rectangle(SDL_Surface *myscreen,
                                 int x, int y, int w, int h, int color)
{
    SDL_Rect rect;
    rect.x = x;
    rect.y = y;
    rect.w = w;
    rect.h = h;
    SDL_FillRect(myscreen, &rect, color);
}

---