main.cpp

linux下实现视频播放的播放器

/*
 *  Copyright (C) 2005-2008  gulikoza, mtrooper
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/* $Id$ */

#include "main.h"

#define USES_BASECLASS
#include "video.h"

#include "GetPot.h"
#include "SDL_opengl.h"

// GUI elements
#include "wxgui/Channel_List.h"
#include "wxgui/StreamInfo.h"
#include "wxgui/TaskBarIcon.h"

//#define DEBUG
#include "log.h"

#if C_SET_PRIORITY
#include <sys/resource.h>
#define PRIO_TOTAL (PRIO_MAX-PRIO_MIN)
#endif

#include "platform/platform.h"

#define MODULE "Main"

SDL_Block sdl;
SDL_bar   sdl_bar;
HPTimer * timer;
EventQueue * events;

void ParseIniFile(const char *iniFileName);
void ParseCmdLine(int argc, char *argv[]);
void PrintHelp();

int main(int argc, char *argv[])
{
    fprintf(stderr, "Hello. Initializing SDL now..\n");

#ifdef WIN32
    // Load Dr.MinGW crash handler
    LoadLibrary("exchndl.dll");

    // Disable screen saver
    SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, FALSE,0,SPIF_SENDWININICHANGE);
#endif

    putenv("SDL_VIDEO_YUV_DIRECT=1");
    putenv("SDL_VIDEO_YUV_HWACCEL=1");
    if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO|SDL_INIT_TIMER)) {
	fprintf(stderr, "Can't init SDL %s\n", SDL_GetError());
	return 1;
    }

    // Initialize wxwidgets
#if (C_HAVE_WXGUI)
    SDL_CreateThread(wxGUIstart, NULL);
#endif

    // Init sdl block
    SDL_memset(&sdl, 0, ((char*)&sdl.rememberChannel - (char*)&sdl));

    sdl.recordingDir = "./";
    sdl.recording = false;
    sdl.delay = 700;
    sdl.ch_num = 1;

    sdl.channelSurfingDelay = 8000;
    sdl.hideMouseInFullscreenDelay = 3000;
    sdl.rememberChannel = false;

    sdl.channel_list = "channels.txt";

#ifndef WIN32
    // This might produce problems in MinGW...
    if(getenv("HOME") != NULL) {
	sdl.channel_list.assign(getenv("HOME"));
	sdl.channel_list.append("/channels.txt");
    }
#endif

    sdl.iniFile = "friptv.ini";
#if (C_HAS_LIBPOSTPROC)
    sdl.ppEnabled =  false;
#endif

    ParseIniFile(sdl.iniFile.c_str());

    // Environment overrides ini
    if(getenv("CHANNELS") != NULL) {
	sdl.channel_list.assign(getenv("CHANNELS"));
    }

    // So does command line
    ParseCmdLine(argc, argv);

#ifdef WIN32
    char * sdl_videodrv = (char*)calloc(sizeof(char), 128);
    SDL_VideoDriverName(sdl_videodrv, 128);

    if((sdl.winfast) || (sdl.output_mode == GDI)) {
	if(strcmp(sdl_videodrv,"windib")) {
	    SDL_QuitSubSystem(SDL_INIT_VIDEO);
	    putenv("SDL_VIDEODRIVER=windib");
	    if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
#if (C_HAVE_WXGUI)
		wxMessageBox(wxT("Can't init SDL video!"), wxT("Error"), wxICON_ERROR | wxOK);
#endif
		QuitProgram(false);
	    }
	}
    } else if((strcmp(sdl_videodrv,"directx")) && (getenv("SDL_VIDEODRIVER") == NULL)) {
	ERROR_MSG("Restarting video with directx enabled...");
	SDL_QuitSubSystem(SDL_INIT_VIDEO);
	putenv("SDL_VIDEODRIVER=directx");
	if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
	    putenv("SDL_VIDEODRIVER=windib");
	    if(SDL_InitSubSystem(SDL_INIT_VIDEO) < 0) {
#if (C_HAVE_WXGUI)
		wxMessageBox(wxT("Can't init SDL video!"), wxT("Error"), wxICON_ERROR | wxOK);
#endif
		QuitProgram(false);
	    }
	}
    }
    free(sdl_videodrv);
#endif

    if(sdl.time) {
	ERROR_MSG("Running time: %u min", sdl.time);
	sdl.time *= 60000;
    }

    try {

    ERROR_MSG("Init SDL done. ThreadID: %u", SDL_ThreadID());
    timer = new HPTimer(sdl.delay);

    // Set high priority to get better timer resolution
#ifdef WIN32
    SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS);
#elif C_SET_PRIORITY
    setpriority(PRIO_PGRP, 0,PRIO_MAX-((3*PRIO_TOTAL)/4));
#endif

    events = new EventQueue();

    // Open channel list
    sdl.channel = new Channel;

    if(!sdl.channel->Open(sdl.channel_list)) {
#if (C_HAVE_WXGUI)
	wxMessageBox(wxString::Format("Unable to open channels list file!\n\n(Filename: '%s')", sdl.channel_list.c_str()),
	    wxT("Error"), wxICON_ERROR | wxOK);
#endif
	QuitProgram(false);
    }

    sdl.channel->SetChannel(sdl.ch_num);

    // Create renderer
    if(!sdl.silent) {
	sdl.renderer = new Renderer(sdl.output_mode);
	if(!sdl.renderer) {
	    ERROR_MSG("Error creating video renderer!");
	    QuitProgram(false);
	}
	sdl.video = sdl.renderer->GetInfo();

	// Initialize screen
	sdl.screen.w = sdl.video->w = 768;
	sdl.screen.h = sdl.video->h = 576;
	SetupScreen(0, 0, false);
	sdl.renderer->ThreadCreate();
	sdl.renderer->SetDeinterlace(sdl.deint_mode);
	sdl_bar.SetDeinterlace(sdl.deint_mode);

	// Initialize audio
	init_audio();
    }

    } catch (const char * c) {
	fprintf(stderr, "[%d] EXCEPTION: %s", SDL_GetTicks(), c);
	QuitProgram(false);
    }

    // Enable key repeats
    SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
    //SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE);

#if (C_HAVE_WXGUI)
    gui.wxTaskBarIcon = new TaskBarIcon();
#endif

    // Main event loop
    while(true) {
	ProcessEvents();

	unsigned int ticks = SDL_GetTicks();
	if((sdl.time) && (ticks > sdl.time)) {
	    // This is GUI signal to quit
	    if(sdl.time == 1) {
		QuitProgram(true);
		continue;
	    }
	    ERROR_MSG("Time is up. Exit.");
	    break;
	}

	if((sdl.keypress.ticks) && (sdl.keypress.ticks + SWITCHDELAY < ticks)) {
	    sdl.keypress.ticks = 0;
	    if(sdl.keypress.channel) sdl.channel->SetChannel(sdl.keypress.channel);
	}

	if((sdl.channelSurfing) && (sdl.channelSurfing + sdl.channelSurfingDelay < ticks)) {
	    sdl.channelSurfing = ticks;
	    sdl.channel->NextChannel();
	}

	if((sdl.hideMouseInFullscreenDelay > 0) && (sdl.screen.fullscreen) &&
	   (SDL_ShowCursor(SDL_QUERY)) && (sdl.lastMouseActivityTicks + sdl.hideMouseInFullscreenDelay < ticks)) {
	    SDL_ShowCursor(SDL_DISABLE);
	}

	SDL_Delay(20);
    }

    QuitProgram(false);

    return 0;
}


void SetupScreen(int w, int h, bool th)
{
    SDL_Rect desktop;

    // Lock video thread
    sdl.renderer->Lock();

    if(sdl.screen.fullscreen) {
#if (SDL_IS_PATCHED)
	if((sdl.screen.x == 0) && (sdl.screen.y == 0)) {
	    SDL_GetWindowPosition(&desktop);
	    sdl.screen.x = desktop.x;
	    sdl.screen.y = desktop.y;
	    desktop.x = desktop.y = 0;
	    desktop.w = desktop.h = 0;
	}
#endif
	if((w == 0) && (h == 0)) {
	    sdl.screen.w = sdl.video->w;
	    sdl.screen.h = sdl.video->h;
	}
	if((GetDesktopMode(&desktop) < 2) && (sdl.hideMouseInFullscreenDelay == 0)) {
	    SDL_ShowCursor(SDL_DISABLE);
	}
	w = desktop.w; h = desktop.h;
    } else if((w == 0) && (h == 0)) {
	w = sdl.screen.w;
	h = sdl.screen.h;
	SDL_ShowCursor(SDL_ENABLE);
    }

    LOG_MSG("Setting video mode %dx%d%s (old: %dx%d)", w, h, sdl.screen.fullscreen ? ", fullscreen" : "",
	sdl.screen.w, sdl.screen.h);

    if(sdl.output_mode == OPENGL) {
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
#if defined (WIN32) && SDL_VERSION_ATLEAST(1, 2, 11)
	SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, 1);
#endif
    }

    if((sdl.video->surface=SDL_SetVideoMode(w, h, 0, SDL_RESIZABLE|SDL_ANYFORMAT|SDL_HWSURFACE|
		((sdl.output_mode == OPENGL) ? SDL_OPENGL : 0) |
		(sdl.screen.fullscreen ?
#ifdef WIN32
		SDL_NOFRAME
#else
		SDL_FULLSCREEN
#endif
		: 0))) == 0) {
	ERROR_MSG("Video mode set failed: %s", SDL_GetError());
	sdl.renderer->Unlock();
	QuitProgram(false);
    }

#if (SDL_IS_PATCHED) && (C_OPENGL)
    // Release OpenGL context
    if(sdl.output_mode == OPENGL) {
	glClearColor(0, 0, 0, 0);
	glClear(GL_COLOR_BUFFER_BIT);
	SDL_GL_SwapBuffers();
	SDL_GL_MakeCurrent(1);
    }
#endif

    // Set video info
    sdl.video->w = w; sdl.video->h = h;
    sdl.video->changed = true;

#ifdef WIN32