qtffplay.cpp

#include "qtffplay.h"
//#include "qtffutil.h"

#include <iostream>
//testing
#include <QLabel>
#include <QPixmap>

Uint8 *dataR, *dataG, *dataB, *dataA;
int globWidth, globHeight;
int globLine0, globLine1, globLine2;

QtFFPlay::QtFFPlay(QWidget *parent, Qt::WFlags flags) : QWidget(parent, flags)
{
        
        alreadyInit = 0;
        buffer_init = 0;
        //setAttribute(Qt::WA_PaintOnScreen);
        //input_filename="example.avi";
    /* register all codecs, demux and protocols */
    av_register_all();
    
}


void QtFFPlay::grabWindow()
{
        SDL_QuitSubSystem(SDL_INIT_VIDEO);
    char variable[64];
    snprintf(variable, sizeof("SDL_WINDOWID=0x0000000"), "SDL_WINDOWID=0x%lx", winId());
    putenv(variable);
    std::cout << "in grabwindow " << variable << std::endl;
    SDL_InitSubSystem(SDL_INIT_VIDEO);
    mythread.myscreen = SDL_SetVideoMode(this->width(),this->height(), 32, flags);
        //myscreen = SDL_SetVideoMode(640,480, 32, flags);
 
}

void QtFFPlay::paintEvent(QPaintEvent *)
{
        //if (alreadyInit)
                //grabWindow(); 
                //SDL_UpdateRect(myscreen, 0, 0, this->width(), this->height());
}

void QtFFPlay::togglePause()
{
        mythread.togglePause();
}
void QtFFPlay::resizeEvent(QResizeEvent *)
{
        // Set the new video mode with the new window size
    //
    //if (alreadyInit)
        //      grabWindow();
                        
    //char variable[64];
    //sprintf(variable, "SDL_WINDOWID=0x%lx", winId());
    //snprintf(variable, sizeof(variable), "SDL_WINDOWID=0x%lx", winId());
    //snprintf(variable, sizeof("SDL_WINDOWID=0x0000000"), "SDL_WINDOWID=0x%lx", winId());
    //putenv(variable);
    //std::cout << variable << std::endl;
}    
    
int QtFFPlay::init()
{
    // To be called after at least a filename is chosen
    //parse_options(argc, argv, options);
    if (input_filename.isEmpty())
        show_help();
    if (display_disable) {
        video_disable = 1;
    }
    flags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER;
#if !defined(CONFIG_WIN32) && !defined(CONFIG_DARWIN)
    flags |= SDL_INIT_EVENTTHREAD; /* Not supported on win32 or darwin */
#endif
    if (SDL_Init (flags)) {
    fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
    return 1;
    }
    if (!display_disable) {
#ifdef HAVE_X11
        /* save the screen resolution... SDL should allow full screen
           by resizing the window */
{
    Display *dpy;
    dpy = XOpenDisplay(NULL);
    if (dpy) {
        fs_screen_width = DisplayWidth(dpy, DefaultScreen(dpy));
        fs_screen_height = DisplayHeight(dpy, DefaultScreen(dpy));
        XCloseDisplay(dpy);
    }
}
#endif
        flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
        if (is_full_screen && fs_screen_width) {
            w = fs_screen_width;
            h = fs_screen_height;
            flags |= SDL_FULLSCREEN;
        } else {
            w = screen_width;
            h = screen_height;
            flags |= SDL_RESIZABLE;
        }
#ifndef CONFIG_DARWIN
        mythread.myscreen = SDL_SetVideoMode(w, h, 0, flags);
#else
        /* setting bits_per_pixel = 0 or 32 causes blank video on OS X */
        //myscreen = SDL_SetVideoMode(this->width(),this->height(), 24, flags);
        mythread.myscreen = SDL_SetVideoMode(w,h, 32, flags);
        //myscreen = SDL_SetVideoMode(640,480, 32, flags);
#endif
    if (!mythread.myscreen) {
    fprintf(stderr, "SDL: could not set video mode\n");
    return 1 ;
    }
    SDL_WM_SetCaption("VisualODF", "VisualODF");
    }

    SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
    SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
    SDL_EventState(SDL_SYSWMEVENT, SDL_IGNORE);
    SDL_EventState(SDL_USEREVENT, SDL_IGNORE);
        //grabWindow();
    cur_stream = stream_open(&input_filename, &*file_iformat);

     mythread.EXIT_INPUT_THREAD=0;
     mythread.start();
     alreadyInit = 1;
     //mythread.togglePause();
        return 0;
    
    
}

QImage* QtFFPlay::grabFrame()
{
        
        if ( !this->buffer_init )
                {
                        //av_free(buffer_rgb);
                                
                        buffer_rgb = (Uint32*)calloc( globLine0 * globHeight , 4 );
                        //std::cout << "Allocating buffer." << std::endl;
                        this->buffer_init = 1;
                } 
                
    
        Uint8 y,u,v;
        Uint32 rgbval = 0;
        int xLoc, yLoc, newX, newY, newIdx;
        
        
        for (int i = 0; i < globLine0 * globHeight; i++)
        {
                y = dataR[i];
        
                // Now find the correct v and u pixels!
                xLoc = (int) ((double)i/(double)globWidth); 
                yLoc = (i % globWidth);
                newX = xLoc/2;
                newY = yLoc/2;
                newIdx = (newX*globWidth/2+ newY);
        
                v = dataG[newIdx];
                u = dataB[newIdx];
        
                rgbval = convert_yuv_rgb(y,u,v);
        
                buffer_rgb[i] = rgbval;
        
        }
        //std::cout << "Grabbed a frame." << std::endl;
        
        QImage *img1 = new QImage( (unsigned char*)buffer_rgb, globLine0, globHeight, QImage::Format_RGB32);
        //QPixmap pm = QPixmap::fromImage( *img1 );
        //pm.save("test1.png", "png");
        //char *filnm = "testpgmR.pgm";    
        //save_pgm( (unsigned char*)dataR, globLine0, globWidth, globHeight, filnm);
        return img1;    
        
}

void QtFFPlay::save_pgm(unsigned char *buf,int wrap, int xsize,int ysize,char *filename)
{
        /* Test write to pgm format!*/
        FILE *f;
    int i;
        std::cout << "Writing pgm: " << wrap << " " << xsize << " " << ysize << " " << filename << std::endl;
    f=fopen(filename,"w");
    fprintf(f,"P5\n%d %d\n%d\n",xsize,ysize,255);
    for(i=0;i<ysize;i++)
        fwrite(buf + i * wrap,1,xsize,f);
    fclose(f);
}

Uint32 QtFFPlay::convert_yuv_rgb(Uint8 y, Uint8 u, Uint8 v)
{
        /*// take YUV and convert to RGB
        float r,g,b;
        float Y = yy;
        float U = uu;
        float V = vv;   
//      r = (float)Y + 1.403 * (float)V;
//      g = (float)Y - 0.344*(float)U - 0.714 * (float)V;
//      b = (float)Y + 1.770*(float)U;

        b = 1.164 *(Y - 16)                   + 2.018*(U - 128);
        g = 1.164*(Y - 16) - 0.813*(V - 128) - 0.391*(U - 128);
        r = 1.164*(Y - 16) + 1.596*(V - 128);

        if (b > 255) b = 255;
        if (r > 255) r = 255;
        if (g > 255) g = 255;
        if (b < 0 ) b = 0;
        if (r < 0 ) r = 0;
        if (g < 0 ) g = 0;
        
        Uint32 rgb = 0;
        Uint8 tmpint;
        tmpint = r;
        rgb = rgb | ( tmpint << 16);
        tmpint = g;
        rgb = rgb | ( tmpint << 8);
        rgb = rgb + (int)b;
        rgb = rgb | 0xff000000;
        return rgb;
        */
        unsigned int pixel32;
        unsigned char *pixel = (unsigned char *)&pixel32;
        int r, g, b;
        r = y + (1.370705 * (v-128));
        g = y - (0.698001 * (v-128)) - (0.337633 * (u-128));
        b = y + (1.732446 * (u-128));
   // Even with proper conversion, some values still need clipping.
   if (r > 255) r = 255;
   if (g > 255) g = 255;
   if (b > 255) b = 255;
   if (r < 0) r = 0;
   if (g < 0) g = 0;
   if (b < 0) b = 0;

   pixel[0] = r * 220 / 256;
   pixel[1] = g * 220 / 256;
   pixel[2] = b * 220 / 256;
   
   pixel[3] = 0;
   return pixel32;
}
 

VideoState* QtFFPlay::stream_open(QString *filename, AVInputFormat *iformat)
{
        // The original videostate that is used is created here.
    
    is = (VideoState*)av_mallocz(sizeof(VideoState));
    if (!is)
        return NULL;
   //const char *buffer = filename->data();
   
        QByteArray foo = filename->toAscii();
        const char* buffer = foo.data();
   
    //const char buffer[1024]=filename->data();
    //is->filename = (const char*)filename->data()->toAscii();
    //is->filename = 
    //is->filename = filename->toLatin1();
    pstrcpy(is->filename, sizeof(is->filename), buffer);
    
    //
    //is->filename[0] = buffer[0];//(char)input_filename.data();
    std::cout << "Playing " << is->filename << std::endl;
    is->iformat = iformat;
    if (mythread.myscreen) {
        is->width = mythread.myscreen->w;
        is->height = mythread.myscreen->h;
    }
    is->ytop = 0;
    is->xleft = 0;

    /* start video display */
    is->pictq_mutex = SDL_CreateMutex();
    is->pictq_cond = SDL_CreateCond();

    is->subpq_mutex = SDL_CreateMutex();
    is->subpq_cond = SDL_CreateCond();

    is->subtitle_decoder_mutex = SDL_CreateMutex();
    is->audio_decoder_mutex = SDL_CreateMutex();
    is->video_decoder_mutex = SDL_CreateMutex();

    /* add the refresh timer to draw the picture */
    mythread.schedule_refresh(is, 40);

    is->av_sync_type = av_sync_type;
    mythread.init(is);
    /*is->parse_tid = SDL_CreateThread(decode_thread, is);
    if (!is->parse_tid) {
        av_free(is);
        return NULL;
    }*/
    
        
    return is;
}

 

void QtFFPlay::opt_width(const char *arg)
{
    screen_width = atoi(arg);
}

void QtFFPlay::opt_height(const char *arg)
{
    screen_height = atoi(arg);
}

 void QtFFPlay::opt_format(const char *arg)
{
    file_iformat = av_find_input_format(arg);
    if (!file_iformat) {
        fprintf(stderr, "Unknown input format: %s\n", arg);
        exit(1);
    }
}

 void QtFFPlay::opt_image_format(const char *arg)
{
    AVImageFormat *f;

    for(f = first_image_format; f != NULL; f = f->next) {
        if (!strcmp(arg, f->name))
            break;
    }
    if (!f) {
        fprintf(stderr, "Unknown image format: '%s'\n", arg);
        exit(1);
    }
    image_format = f;
}

//#ifdef CONFIG_NETWORK
//void QtFFPlay::opt_rtp_tcp(void)
//{
    /* only tcp protocol */
    //rtsp_default_protocols = (1 << RTSP_PROTOCOL_RTP_TCP);
//}
//#endif

void QtFFPlay::opt_sync(const char *arg)
{
    if (!strcmp(arg, "audio"))
        av_sync_type = AV_SYNC_AUDIO_MASTER;
    else if (!strcmp(arg, "video"))
        av_sync_type = AV_SYNC_VIDEO_MASTER;
    else if (!strcmp(arg, "ext"))
        av_sync_type = AV_SYNC_EXTERNAL_CLOCK;
    else
        show_help();
}

void QtFFPlay::opt_seek(const char *arg)
{
    start_time = parse_date(arg, 1);
}

 void QtFFPlay::opt_debug(const char *arg)
{
    debug = atoi(arg);
}

 void QtFFPlay::opt_vismv(const char *arg)
{
    debug_mv = atoi(arg);
}

 void QtFFPlay::opt_thread_count(const char *arg)
{
    thread_count= atoi(arg);
#if !defined(HAVE_THREADS)
    fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
#endif
}

void QtFFPlay::show_help(void)
{
}

void QtFFPlay::parse_arg_file(const char *filename)
{
    if (!strcmp(filename, "-"))
        filename = "pipe:";
    input_filename = filename;
}

---