Software Público Brasileiro

#include "serviceWindowGeneration.h"

ServiceWindowGeneration::ServiceWindowGeneration() {
    tradutor = new TradutorPortGlosa();
    vetor_pts = new vector<int64_t >();
    numero_legendas = INT_MAX;
    legendas_enviadas = 0;
    this->running = true;
	serviceType = 0;
    DPRINTF("Done!\n");
}

ServiceWindowGeneration::~ServiceWindowGeneration() {
    free(vetor_pts);
    free(path_libras);
    if (inputfile) delete inputfile;
    if (mixer) delete mixer;
    if (tradutor) delete tradutor;
    if (sincronizador) delete sincronizador;
    DDDPRINTF("Service finalized!\n");
}

char* ServiceWindowGeneration::getPathLibras() {
    return path_libras;
}

char* ServiceWindowGeneration::getPathInput() {
    return path_input;
}

string ServiceWindowGeneration::getPathAPI() {
    return PATH_API;
}

char* ServiceWindowGeneration::getClientType(){
    return client_type;
}

char* ServiceWindowGeneration::getUserId() {
    return user_id;
}

void ServiceWindowGeneration::setPathInput(char* _path_input) {
    this->path_input = _path_input;
}

void ServiceWindowGeneration::setClientType(char* client_type) {
    this->client_type = client_type;
}

void ServiceWindowGeneration::setUserId(char* _userId) {
    this->user_id = _userId;
}

void ServiceWindowGeneration::setServiceType(int type) {
	serviceType = type;
}

void ServiceWindowGeneration::setSubLanguage(int sublang){
    this->sublanguage = sublang;
}

void ServiceWindowGeneration::setSize(int size){
	this->size = size;
}

void ServiceWindowGeneration::setPosition(int position){
	this->position = position;
}

void ServiceWindowGeneration::setTransparency(int transparency){
	this->transparency = transparency;
}

void ServiceWindowGeneration::setPathLibras() {
    char* final_path = new char[MAX_SIZE_PATH];
    strcpy(final_path, "vlibras_user/vlibras-api/uploads/");
    strcat(final_path, this->user_id);
    strcat(final_path, "/libras.ts");

    this->path_libras = final_path;
    //DDPRINTF("Path TS File: %s\n", this->path_libras);
}

void ServiceWindowGeneration::setSizeOfSubtitles(int sub_size) {
    numero_legendas = sub_size;
    if (legendas_enviadas >= numero_legendas)
        sincronizador->stop();
}

void ServiceWindowGeneration::adicionaPTS(int64_t pts) {
    vetor_pts->push_back(pts);
}

/* Checado pela subclasse para saber quando o sincronizador terminar. */
bool ServiceWindowGeneration::isRunning() {
    return this->running;
}

/* Quando o sincronizador termina, ele invoca esse método para avisar! */
void ServiceWindowGeneration::notifyEndOfSynchronization() {
    if (serviceType == SERVICE_TYPE_REC || serviceType == SERVICE_TYPE_SRT) {
        mixer = new Mixer();
        mixer->initialize(this->path_input, this->path_libras,this->position,this->size,this->transparency, this->user_id);
        createThumbnail();
    }else{
        transcodeVideoToMp4();
    }
    this->running = false;
}

void ServiceWindowGeneration::initialize() {	

    setPathLibras();

    if (this->sublanguage == 1) {
        tradutor->addListener(this);
    }
	
    // o path do arquivo só poderá conter um "."(ponto), esse identifica a extensão.
    
    vector<string> tokens;
    /* Se for texto não é necessário vídeo de entrada (path_input) */
    if (serviceType != SERVICE_TYPE_TEXT && serviceType != SERVICE_TYPE_SRT_ONLY &&
            serviceType != SERVICE_TYPE_REC_ONLY_AUDIO) {
        char * pathtmp = this->path_input;
    	int size = strlen(pathtmp);
    	char vtemp [size];
    	strcpy(vtemp, pathtmp);
    	pathtmp = strtok(vtemp, ".");
    	while (pathtmp != NULL) {
            tokens.push_back(string(pathtmp));
            pathtmp = strtok(NULL, ".");
    	}
    	string buildstrpath = tokens[0] + "_libras" + EXTENSAO_DICIONARIO;
    	this->path_libras = new char[buildstrpath.size()];
    	strcpy(this->path_libras, buildstrpath.c_str());
        //printf("O ServiceWGeneration montou o seguinte path para o vídeo de Libras: %s\n", path_libras);

    } else {
	   tradutor->addListener(this);
    }
	    
    if(this->transparency == 0) {	//pega dicionario com BackGround opaco
    	sincronizador = new Synchronizer(BASEDIR, EXTENSAO_DICIONARIO, 
            this->path_libras, this->transparency);
    } else { 
    	if(this->transparency == 1) {	//pega dicionario com BackGround transparente
    	   sincronizador = new Synchronizer(BASEDIRTRANSP, EXTENSAO_DICIONARIO,
            this->path_libras,this->transparency);
    	}
    }
    
	if (serviceType != SERVICE_TYPE_SRT) {
		uint64_t pcr_base = (uint64_t) 1000; //FIXME: macro
        sincronizador->setPCRBase(pcr_base);
	}

    sincronizador->addListener(this);
    sincronizador->Start();
}

/* Método utilizado pelo Tradutor para notificar o texto traduzido. */
void ServiceWindowGeneration::notifyTranslation(vector<string> * glosas) {
    if (serviceType != SERVICE_TYPE_TEXT) {
	    for (int i = 0; i < glosas->size(); i++) {
            std::locale loc;
            std::string glosa_lower = "";
            for (int k = 0; k < glosas->at(i).length(); k++)
                glosa_lower += std::tolower(glosas->at(i).at(k), loc);

            //cout << "__Glosa [" << i << "] = " << glosa_lower << endl;
            int64_t pts_notificado = vetor_pts->front();
            sincronizador->recebeglosa(glosa_lower, pts_notificado);
    	}
        /* O 'numero_legendas' é informado pela subclasse através do método setSizeOfSubtitles.
           Então, inicialmente, seu valor corresponde a um número inteiro máximo.
         */
        /*printf("numero_legendas = %d\nlegendas_enviadas = %d\n", numero_legendas, legendas_enviadas);
        if (legendas_enviadas >= numero_legendas) {
	    sincronizador->stop();
	}*/
	vetor_pts->erase(vetor_pts->begin());
    } else {
        //Nova versão!
        for (int i = 0; i < glosas->size(); i++) {
            std::locale loc;
            std::string glosa_lower = "";
            for (int k = 0; k < glosas->at(i).length(); k++)
                glosa_lower += std::tolower(glosas->at(i).at(k), loc);

            //cout << "__Glosa [" << i << "] = " << glosa_lower << endl;
            sincronizador->recebeglosa(glosa_lower, 1000);
        }
        sincronizador->stop();
    }
    legendas_enviadas++;        
}

void ServiceWindowGeneration::transcodeVideoToWebm() {
    //printf("[INFO]: A transcodificação para .webm está ativada!\n");
    DDDPRINTF("[AGUARDE] Transcodificando o vídeo de Libras...\n");
    string command = "ffmpeg -i ";
    command.append(path_libras)
    .append(" -vcodec libvpx -acodec libvorbis ")
    .append(" -v quiet ")
    .append(PATH_API)
    .append(getUserId())
    .append(".webm");
    //printf("[INFO]: Transcodification command -> %s\n", command.c_str());
    system(command.c_str());
}

void ServiceWindowGeneration::transcodeVideoToMp4() {
    if (serviceType == SERVICE_TYPE_TEXT && strcmp(client_type, (char*)"WEB") == 0)
            transcodeVideoToWebm();
    else{
         //printf("[INFO]: A transcodificação para .mp4 está ativada!\n");
        DDDPRINTF("[AGUARDE] Transcodificando o vídeo de Libras...\n");
        string command = "ffmpeg -i ";
        command.append(path_libras)
        .append(" -qscale 0 -strict experimental -vcodec libx264 -preset fast -r 30 ")
        .append(" -v quiet ")
        .append(PATH_API)
        .append(getUserId())
        .append(".mp4");
        //printf("[INFO]: Transcodification command -> %s\n", command.c_str());
        system(command.c_str());

        //.append(" -strict experimental -vcodec mjpeg -r 30 -pix_fmt yuvj422p ")
        //.append(" -strict experimental -vcodec mpeg2video -r 30 ")
    }
}

void ServiceWindowGeneration::createThumbnail(){
    string command = "ffmpeg -ss 10 -i ";
    command.append(PATH_API).append(user_id).append(".mp4")
    .append(" -vcodec png -vframes 1 -an -f rawvideo -y -vf scale=200:200 ")
    .append(" -v quiet ")
    .append(PATH_API).append(user_id).append(".png");
    system(command.c_str());
}