Software Público Brasileiro

/* 
 * File:   main.cpp
 * Author: felipe
 *
 * Created on 15 de Outubro de 2009, 10:56
 */

/* 
 * File:   main.cpp
 * Author: Erickson
 *
 * Edit on 03 de Fevereiro de 2014
 */
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include "logging.h"
#include "argParser.h"
#include "serviceTester.h"
#include "serviceException.h"
#include "serviceWindowGenerationFromSRT.h"
#include "serviceWindowGenerationFromRec.h"
#include "serviceWindowGenerationFromText.h"
#include <lavidlib/base/RuntimeException.h>

#define MAX_SIZE_PATH 256
#define PATH_VBOX_UPLOADS   "vlibras_user/.vlibras-config/uploads"
#define PATH_DEVEL_CONTENTS "vlibras_user/vlibras-contents/videos"
#define PATH_DEVEL_UPLOADS  "vlibras_user/vlibras-contents/uploads"

using namespace std;
using namespace util;

void serviceSRT(int service, string path_video, string path_srt, int language, int position, int size, int background, string id, int mode);
void serviceREC(int service, string path_video, int position, int size, int background, string id, int mode);
void serviceOnlySRT(int service, string path_srt, int language, int background, string id, int mode);
void serviceOnlyAudio(int service, string path_audio, int background, string id, int mode);
void serviceText(string path_text, int language, int background, string id, int mode);
void serviceRECWithoutMixing(int service, string path_video, int background, string id, int mode);
void serviceTest(int position, int size, int background);

void help();
void hasFailed();
void hasInvalid();
void fail(string msg);
void setPathContents(int mode, string id);

bool isFailed;
bool isInvalid;

int main(int argc, char* argv[]) {  

	int service;
	int language;
	int position;
	int size;
	int background;
	int mode;
	int nomixer;

	string input;
	string input_srt;
	string id;

	ArgParser *parser;

	struct timeval tv1, tv2;
	double t1, t2;    

	gettimeofday(&tv1, NULL);
	t1 = (double)(tv1.tv_sec) + (double)(tv1.tv_usec)/ 1000000.00;

	parser = new ArgParser();
	try{
		parser->readArgs(argv, argc);
	}catch(lavidlib::RuntimeException &ex){
		exit(1);
	}

	//printf("\n################## LAViD : VLibras ##################\n\n");

	service = parser->getService();
	util::Logging::instance()->setLevel(parser->getLog());

	switch(service){
		case 1:
			PRINTL(util::_INFO, "Service Type: Video with Subtitles\n");
			input = parser->getInput();
			input_srt = parser->getInputSRT();
			language = parser->getLanguage();
			position = parser->getPosition();
			size = parser->getSize();
			background = parser->getBackground();
			id = parser->getId();
			mode = parser->getMode();
			serviceSRT(service, input, input_srt, language, position, size, background, id, mode);
			break;

		case 2:
			PRINTL(util::_INFO, "Service Type: Video Recognize\n");
			input = parser->getInput();
			position = parser->getPosition();
			size = parser->getSize();
			background = parser->getBackground();
			id = parser->getId();
			mode = parser->getMode();
			serviceREC(service, input, position, size, background, id, mode);
			break;

		case 3:
			PRINTL(util::_INFO, "Service Type: Text\n");
			input = parser->getInput();
			language = parser->getLanguage();
			background = parser->getBackground();
			id = parser->getId();
			mode = parser->getMode();
			serviceText(input, language, background, id, mode);
			break;

		case 4:
			PRINTL(util::_INFO, "Service Type: Subtitles only\n");
			input = parser->getInput();
			language = parser->getLanguage();
			background = parser->getBackground();
			id = parser->getId();
			mode = parser->getMode();
			serviceOnlySRT(service, input, language, background, id, mode);
			break;

		case 5: //reconhecimento de audio
			PRINTL(util::_INFO, "Service Type: Audio Recognize\n");
			input = parser->getInput();
			background = parser->getBackground();
			id = parser->getId();
			mode = parser->getMode();
			serviceREC(service, input, 0, 0, background, id, mode);
			break;

		case 6: //Reconhecimento de video sem mixagem
			PRINTL(util::_INFO, "Service Type: Video Recognize (Mixer Disabled)\n");
			input = parser->getInput();
			background = parser->getBackground();
			id = parser->getId();
			mode = parser->getMode();
			serviceREC(service, input, 0, 0, background, id, mode);//como service != 2 então não há mixagem
			break;

		case 7: // serviço de teste
			position = parser->getPosition();
			size = parser->getSize();
			background = parser->getBackground();
			serviceTest(position, size, background);
			break;

		case 8: //ajuda
			help();
			break;

		default:
			PRINTL(util::_ERROR, "Opção de serviço não reconhecida!\n");
			hasInvalid();
	}

	if(isFailed)
		exit(1);
	else if(isInvalid)
		exit(127);

	gettimeofday(&tv2, NULL);
	t2 = (double)(tv2.tv_sec) + (double)(tv2.tv_usec)/ 1000000.00;
	PRINTL(util::_DEBUG, "Time: %lf\n", (t2-t1));
	PRINTL(util::_INFO, "VLibras finalized!\n\n");
	exit(0);
}

void serviceSRT(int service, string path_video, string path_srt, int language, int position, int size, int background, string id, int mode){
	char* video = new char[MAX_SIZE_PATH];
	char* srt = new char[MAX_SIZE_PATH];
	char* name = new char[64];

	strcpy(video, path_video.c_str());
	strcpy(srt, path_srt.c_str());
	strcpy(name, id.c_str());

 	setPathContents(mode, id);

	ServiceWindowGenerationFromSRT* service_srt;
	service_srt = new ServiceWindowGenerationFromSRT(video, srt, language, position, size, background, name, mode, service);
	
	try{
		service_srt->initialize();
	}catch(ServiceException ex){
		fail(ex.getMessage());
		hasFailed();
		return;
	}		    
	while(!service_srt->isFinished()){
        sleep(5);
	}

	delete [] video;
	delete [] srt;
	delete [] name;
	delete service_srt;
}

void serviceREC(int service, string path_video, int position, int size, int background, string id, int mode){
	char* video = new char[MAX_SIZE_PATH];
	char* name = new char[64];

	strcpy(video, path_video.c_str());
	strcpy(name, id.c_str());

 	setPathContents(mode, id);

	ServiceWindowGenerationFromRec* service_rec;
	service_rec = new ServiceWindowGenerationFromRec(video, position, size, background, name, mode, service);
	
	try{
		service_rec->initialize();
	}catch(ServiceException ex){
		fail(ex.getMessage());
		hasFailed();
		return;
	}	
	while(!service_rec->isFinished()){
        sleep(5);
	}

	delete [] video;
	delete [] name;
	delete service_rec;
}

void serviceText(string path_text, int language, int background, string id, int mode){
	char* text = new char[MAX_SIZE_PATH];
	char* name = new char[64];

	strcpy(text, path_text.c_str());
	strcpy(name, id.c_str());

	setPathContents(mode, id);

	ServiceWindowGenerationFromText* service_text;
    service_text = new ServiceWindowGenerationFromText(text, language, background, name, mode);

    try{
        service_text->initialize();
    }catch(ServiceException ex){
        fail(ex.getMessage());
        hasFailed();
        return;
    }
        
    while (!service_text->isFinished()) {
        usleep(100000); //100ms
    }

    delete [] text;
	delete [] name;
    delete service_text;
}

void serviceOnlySRT(int service, string path_srt, int language, int background, string id, int mode){
	char* srt = new char[MAX_SIZE_PATH];
	char* name = new char[64];

	strcpy(srt, path_srt.c_str());
	strcpy(name, id.c_str());

	setPathContents(mode, id);

	ServiceWindowGenerationFromSRT* service_srt;
	service_srt = new ServiceWindowGenerationFromSRT(srt, language, background, name, mode, service);		
	try{
		service_srt->initialize();
	}catch(ServiceException ex){		
		fail(ex.getMessage());
		hasFailed();
		return;
	}

    while (!service_srt->isFinished()) {
		usleep(100000);	//100ms
	}

	delete [] srt;
	delete [] name;
	delete service_srt;
}

void serviceTest(int position, int size, int background) {
	ServiceTester* service_t;
	service_t = new ServiceTester(position, size, background);
	try{
		service_t->Start();
	}catch(ServiceException &ex){
		fail(ex.getMessage());
		hasFailed();
		return;
	}

	while (!service_t->isFinished()) {
		sleep(5);
	}
	delete service_t;
}

void fail(string msg){
	PRINTL(util::_ERROR, "\nOps... Tivemos um problema! :(\n");
	PRINTL(util::_ERROR, "Possível causa do erro: %s\n\n", msg.c_str());
}

void hasFailed(){
	isFailed = true; 
}

void hasInvalid(){
	isInvalid = true;
}

void setPathContents(int mode, string id){
	string command = "mkdir -p ";
	switch(mode){
		case 1://devel
			char* vlStorage;
	        char* vlUploads;
	        vlStorage = getenv("VLSTORAGE");
	        vlUploads = getenv("VLUPLOADS");

	        if(vlStorage == NULL || vlUploads == NULL){
				command.append(PATH_DEVEL_CONTENTS).append(" && mkdir -p ")
				.append(PATH_DEVEL_UPLOADS).append("/").append(id);
				system(command.c_str());
	        }
	    break;

	    case 2://produção
	    	command.append(PATH_VBOX_UPLOADS).append("/").append(id);
	    	system(command.c_str());
	    	break;

	    default:
		    fail("Modo de execução não reconhecido!");
			exit(127);
	}
}

void help()
{
	std::cout << std::endl
	<< "Usage Summary: vlibras [Service_option] filepath [Options] --id [name] --mode [devel,prod]"
	<< "\n\nService_option:"
	<< "\n\tVideo with Subtitles -V, --video [filePath] -S, --subtitle [filePath]"
	<< "\n\tVideo Recognize      -V, --video [filePath]"
	<< "\n\tAudio Recognize      -A, --audio [filepath]"
	<< "\n\tText                 -T, --text  [filePath]"
	<< "\n\tSubtitles only       -S, --subtitle [filePath]"
	<< "\n\nOptions:"
	<< "\n\t-l, --language   [portugues,glosa]"
	<< "\n\t-b, --background [opaque,transp]"
	<< "\n\t-r, --resolution [small,medium,large]"
	<< "\n\t-p, --position   [top_left,top_right,bottom_left,bottom_right]"
	<< "\n\t-m, --mode       [devel,prod]"
	<< "\n\t-v, --loglevel   [quiet,error,warning,info,debug]"
	<< "\n\t--id [name]      Relative to the unique ID on the Database."
	<< "\n\t--no-mixer       Disables mixing with the original video."
	<< "\n\nSee man vlibras for detailed descriptions."
	<< std::endl;
	exit(0);
}