test.cpp

// RadioClient get and storage the meta data and the media from a server
// Copyright (C) 2010-2026 Maxim Zakharov
//
// 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 as the file license.txt. If not, see
// <http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt>
// test mplayer auto start
// -forceidx

#include <iostream>
#include <algorithm>
#include <fstream>
#include <ctime>
#include <stdlib.h>
#include <sys/wait.h>
#include "molib/dir.hpp"
#include "molib/rmtime.hpp"
#include "molib/vol.hpp"
#include "molib/version.hpp"
#include "molib/mpversion.hpp"
#include "molib/allpls.hpp"
//#include "molib/mpjpls.hpp"
#include "molib/mppls.hpp"
#include "molib/rmfiles.hpp"
//#define DBG
//#define DBG1
//#define DBGCMPTT
//#define DBGREBOOT
//#define TIMEDBG

#define UPDATEDIR "./update/"
#define FUPDATE     "FILEUPDATE"
#define FNFUPDATE   UPDATEDIR"FILEUPDATE"
#define UDOWNLOADED "DOWNLOADED"
#define FNUDOWNLOADED UPDATEDIR"DOWNLOADED"
#define FUEXIT      "MAINEXIT"
#define FNFUEXIT    UPDATEDIR"MAINEXIT"

#define FUPDATEP     "FILEUPDATEPLAYER"
#define FNFUPDATEP   UPDATEDIR"FILEUPDATEPLAYER"
#define UDOWNLOADEDP "DOWNLOADEDPLAYER"
#define FNUDOWNLOADEDP UPDATEDIR"DOWNLOADEDPLAYER"
#define FUEXITP      "PLAYEREXIT"
#define FNFUEXITP    UPDATEDIR"PLAYEREXIT"

#define TASKDIR  "./task/"
#define TDIRPROGRESS   TASKDIR"PROGRESS/"
#define TDIRREPORTED   TASKDIR"REPORTED/"

const
  std::string
  CTASKDIR = "./task/";
const
  std::string
  VOL_DOWN = "./mp/vol_down.sh";

//const std::string LOGDIR      = "./log/";
//const std::string LMPREBOOT   = LOGDIR + "mp_reboot.log";
//const std::string LCREBOOT    = LOGDIR + "count_reboot.log";


//const std::string MVOL      =      CTASKDIR + "MUSIC_VOL";
//const std::string JVOL      =      CTASKDIR + "JINGL_VOL";
//const std::string VOLSOFDAY =      CTASKDIR + "VOLSOFDAY";

//const std::string wdays = "0123456";


#define DIRPLS "./pls/"
//const std::string BDIRPLS = "./pls";
//const std::string EDIRPLS = "/";
#define EXTPLS ".pls"

#define FNBEGINENDTIME "./betime.rm"

void
create_ff2one_mp4 ()
{
  std::ofstream ofile;

  std::string arg1 = "./scripts/ff2one_mp4.sh";

  ofile.open (arg1.c_str ());
  ofile << "#!/bin/sh" << std::endl;
  ofile << "DAY=$1" << std::endl;
  ofile << "TIME=$2" << std::endl;
  ofile << "if [ -f \"/home/uid0001/pls$DAY/$TIME.pls\" ]; then " <<
    std::endl;
  ofile <<
    "  MP4NAME=`grep File ~/pls$DAY/$TIME.pls | grep 'mp4$' | sed s/^.*upload.//  | awk '!x[$0]++' | tr -d '\\n' | sed \"s|^|/home/uid0001/upload/|\" | sed s/$/.mp4/`"
    << std::endl;
  ofile <<
    "  COUNTLINE=`grep 'File' ~/pls$DAY/$TIME.pls | grep 'mp4$' | sed s/^.*=//g | awk '!x[$0]++' | wc -l | awk '{print $1}'`"
    << std::endl;
  ofile << "  ZZZ=1" << std::endl;
  ofile << "  if [ \"$COUNTLINE\" -gt \"$ZZZ\" ]; then" << std::endl;
  ofile <<
    "    TSNAME=`grep File ~/pls$DAY/$TIME.pls | grep 'mp4$' | sed s/$/.ts/ | sed s/^File.*=........./\"|\\/home\\/uid0001\\/ts\"/ | awk '!x[$0]++' | tr -d '\\n' | sed s/^.//`"
    << std::endl;
//    ofile << "  MP4NAME=`grep File ~/pls$DAY/$TIME.pls | grep 'mp4$' | sed s/^.*upload.// | tr -d '\\n' | sed \"s|^|/home/uid0001/upload/|\" | sed s/$/.mp4/`" << std::endl;
  ofile << "    if [ ! -f \"$MP4NAME\" ]" << std::endl;
  ofile << "    then" << std::endl;
  ofile <<
    "      ffmpeg -y -v quiet -i concat:\"$TSNAME\" -vcodec copy -acodec copy -vbsf:a aac_adtstoasc $MP4NAME 2>/tmp/ffmpeg.log"
    << std::endl;
  ofile << "    fi" << std::endl;
  ofile << "  else" << std::endl;
  ofile << "    if [ \"$COUNTLINE\" -eq \"$ZZZ\" ]; then" << std::endl;
  ofile << "      ln -f -s `echo $MP4NAME | sed 's/.mp4$//'` $MP4NAME" <<
    std::endl;
  ofile << "    fi" << std::endl;
  ofile << "  fi" << std::endl;
  ofile << "  ln -f -s $MP4NAME /home/uid0001/ts$DAY/$TIME.mp4" << std::endl;
  ofile << "fi" << std::endl;
  ofile.close ();
}

void
ffmpeg_pls_2_one_file_link (const std::string & time,
			    const unsigned int &wday)
{
  std::ofstream ofile;

  std::string arg1 = "./scripts/run_ff2one_mp4.sh";

  ofile.open (arg1.c_str ());
  ofile << "#!/bin/sh" << std::endl;
  ofile << "chmod +x ~/scripts/ff2one_mp4.sh" << std::endl;
  ofile << "~/scripts/ff2one_mp4.sh " << wday << " " << time << std::endl;
  ofile.close ();

  pid_t
    child;
  std::string exec_name;

  exec_name = "/bin/sh";

  if (!(child = fork ()))
    {
      execlp (exec_name.c_str (), exec_name.c_str (), arg1.c_str (), NULL);
      exit (0);
    }				//child
  wait (0);
}

void
sieve (const std::string & fnames)
{
  std::ifstream ifile;
  std::ofstream ofile;

  std::string mp3name;
  std::vector < std::string > files;

  bool
    fignore;

  ifile.open (fnames.c_str ());
  while (ifile.good ())
    {
      std::getline (ifile, mp3name);
      fignore = false;

      for (unsigned int index = 0; index < files.size (); index++)
	if (mp3name.size () > 9)
	  if (files[index].find (mp3name.substr (mp3name.find_last_of ('/')))
	      != std::string::npos)
	    fignore = true;

      if (!fignore)
	{
	  if (mp3name.size () > 9)
	    files.push_back (mp3name);
	}
    }
  ifile.close ();

  ofile.open (fnames.c_str ());
  //  ofile << "[playlist]" << std::endl; // FIXME --ERROR why work without this line
  for (unsigned int index = 0; index < files.size (); index++)
    ofile << files[index] << std::endl;
  ofile.close ();
}

void
create_rep_overflow_block (std::string runtime, std::string runtime_next,
			   unsigned int sumsec)
{
  std::ofstream ofmsg;

  ofmsg.open ("./task/REPORTED/overflow_block.pxml",
	      std::ios::out | std::ios::app);
  ofmsg <<
    "<RUNTIME>2013-02-10 15:00:00</RUNTIME><TEXT>Блок по времени"
    << runtime << ", следующий " << runtime_next <<
    ", переполнение блока на " << sumsec -
    (to_sec ("2013-02-12 " + runtime_next) -
     to_sec ("2013-02-12 " +
	     runtime)) << " секунд.</TEXT>" << std::endl;
  ofmsg.close ();
}

std::map < std::string, std::string > mlines4h (const std::string & fn)
{
  std::map < std::string, std::string > res;
  std::ifstream ifile;
  std::string tmp;

  ifile.open (fn.c_str ());
  while (ifile.good ())
    {
      std::getline (ifile, tmp);
      if (tmp.length () > 34)
	res[tmp.substr (0, 32)] = tmp.substr (34);
    }
  ifile.close ();

  return res;
}

std::map < std::string, int >
mlines4inverted (const std::string & fn)
{
  std::map < std::string, int >
    res;
  std::ifstream ifile;
  std::string tmp;

  ifile.open (fn.c_str ());
  while (ifile.good ())
    {
      std::getline (ifile, tmp);
      if (tmp.length () > 34)
	{
	  std::size_t found = tmp.find ('|');
	  if (found != std::string::npos && found < tmp.length ())
	    res[tmp.substr (found + 1)] =
	      atoi (tmp.substr (0, found).c_str ());
	}
    }
  ifile.close ();

  return res;
}

std::multimap < std::string, std::string > mlines4p (const std::string & fn)
{
  std::multimap < std::string, std::string > res;
  std::ifstream ifile;
  std::string tmp;

  ifile.open (fn.c_str ());
  while (ifile.good ())
    {
      std::getline (ifile, tmp);
      if (tmp.length () > 10)
	{
	  std::size_t found = tmp.find ('.');
	  if (found != std::string::npos && found < tmp.length ())
	    {
	      res.insert (std::make_pair (tmp.substr (found + 1),
					  tmp.substr (0, found)));
	    }
	}
    }
  ifile.close ();

  return res;
}

void
gen_pls_by_weight (const std::string & fplsname)
{
  std::map < std::string, std::string > hashs, names;
  std::map < std::string, int >
    inverted_weight;
  std::multimap < int,
    std::string >
    nweight;
  int
    weight;

  inverted_weight = mlines4inverted ("weight.rm");

  hashs = mlines4h (HASHNAME);

  for (std::map < std::string, std::string >::iterator it = hashs.begin ();
       it != hashs.end (); ++it)
    names[it->second] = it->first;

  std::multimap < std::string, std::string > pls;
  pls = mlines4p (fplsname);

  for (std::map < std::string, std::string >::iterator orig_name =
       hashs.begin (); orig_name != hashs.end (); ++orig_name)
    for (std::map < std::string, std::string >::iterator it = pls.begin ();
	 it != pls.end (); ++it)
      if (it->first.find (orig_name->second.substr (9)) != std::string::npos)
	{
	  weight = 50;
	  weight = inverted_weight[names[orig_name->second]];
	  if (0 == weight)
	    weight = 50;
	  nweight.insert (std::make_pair
			  (weight,
			   it->second + "." + it->first));
	}

  std::ofstream plsfile;
  plsfile.open (fplsname.c_str ());

  for (std::map < int, std::string >::reverse_iterator it = nweight.rbegin ();
       it != nweight.rend (); ++it)
    plsfile << it->second << std::endl;

  plsfile.close ();
}

std::vector < std::string > get_mpfiles (const std::string & fplsname)
{
  std::vector < std::string > result;
  std::ifstream ifpls;
  std::string temp_str;

  gen_pls_by_weight (fplsname);

  ifpls.open (fplsname.c_str ());
  while (ifpls.good ())
    {
      std::getline (ifpls, temp_str);
      if (temp_str.size () > 5)
	if (temp_str.substr (0, 4) == "File")
	  if (temp_str.find_last_of ('/') != std::string::npos)
	    if (temp_str.find_last_of ('/') + 1 < temp_str.size ())
	      result.push_back (temp_str.
				substr (temp_str.find_last_of ('/') + 1));
    }
  ifpls.close ();


  return result;
}

std::string get_mpftype (const std::string & filename)
{
  std::string result, name;

  result = "audio";

  name = "mp3";

  if (filename.find_last_of (".") != std::string::npos)
    if (filename.size () >= 4
	&& filename.size () - 4 == filename.find_last_of ("."))
      {
	name = filename.substr (filename.find_last_of (".") + 1, 3);
      }
  if (name == "avi" || name == "mpg")
    result = "video";

  return result;
}

void
next_all_pls (int second)
{
  std::string fn, temp_str;
  fn = "./pls/all.pls";
  std::vector < std::string > vpls, nvpls;
  std::ifstream ifpls;
  std::ofstream ofpls;

  ifpls.open (fn.c_str ());

  while (ifpls.good ())
    {
      std::getline (ifpls, temp_str);
      if (temp_str.size () > 0)
	vpls.push_back (temp_str);
    }
  ifpls.close ();

  unsigned int cuptime;
  cuptime = (second / AVGTIMETRACK) + 1;	//FIXME may be error

  for (unsigned int i = cuptime; i < vpls.size (); i++)
    nvpls.push_back (vpls[i]);
  for (unsigned int i = 0; (i < cuptime) && (i < vpls.size ()); i++)
    nvpls.push_back (vpls[i]);

  ofpls.open (fn.c_str ());
  for (unsigned int i = 0; i < nvpls.size (); i++)
    ofpls << nvpls[i] << std::endl;
  ofpls.close ();
}

void
mp_reboot ()
{
  create_reboot ("./scripts/reboot.sh");

  std::string fnscript;
  fnscript = "./scripts/mp_reboot.sh";

  pid_t child;
  std::string exec_name;

  exec_name = "/bin/sh";

  if (!(child = fork ()))
    {
      execlp (exec_name.c_str (), exec_name.c_str (), fnscript.c_str (),
	      NULL);
      exit (0);
    }				//child
  wait (0);
}

void
save_vol (const std::string & fname, const std::string & master)
{
  std::string vol;

  vol = line4 (fname);

  if ((vol.length () > 0) && (vol.find (':') != std::string::npos))
    saven2 (fname, master + vol.substr (vol.find (':')));
}

void
set_vols (const std::string & master)
{
  save_vol (JVOL, master);
  save_vol (MVOL, master);
}

void
change_vols (const std::string & time)
{

  if (time.length () > 0)
    {

      std::ifstream ifile;

      std::string timevol;
      std::vector < std::string > timevols;

      ifile.open (FVOLSOFDAY.c_str ());
      while (ifile.good ())
	{
	  std::getline (ifile, timevol);
	  if (timevol.length () > 0)
	    timevols.push_back (timevol);
	}
      ifile.close ();

      for (unsigned int i = 0; i < timevols.size (); i++)
	if (timevols[i].length () > 8 && time == timevols[i].substr (0, 8)
	    && timevols[i].find (';') != std::string::npos)
	  set_vols (timevols[i].substr (timevols[i].find (';') + 1));	//FIXME time = "" & timesvols[i]="" [error in] find + 1 >= length() //!NEW, fail, timevols verify of emty in time read from file of upper while
    }
}


void
create_isunmute ()
{
  std::string fname, fnscript;
  std::ofstream ofile;

  fname = "./mstate";		//FIXME adding in const.hpp
  fnscript = "./mscript.sh";	//FIXME adding in const.hpp

  ofile.open (fnscript.c_str ());
  ofile << "#!/bin/sh" << std::endl;
  ofile << "amixer get " << gsmaster () << " | tail -n 1 > " << fname << std::endl;	//FIXME add in script on all line "2> to error_file.log
  //  ofile << "amixer get " << gshphone() << " | tail -n 1 >> " << fname << std::endl;//FIXME add in script on all line "2> to error_file.log
  //  ofile << "amixer get " << gspcm() << " | tail -n 1 >> " << fname << std::endl;//FIXME add in script on all line "2> to error_file.log
  ofile.close ();
}

bool
isunmute ()
{
  std::string fname, fnscript;

  fname = "./mstate";		// FIXME need add in const.hpp
  fnscript = "./mscript.sh";	//FIXME need add in const.hpp

  pid_t child;
  std::string exec_name;

  exec_name = "/bin/sh";

  if (!(child = fork ()))
    {
      execlp (exec_name.c_str (), exec_name.c_str (), fnscript.c_str (),
	      NULL);
      exit (0);
    }				//child
  wait (0);

  bool result;
  result = false;

  std::string tmp_mute;
  std::ifstream ifile;

  ifile.open (fname.c_str ());
  while (ifile.good ())
    {
      std::getline (ifile, tmp_mute);
      if (tmp_mute.length () > 3)
	if (tmp_mute.find ("[on]") != std::string::npos)
	  result = true;
    }
  ifile.close ();

  //  std::cout << "___________________" << tmp_mute << std::endl;


  return result;
}

void
activate_track_of_ntask (const std::string & idtask, const unsigned int &wday)
{
  std::vector < std::string > tasks, sname, vfnsourcename;
  std::string fname, plsname, vfnpls, fnamesource, singlesname;
  std::ifstream ifname, ifpls, ifsource;
  std::ofstream ofpls, ofsource;


  tasks = ls (TDIRPROGRESS);
  for (unsigned int i = 0; i < tasks.size (); i++)
    {
      if (idtask == tasks[i].substr (tasks[i].find_last_of ('_') + 1))
	{			//FIXME  error for substr(find_last_of+1), findlastof maybe std::string::npos or last element in string and +1 out of range OR if circle in begin

	  //delete_task_of_npls(task.vdelid[i]);//FIXME CLEAR ALL PLS FROM THIS file.open(task[i])

	  fname = TDIRPROGRESS + tasks[i];
#ifdef DBG
	  //std::cout << fname << std::endl;
#endif //DBG

	  ifname.open (fname.c_str ());
	  while (ifname.good ())
	    {
	      std::getline (ifname, plsname);	// FIXME никаких проверок не сделано, основано на услов
	      if (plsname.length () > 3 && plsname.find (".pls") != std::string::npos)	//FIXME mayby need add nowtime in find .pls => find 00:00:00.pls
		vfnpls = plsname;
	    }
	  ifname.close ();

	  fnamesource =
	    BDIRPLS + WDAYS[wday] + EDIRPLS + tasks[i].substr (0, 8) + EXTPLS;
#ifdef DBG
	  //      std::cout << fnamesource << std::endl;
#endif //DBG

	  ifsource.open (fnamesource.c_str ());
	  vfnsourcename.clear ();
	  while (ifsource.good ())
	    {
	      std::getline (ifsource, singlesname);	// FIXME никаких проверок не сделано, основано на услов
	      if (singlesname.size () > 11)
		{		// FIXME [playlist] was 10, but '[playlist]'.length() == 10, may be need return 10, and rewrite test program of down
#ifdef DBG
		  //      std::cout << singlesname << ": -singlesname- :"<< singlesname.substr(singlesname.find("=")+1+9) << std::endl;
#endif //DBG

		  if (vfnpls.find
		      (singlesname.substr (singlesname.find ("=") + 1 + 9)) ==
		      std::string::npos)
		    {
		      if (singlesname.substr (0, 7) == "Title1=")
			vfnsourcename.push_back (singlesname);
		      else
			{
			  vfnsourcename.push_back (singlesname.substr
						   (singlesname.find ("=") +
						    1));
#ifdef DBG
			  //              std::cout << singlesname.substr(singlesname.find("=")+1) << std::endl << std::endl;
#endif //DBG

			}
		    }
		  else
		    {
		      vfnsourcename.push_back (singlesname.substr
					       (singlesname.find ("=") + 1));
#ifdef DBG
		      //              std::cout << singlesname.substr(singlesname.find("=")+1) << std::endl << std::endl;
#endif //DBG
		    }
		}
#ifdef DBG
	      //std::cout << "<End>" << std::endl << std::endl;
#endif //DBG
	    }
	  ifsource.close ();

#ifdef DBG
	  //std::cout << "task[i] = "<< tasks[i] << std::endl;
#endif //DBG

	  if (vfnsourcename.size () > 0)
	    {
	      ofsource.open (fnamesource.c_str ());
	      if (ofsource.good ())
		{
		  ofsource << "[playlist]" << std::endl;	// FIXME [playlist] was 10, but '[playlist]'.length() == 10, mey be need return 10 and rewrite test program of down
		  for (unsigned int m = 0, count = 1;
		       m < vfnsourcename.size (); m++)
		    {
		      if (vfnsourcename[m].length () > 7)
			{
			  if (vfnsourcename[m].substr (0, 7) == "Title1=")
			    ofsource << vfnsourcename[m] << std::endl;
			  else
			    ofsource << "File" << count++ << "=" <<
			      vfnsourcename[m] << std::endl;
			}
		    }
		  //FIXME else error message
		}
	      ofsource.close ();
	    }
	  //      else { // FIXME MAYBE ERROR !!!!!!!!!!!!!!!!!!!!!!!!!!!---------------------- ERROR --------------- and so, what would you do with task
	  //        unlink(fnamesource.c_str());
	  //      }
	}
    }
#ifdef DBG
  std::cout << "Out of activate_tracks." << std::endl << std::endl;
#endif //DBG
}

void
delete_task_of_ntask (const std::string & idtask)
{
  std::vector < std::string > tasks, sname, vfnsourcename;
  std::set < std::string > deleted_tracks;
  std::string fname, plsname, vfnpls, fnamesource, singlesname;
  std::ifstream ifname, ifpls, ifsource;
  std::ofstream ofpls, ofsource;
  //  std::ofstream oflogdel;
  //  const std::string fnlogdel = "./log/plsdel.log";

  tasks = ls (TDIRPROGRESS);
  for (unsigned int i = 0; i < tasks.size (); i++)
    {
      if (idtask == tasks[i].substr (tasks[i].find_last_of ('_') + 1))
	{			//FIXME  error for substr(find_last_of+1), findlastof maybe std::string::npos or last element in string and +1 out of range OR if circle in begin

	  //delete_task_of_npls(task.vdelid[i]);//FIXME CLEAR ALL PLS FROM THIS file.open(task[i])

	  fname = TDIRPROGRESS + tasks[i];
#ifdef DBG
	  std::cout << fname << std::endl;
#endif //DBG

	  ifname.open (fname.c_str ());
	  while (ifname.good ())
	    {
	      std::getline (ifname, plsname);
	      if (plsname.length () > 3
		  && plsname.find (".pls") != std::string::npos)
		vfnpls = plsname;
	    }
	  ifname.close ();

	  for (unsigned int wday = 0; wday < WDAYS.size (); wday++)
	    {
	      fnamesource =
		BDIRPLS + WDAYS[wday] + EDIRPLS + tasks[i].substr (0,
								   8) +
		EXTPLS;
#ifdef DBG
	      std::cout << fnamesource << std::endl;
#endif //DBG

	      //      oflogdel.open(fnlogdel.c_str(), std::ios::out | std::ios::app);
	      //      oflogdel << "Open: " << fnamesource << ", task: " << idtask << std::endl;
	      //      oflogdel.close();

	      ifsource.open (fnamesource.c_str ());
	      vfnsourcename.clear ();
	      while (ifsource.good ())
		{
		  std::getline (ifsource, singlesname);	// FIXME никаких проверок не сделано, основывано на услов
		  if (singlesname.size () > 11)
		    {		// FIXME [playlist] was 10, but '[playlist]'.length() == 10, mey be need return 10 and rewrite test program of down
#ifdef DBG
		      std::cout << singlesname << ": -singlesname- :" <<
			singlesname.substr (singlesname.find ("=") + 1 +
					    9) << std::endl;
#endif //DBG

		      if (vfnpls.find
			  (singlesname.substr
			   (singlesname.find ("=") + 1 + 9)) ==
			  std::string::npos)
			{
			  vfnsourcename.push_back (singlesname);

#ifdef DBG
			  std::cout << "add : " << singlesname << std::endl;
#endif //DBG
			}
		      else
			{
			  deleted_tracks.insert (singlesname.substr
						 (singlesname.find ("=") + 1 +
						  9));
			}
		      //{
		      //              oflogdel.open(fnlogdel.c_str(), std::ios::out | std::ios::app);
		      //              oflogdel << "IDtask: " << idtask << ", task[i]: " << tasks[i] << std::endl;
		      //              oflogdel << "Find to del: " << fnamesource << "::" << singlesname << " in " << vfnpls << std::endl;
		      //              oflogdel.close();
		      //}
		    }
#ifdef DBG
		  std::cout << "<End>" << std::endl << std::endl;
#endif //DBG
		}		//while
	      ifsource.close ();

#ifdef DBG
	      std::cout << "task[i] = " << tasks[i] << std::endl;
#endif //DBG
	      //oflogdel.open(fnlogdel.c_str(), std::ios::out | std::ios::app);
	      //oflogdel << "Count string:" << vfnsourcename.size() << std::endl;
	      //oflogdel.close();

	      if (vfnsourcename.size () > 0)
		{
		  ofsource.open (fnamesource.c_str ());
		  if (ofsource.good ())
		    {
		      ofsource << "[playlist]" << std::endl;	// FIXME [playlist] was 10, but '[playlist]'.length() == 10, mey be need return 10 and rewrite test program of down
		      for (unsigned int m = 0; m < vfnsourcename.size (); m++)
			ofsource << vfnsourcename[m] << std::endl;
		      //FIXME else error message
		    }
		  ofsource.close ();
		}
	      else
		{
		  unlink (fnamesource.c_str ());
      std::string cleanTsFile = "./ts" + WDAYS[wday] + EDIRPLS + tasks[i].substr (0,8) + ".mp4";
      unlink(cleanTsFile.c_str());
		  //oflogdel.open(fnlogdel.c_str(), std::ios::out | std::ios::app);
		  //oflogdel << "Remove: " << fnamesource << std::endl;
		  //oflogdel.close();
		}
	    }			//fow wday

	  fname = TDIRPROGRESS + tasks[i];
	  unlink (fname.c_str ());

	  std::string srmfc;
	  srmfc.clear ();
	  std::ifstream rmfc;
	  rmfc.open (("./pls/" + idtask + ".auto.del").c_str ());
	  while (rmfc.good ())
	    {
	      std::getline (rmfc, srmfc);
	      if (srmfc.length () > 0)
		unlink (srmfc.c_str ());
	    }
	  rmfc.close ();
	  unlink (("./pls/" + idtask + ".auto.del").c_str ());
	}			//if idtask ==
    }				//for i

  std::string pxml;
  for (std::set < std::string >::const_iterator track =
       deleted_tracks.begin (); track != deleted_tracks.end (); ++track)
    pxml =
      atag (RUNTIME, "2013-03-29 14:00:00") + atag (TEXT,
						    "Удален с эфира: "
						    + *track);

  save2 (FWEBRUN, pxml);

#ifdef DBG
  std::cout << "Out of del_ntask." << std::endl << std::endl;
#endif //DBG
}

void
cmp_endtime_range (time_t rawtime, std::string endtime, std::string task_id)
{
#ifdef DBG
  std::cout << rawtime << " >= " << to_sec (endtime) << std::endl;
#endif //DBG

  if (rawtime >= to_sec (endtime))
    {
      delete_task_of_ntask (task_id);

#ifdef DBG
      std::cout << "Delete: " << task_id <<
	"------------------------------------------------------" << std::endl;
#endif //DBF
    }
}

void
cmp_begintime_range (time_t rawtime, std::string begintime,
		     std::string task_id, const unsigned int &wday)
{
#ifdef DBG
  std::cout << rawtime << ">=" << to_sec (begintime) <<
    "COMPARE TIME ++++++++++++++++++++++++++++++" << std::endl;
#endif //DBG

  if (rawtime >= to_sec (begintime))
    {
      activate_track_of_ntask (task_id, wday);

#ifdef DBG
      std::cout << "May be activate tracks of task: " << task_id << std::endl;
#endif //DBF
    }
}

void
cmp_task_time (std::vector < std::string > vtask_id, time_t rawtime,
	       const unsigned int &wday)
{
  std::ifstream itbeginend;
  std::string fname, sourceline;
  std::vector < std::string > vsourceline;

  //  time_t now_datetime;
  //  struct tm timeinfo;

  //  now_datetime = mktime(&timeinfo);

#ifdef DBGCMPTT
  std::cout << "Begin cmp_task_time: ######################################"
    << std::endl;
#endif //DBG

  fname = FNBEGINENDTIME;
  itbeginend.open (fname.c_str ());
  while (itbeginend.good ())
    {
      std::getline (itbeginend, sourceline);
      if (sourceline.length () > 2)
	{
	  vsourceline.push_back (sourceline);
#ifdef DBG
	  //      std::cout << sourceline << std::endl;
#endif //DBG
	}
    }
  itbeginend.close ();
  for (unsigned int j = 0; j < vtask_id.size (); j++)
    {
      for (unsigned int i = 0; i < vsourceline.size (); i++)
	{
#ifdef DBGCMPTT
	  std::cout << "cmp_task_time i,j:" << i << ", " << j << std::endl;
#endif //DBG

	  if (vtask_id[j] ==
	      vsourceline[i].substr (0, vsourceline[i].find (';')))
	    {
#ifdef DBGCMPTT
	      std::cout << vsourceline[i].substr (0,
						  vsourceline[i].find (';'))
		<< " ---- " << vsourceline[i].
		substr (vsourceline[i].find (';') + 1,
			vsourceline[i].find_last_of (';') -
			vsourceline[i].find (';') -
			1) << " ---- " << vsourceline[i].
		substr (vsourceline[i].find_last_of (';') + 1) << std::endl;
#endif //DBG

	      if (vsourceline[i].substr (vsourceline[i].find (';') + 1,
					 vsourceline[i].find_last_of (';') -
					 vsourceline[i].find (';') -
					 1).length () > 0)
		cmp_begintime_range (rawtime,
				     vsourceline[i].substr (vsourceline[i].
							    find (';') + 1,
							    vsourceline[i].
							    find_last_of (';')
							    -
							    vsourceline[i].
							    find (';') - 1),
				     vtask_id[j], wday);

	      if (vsourceline[i].substr
		  (vsourceline[i].find_last_of (';') + 1).length () > 0)
		cmp_endtime_range (rawtime,
				   vsourceline[i].substr (vsourceline[i].
							  find_last_of (';') +
							  1), vtask_id[j]);
	    }
	}
    }
}

std::string complex_vol (const std::string & strvol)
{
  std::string result, tmpvol, master, pcml, pcmr;;
  tmpvol = strvol;

  if (tmpvol.length () > 0)
    {
      master = tmpvol.substr (0, tmpvol.find (":"));	//FIXME verife of valid format XX:XX:XX
      pcml =
	tmpvol.substr (tmpvol.find (":") + 1,
		       tmpvol.find_last_of (":") - tmpvol.find (":") - 1);
      pcmr = tmpvol.substr (tmpvol.find_last_of (":") + 1);


      if (master.length () > 0 && pcml.length () > 0 && pcmr.length () > 0)
	result = "amixer -q set " + gsmaster () + " " + master + "%";	// + " ; amixer -q set " + gshphone() + " " + master + "%" + " ; amixer -q set " + gspcm() + " " + pcml + "%," + pcmr + "%";
      else
	result = "amixer -q set " + gsmaster () + " 70%";	// " ; amixer -q set " + gshphone() + " 70% ; amixer -q set " + gspcm() + " 70%,70%";
    }
  else
    result = "amixer -q set " + gsmaster () + " 60%";	//" ; amixer -q set " + gshphone() + " 60% ; amixer -q set " + gspcm() + " 60%,60%";

  return result;
}

std::string jvol_per ()
{
  std::string result, tmpvol;
  std::string fname;
  std::ifstream fnjvol;

  fname = "./task/JINGL_VOL";
  fnjvol.open (fname.c_str ());
  std::getline (fnjvol, tmpvol);
  fnjvol.close ();

  result = complex_vol (tmpvol);

  return result;
}

std::string get_vol_per (std::string time, bool brun,
			 const unsigned int &wday)
{
  std::string result;

  std::string mtime, umtime;
  std::vector < std::string > vmtime, vumtime;
  std::ifstream fnmuted;

  std::vector < unsigned int >int_wdays;
  int_wdays.push_back (6);
  int_wdays.push_back (0);
  int_wdays.push_back (1);
  int_wdays.push_back (2);
  int_wdays.push_back (3);
  int_wdays.push_back (4);
  int_wdays.push_back (5);

  vmtime = vlines4 ("./task/mute");
  vumtime = vlines4 ("./task/unmute");

  std::string fname, tmpvol;
  std::ifstream fnmvol;

  if (brun)
    {
      fname = "./task/MUSIC_VOL";

      change_music_vol (fname, time, wday);
    }
  else
    {
      fname = "./task/JINGL_VOL";
    }
  fnmvol.open (fname.c_str ());
  std::getline (fnmvol, tmpvol);
  fnmvol.close ();


  for (unsigned int i = 0; i < vmtime.size (); i++)
    if (time == vmtime[i] and i == int_wdays[wday])
      result = "amixer -q set " + gsmaster () + " mute;"
	/*" amixer -q set " + gshphone() + " mute; amixer -q set " + gspcm() + " mute;" */
	+ " /bin/sh -e ~/mute.sh; " + complex_vol (tmpvol);


  for (unsigned int i = 0; i < vumtime.size (); i++)
    if (time == vumtime[i] and i == int_wdays[wday])
      result = "amixer -q set " + gsmaster () + " unmute;"
	/*" amixer -q set " + gshphone() + " unmute; amixer -q set " + gspcm() + " unmute; */
	+ " /bin/sh -e ~/unmute.sh; " + complex_vol (tmpvol);

  if (result.length () == 0)
    result = complex_vol (tmpvol);

  std::string fnscript;
  std::ofstream ofile;

  fnscript = "./volscript.sh";

  ofile.open (fnscript.c_str ());
  ofile << "#!/bin/sh" << std::endl;
  ofile << result << std::endl;
  ofile.close ();

  pid_t child;
  std::string exec_name;

  exec_name = "/bin/sh";
  if (brun)
    {
      if (!(child = fork ()))
	{
	  execlp (exec_name.c_str (), exec_name.c_str (), fnscript.c_str (),
		  NULL);
	  exit (0);
	}			//child
      wait (0);
    }
  return result;
}

time_t
rnd_time ()
{
  time_t ntime;

  time (&ntime);
  return ntime;
}

void
start_bgmp_music (const std::string & wday, const std::string & time)
{
  pid_t child;
  std::ofstream task;
  std::string exec_name = "/bin/sh";

  std::ifstream ifmexcept, ifsstime;
  std::string fnmexcept, tmp_mexcept, sum_except, mexcept, sstime, tmp_sstime;

  ifsstime.open ("./sstime");
  std::getline (ifsstime, tmp_sstime);
  if (tmp_sstime.length () > 0)
    sstime = " -ss " + tmp_sstime + " ";
  else
    sstime = " -ss 0 ";
  ifsstime.close ();

  ifmexcept.open ("./task/mexcept");
  while (ifmexcept.good ())
    {
      std::getline (ifmexcept, tmp_mexcept);
      sum_except += tmp_mexcept;
    }
  ifmexcept.close ();

  if (sum_except.find (time) != std::string::npos)
    mexcept = "amixer -q set " + gsmaster () + " mute;"
      /* " amixer -q set " + gshphone() + " mute; amixer -q set " + gspcm() + " mute;" */
      + " /bin/sh -e ~/mute.sh;";

  task.open ("./mp/taskmp.sh");
  task << "#!/bin/sh" << std::endl;

  /*
     task << "mv -f " << "./task/PROGRESS/"
     << runtime[i]
     << " ./task/COMPLETED/"
     << runtime[i]
     << std::endl;
   */
  //FIXME if radio ON in .rm then radio.pls, not all.pls

#ifdef DBG
  std::cout << "start_bg_music::   wday: " << wday << ", time: " << time <<
    std::endl;
#endif //DBG
  task << "# wday: " << wday << ", time: " << time << std::endl;

  task << "cp -f ~/pls/all.pls ~/pls/backup_all.pls" << std::endl;
  task << "cp -f ~/pls/" << change_all_pls (wday, time) << ".pls ~/pls/all.pls" << std::endl;	// if exist file, ln -s 2_11:00:00.pls all.pls (rm all.pls)

  task << "line=`pgrep -U " << UID2 << " mpg321`\n";
  task << "if [ -n \"$line\" ]\n";
  task << "then\n";
  task << "  killall -q -9 -u " << UID2 << " mpg321" << std::endl;
  task << "fi" << std::endl;

  task << mexcept << jvol_per () << std::endl;

  task << "mpg321 -q -g " << "`cat ~/task/MUSIC_VOL | sed s/.*://g`" <<
    " -Z -@ pls/all.pls &" << std::endl;
  //task << "DISPLAY=:0.0 mplayer -geometry " << get_resolution() << "+0+0 -input file=/home/uid0001/bgmpfifo -softvol " << get_eq() << " -loop 0 -nolirc -quiet -playlist ~/pls/all.pls > ~/log/allplsmplayer.log 2> ~/log/error_allplsmplayer.log &" << std::endl;

  task.close ();

  std::string arg1 = "./mp/taskmp.sh";

  if (!(child = fork ()))
    {
      execlp (exec_name.c_str (), exec_name.c_str (), arg1.c_str (), NULL);
      exit (0);
    }				//child
  wait (0);
}


void
set_run_pls (const std::string & runtime, const std::string & nextruntime,
	     const std::string & fn, const std::string & status,
	     const unsigned int &wday)
{

  std::ifstream ifnpls, ifnhashs;
  std::ofstream ofreport;

  std::string fnreport, hashs, nexthashs, tmpstr, fnhashs, fnpls, nextfnpls,
    tags, nexttags;
  std::string content, nextcontent;
  content = "";

  fnpls = BDIRPLS + WDAYS[wday] + EDIRPLS + runtime + ".pls";
  nextfnpls = BDIRPLS + WDAYS[wday] + EDIRPLS + nextruntime + ".pls";

  ifnpls.open (fnpls.c_str ());
  while (ifnpls.good ())
    {
      getline (ifnpls, tmpstr);
      if ((tmpstr.find ("File") != std::string::npos)
	  && (tmpstr.find ("=../") != std::string::npos)
	  && ((tmpstr.find_last_of ('/') + 1) <= tmpstr.length ()))
	content += tmpstr.substr (tmpstr.find_last_of ('/') + 1);
    }
  ifnpls.close ();

  tmpstr = "";

  ifnpls.open (nextfnpls.c_str ());
  while (ifnpls.good ())
    {
      getline (ifnpls, tmpstr);
      if ((tmpstr.find ("=../") != std::string::npos)
	  && ((tmpstr.find_last_of ('/') + 1) <= tmpstr.length ()))
	nextcontent += tmpstr.substr (tmpstr.find_last_of ('/') + 1);
    }
  ifnpls.close ();

#ifdef DBG
  //  std::cout << "content: " << content << std::endl;
  //  std::cout << "nextcontent: " << nextcontent << std::endl;
#endif //DBG


  tmpstr = "";

  fnhashs = "./log/hashname.txt";
  ifnhashs.open (fnhashs.c_str ());
  while (ifnhashs.good ())
    {
      getline (ifnhashs, tmpstr);
      if ((tmpstr.find_last_of ('/')) != std::string::npos)
	if (((tmpstr.find_last_of ('/') + 1) <= tmpstr.length ()) && (tmpstr.length () > 34))	//FIXME may be fail in < or <=
	  {
	    if (content.find (tmpstr.substr (tmpstr.find_last_of ('/') + 1))
		!= std::string::npos)
	      hashs += "<HASH>" + tmpstr.substr (0, 32) + "</HASH>";
	    if (nextcontent.find
		(tmpstr.substr (tmpstr.find_last_of ('/') + 1)) !=
		std::string::npos)
	      nexthashs += "<HASH>" + tmpstr.substr (0, 32) + "</HASH>";
	  }
    }
  ifnhashs.close ();

#ifdef DBG
  //  std::cout << "hashs: " << hashs << std::endl;
  //  std::cout << "nexthashs: " << nexthashs << std::endl;
#endif //DBG

  fnreport = TDIRREPORTED + fn;

  if (hashs.length () > 0 || nexthashs.length () > 0)
    {
      tags =
	"<RUNTIME>" + runtime + "</RUNTIME>" + "<STATUS>" + status +
	"</STATUS>";
      nexttags =
	"<RUNTIME>" + nextruntime + "</RUNTIME>" + "<STATUS>WAIT</STATUS>";

#ifdef DBG
      //      std::cout << "tags: " << tags << std::endl;
      //      std::cout << "nexttags: " << nexttags << std::endl;
#endif //DBG

      ofreport.open (fnreport.c_str ());

      if (hashs.length () > 0)
	ofreport << tags << "<TRACKS>" << hashs << "</TRACKS>" << std::endl;	// Standart for this type files
      //NEXT LINE
      if (nexthashs.length () > 0)
	ofreport << nexttags << "<TRACKS>" << nexthashs << "</TRACKS>";

      ofreport.close ();
    }
}

void
gen_volsofday24 ()
{
  std::string time, time_hm, time_h;
  time = get_now_time ();
  time_h = time.substr (0, 2);
  time_hm = time.substr (0, 5);

  std::vector < std::string > times;

  for (unsigned int i = 21 * 60 * 60; i < 21 * 60 * 60 + 24 * 60 * 60 - 1;
       i = i + 60 * 60)
    {				//00:00:00 - 23:59:00
      if (time_h == time_to_str (i).substr (0, 2))
	change_vols (time_h + ":00:00");
    }

  for (unsigned int i = 21 * 60 * 60; i < 21 * 60 * 60 + 24 * 60 * 60 - 1;
       i = i + 60)
    {				//00:00:00 - 23:59:00
      if (time_hm == time_to_str (i).substr (0, 5))
	change_vols (time_hm + ":00");
    }
}

int
main ()
{
  std::ofstream ofmplog;
  ofmplog.open ("mplog.log");
  ofmplog << "Main version in compile time: " << VERSION << std::endl;
  ofmplog << "Player Version: " << MPVER << std::endl;
  ofmplog.close ();

  create_ff2one_mp4 ();

  gen_volsofday24 ();

  create_isunmute ();

  pid_t child;

  time_t rawtime, realtime, bgStartTime;
  struct tm *timeinfo;

  std::string exec_name = "/bin/sh";
  std::string arg1 = "./mp/mp.sh";
  std::vector < std::string > runtime, tmp_runtime, fupdate, runtask;
  std::string now_time, old_time, tmp_time;
  bool is_run = false;

  std::string vol_per, jvol_per;

  //PNG
  std::string png_delay, pngtimename, pngname, spngname, lsec, stimename;
  std::ifstream ifpngtimename, ifpngname, iftimename;

  //timeupdate
  std::string strtimeupdate;
  std::ifstream iftimeupdate;

  time (&bgStartTime);
  time (&rawtime);
  timeinfo = localtime (&rawtime);
  tmp_time = asctime (timeinfo);
  now_time = tmp_time.substr (11, 8);

  unsigned int wdmute, sumsec;

  wdmute = timeinfo->tm_wday;

  std::string swdays;
  swdays = "0123456";
  std::string swdmute;
  swdmute.push_back (swdays[wdmute]);

  std::string tmp_sget_vol_per;

  cmp_mute (now_time, wdmute);

  tmp_sget_vol_per = get_vol_per (now_time, true, wdmute);

  start_bgmp_music (swdmute, now_time);
  time (&rawtime);

  for (;;)
    {
      fupdate = ls (UPDATEDIR);
      if (fupdate.size () > 0)
	{
	  for (unsigned j = 0; j < fupdate.size (); j++)
	    {
	      if (fupdate[j] == UDOWNLOADEDP)
		{
		  rename (FNUDOWNLOADEDP, FNFUEXITP);
		  exit (EXIT_SUCCESS);
		}
	    }
	}			// if fupdate.size() > 0


      time (&realtime);

      iftimeupdate.open ("./task/updatetime");
      if (iftimeupdate.good ())
	std::getline (iftimeupdate, strtimeupdate);
      iftimeupdate.close ();

      if ("updatetimenow" == strtimeupdate)
	{
	  unlink ("./task/updatetime");
	  rawtime = realtime - 1;
	  strtimeupdate.clear ();
	}

      timeinfo = localtime (&rawtime);
      tmp_time = asctime (timeinfo);

      now_time = tmp_time.substr (11, 8);

      old_time = now_time;

      //    if (now_time.substr(3) == "00:00")
      if (now_time.substr (5) == ":00")
	change_vols (now_time);

      unsigned int wday;

      wday = timeinfo->tm_wday;

      std::string sget_vol_per;
      if (!div (atoi (now_time.substr (6).c_str ()), 5).rem)
	sget_vol_per = get_vol_per (now_time, true, wday);

      //    std::cout << "WDAY = " << wday << "; wdays[]=" << wdays[wday]  << std::endl;

#ifdef DBG
      std::cout << "Time: " << now_time << std::endl;
#endif //DBG

      runtime.clear ();
      tmp_runtime = ls ("./task/PROGRESS/");
      /*
         for (unsigned int i = 0; i < tmp_runtime.size(); i++) {
         if (!isjpls("./task/PROGRESS/"+tmp_runtime[i]))//FIXME function
         runtime.push_back(tmp_runtime[i]);
         }
       */

      runtime = tmp_runtime;

      runtask.clear ();

      if (runtime.size () > 0)
	{
	  for (unsigned int i = 0; i < runtime.size (); i++)
	    {
	      if (runtime[i].find ('_') != std::string::npos)	//FIXME && runtime[i].find_last_of('_')+1 < (!!!!!!1111 in this place '<') runtime[i].length()
		if (runtime[i].substr (0, 8) == now_time)
		  runtask.push_back (runtime[i].substr
				     (runtime[i].find_last_of ('_') + 1));
	      runtime[i] = runtime[i].substr (0, 8);	//FIXME may be runtime[i].length() == 0,1,2,3,4,5,6,7 and all < 8, what did you doing
	    }

#ifdef DBG1
	  std::cout << "Runtask.size() = " << runtask.size () << std::endl;
#endif //DBG

	  cmp_task_time (runtask, rawtime, wday);
    //std::cout << "./pls" + tToStr(wday)+"/" + now_time + ".pls" << std::endl;
    //std::cout << fexist("./pls" + tToStr(wday)+"/" + now_time + ".pls") << std::endl;
    if (fexist("./pls" + tToStr(wday)+"/" + now_time + ".pls"))
	    ffmpeg_pls_2_one_file_link (now_time, wday);

	  std::sort (runtime.begin (), runtime.end ());
	  std::vector < std::string >::iterator it =
	    std::unique (runtime.begin (), runtime.end ());
	  runtime.erase (it, runtime.end ());
	}
      //    std::cout << "before runtime.size = " << runtime.size() << std::endl;
      if (runtime.size () > 0)
	{
#ifdef DBG1
	  std::cout << "runtime.size() = " << runtime.size () << std::endl;
#endif //DBG

	  for (unsigned int i = 0; i < runtime.size (); i++)
	    {
	      if (runtime[i] == now_time)
		{
#ifdef DBG1
		  std::cout << "in if runtime[i] == now_time" << std::endl;
		  std::cout << "cmp_runtime" << std::endl;
#endif //DBG
		  cmp_mute (runtime[i], wday);
		  //if ( isunmute() )
		  is_run = true;

		}

#ifdef DBG
	      std::cout << "before is_run = " << runtime[i] << std::endl;
#endif //DBG

	      if (is_run)
		{

#ifdef DBG1
		  std::cout << "in is_run = " << runtime[i] << std::endl;
#endif //DBG

		  if ((realtime - bgStartTime) > 0)
		    next_all_pls (realtime - bgStartTime);	// need always realtime > bgStartTime
		  else
		    next_all_pls (240);

		  std::ofstream mp_sh;
		  // ---begin--- lite mute
		  mp_sh.open (VOL_DOWN.c_str ());
		  mp_sh << "#!/bin/sh" << std::endl;
      mp_sh << "touch ~/task/mpxysize" << std::endl;
		  for (unsigned int count = 0; count < 20; count++)
		    {
		      mp_sh << "sleep 0.2" << std::endl;
		      mp_sh <<
			/*"amixer -q set " + gshphone() + " 5%- > ~/log/amixer5dec.log 2>~/log/error_amixer5dec.log; " + */
			"amixer -q set " << gsmaster () <<
			" 0% > ~/log/amixer5dec.log 2>~/log/error_amixer5dec.log"
			/* + "; amixer -q set " + gspcm() + " 5%- > ~/log/amixer5dec.log 2>~/log/error_amixer5dec.log" */
			<< std::endl;
		    }
		  mp_sh.close ();

		  if (!(child = fork ()))
		    {
		      execlp (exec_name.c_str (), exec_name.c_str (),
			      VOL_DOWN.c_str (), NULL);
		      exit (0);
		    }		//child
		  wait (0);
		  // ---end--- lite mute

		  vol_per = get_vol_per (runtime[i], false, wday);

		  std::string wdays;
		  wdays = "0123456";
		  std::string fnames, mp4fnames;
		  fnames = "./pls";
		  fnames.push_back (wdays[wday]);
		  fnames.push_back ('/');
		  fnames += runtime[i];
		  fnames += ".pls";

		  mp4fnames = "./ts";
		  mp4fnames.push_back (wdays[wday]);
		  mp4fnames.push_back ('/');
		  mp4fnames += runtime[i];
		  mp4fnames += ".mp4";

		  sieve (fnames);

		  std::string swpapper;

		  unsigned int nexti;
		  if (i + 1 < runtime.size ())
		    nexti = i + 1;
		  else
		    nexti = 0;

		  //set_run_pls(runtime[i], runtime[nexti], tmp_time, "PROGRESS", wday);

		  std::vector < std::string > mpfiles;

		  mpfiles = get_mpfiles (fnames);
		  //      std::cout << mpfiles.size() << std::endl;
		  if (mpfiles.size () > 0)
		    {
		      //ffmpeg_pls_2_one_file_link(now_time, wday);

		      mp_sh.open (arg1.c_str ());
		      mp_sh << "#!/bin/sh" << std::endl;
		      mp_sh << "#" << runtime[i] << std::endl;
		      mp_sh << "touch ~/mp/pre.sh ~/mp/post.sh" << std::endl;
		      mp_sh << "/bin/sh -e ~/mp/pre.sh" << std::endl;

          mp_sh << "line=`pgrep -U " << UID2 << " mpg321`\n";
          mp_sh << "if [ -n \"$line\" ]\n";
          mp_sh << "then\n";
          mp_sh << "  killall -q -9 -u " << UID2 << " mpg321" << std::endl;
          mp_sh << "fi" << std::endl;

		      //if (config->isPresent(RMBGVIDEOYES))
		      //mp_sh << "echo \"pause\" >> /home/uid0001/bgmp2fifo &" << std::endl;

		      mp_sh << vol_per << std::endl;


		      sumsec = 0;

		      /*
		         for (unsigned int mpfcount = 0; mpfcount < mpfiles.size(); mpfcount++)
		         {

		         stimename = "./pls/" + mpfiles[mpfcount] + ".sec";
		         lsec.clear();
		         iftimename.open(stimename.c_str());
		         if (iftimename.good())
		         {
		         std::getline(iftimename, lsec);
		         sumsec += atoi(lsec.c_str());
		         }
		         iftimename.close();

		         mp_sh << "echo -n '{{{" + mpfiles[mpfcount] + " (" + lsec + " сек.) +++Начало: ' >> ./log/\"$DATE\".log; date | tr -d '\\n' >> ./log/\"$DATE\".log" << std::endl;

		         if(mpfiles[mpfcount].find(".wav") != std::string::npos) {
		         mp_sh << "aplay -q ~/upload/"
		         << mpfiles[mpfcount]
		         << " > ~/log/plsNmplayer.log 2> ~/log/error_plsNmplayer.log"
		         << std::endl;
		         }
		         else {
		         mp_sh << "mpg321 -q -g " << "`cat ~/task/JINGL_VOL | sed s/.*://g`" << " ~/upload/"
		         << mpfiles[mpfcount]
		         << " > ~/log/plsNmplayer.log 2> ~/log/error_plsNmplayer.log"
		         << std::endl;
		         }

		         mp_sh << "echo -n ' +++Окончание: ' >> ./log/\"$DATE\".log\n";
		         mp_sh << "date  | tr -d '\\n' >> ./log/\"$DATE\".log\n";
		         mp_sh << "echo -n ' +++' >> ./log/\"$DATE\".log\n";
		         mp_sh << "amixer sget " + gsmaster() + " | grep '\\[' | sed s/.*://g | awk '{print $3 $5}' | tr -d '\\n' >> ./log/\"$DATE\".log\n";
		         //               mp_sh << "amixer sget " + gshphone() + " | grep '\\[' | sed s/.*://g | awk '{print $3 $5}' | tr -d '\\n' >> ./log/\"$DATE\".log\n";
		         //               mp_sh << "amixer sget " + gspcm() + " | grep '\\[' | sed s/.*://g | awk '{print $3 $5}' | tr -d '\\n' >> ./log/\"$DATE\".log\n";
		         mp_sh << "echo '}}}' >> ./log/\"$DATE\".log"<< std::endl;
		         }
		       */

		      mp_sh << "omxplayer `cat /home/" + UID2 + "/task/mpxysize` -o local --layer '2' --vol $(amixer sget " +
			gsmaster () +
			" | grep 'dB' | awk '{print $3}') " << mp4fnames <<
			" >/tmp/omxplayer.log &" << std::endl;
           mp_sh << "sleep 2 && sleep 0$(ffprobe -v quiet -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 " << mp4fnames << ") && dbuscontrol.sh stop" << std::endl;


//mp_sh << "DISPLAY=:0.0 mplayer -vo x11 -geometry " << get_resolution() << "+0+0 -input file=/home/uid0001/mpfifo -softvol " << get_eq() << "  -nolirc -quiet " << mp4fnames << " > ~/log/plsNmplayer.log 2> ~/log/error_plsNmplayer.log" <<std::endl;
// mp_sh << "DISPLAY=:0.0 mplayer -geometry " << get_resolution() << "+0+0 -input file=/home/uid0001/mpfifo -softvol " << get_eq() << "  -nolirc -quiet " << mp4fnames


		      //if (config->isPresent(RMBGVIDEOYES))
		      //mp_sh << "echo \"pause\" >> /home/uid0001/bgmp2fifo &" << std::endl;
		      mp_sh << "/bin/sh -e ~/mp/post.sh" << std::endl;

		      mp_sh.close ();

		      if (to_sec ("2013-02-12 " + runtime[i]) <=
			  to_sec ("2013-02-12 " + runtime[nexti]))
			if ((time_t)
			    (to_sec ("2013-02-12 " + runtime[i]) + sumsec) >
			    to_sec ("2013-02-12 " + runtime[nexti]))
			  create_rep_overflow_block (runtime[i],
						     runtime[nexti], sumsec);

		      if (!(child = fork ()))
			{
			  execlp (exec_name.c_str (), exec_name.c_str (),
				  arg1.c_str (), NULL);
			  exit (0);
			}	//child
		      wait (0);

		    }
		  swdmute.clear ();
		  swdmute.push_back (wdays[wday]);
		  start_bgmp_music (swdmute, runtime[i]);

		  if (config->isPresent(RMREPORT))
		    set_run_pls (runtime[i], runtime[nexti], tmp_time,
				 "COMPLETED", wday);

		  time (&bgStartTime);


		  is_run = false;

		}		//is_run
	    }			//for i
	}			//runtime

      rawtime = rawtime + 1;
#ifdef TIMEDBG
      std::cout << "RealTime: " << realtime << ", RawTime: " << rawtime <<
	std::endl;
#endif //TIMEDBG

      if (realtime <= rawtime)	// If 11sec <= 11sec
	sleep (1);

      /*
         std::ifstream if_mp_reboot;
         std::ofstream of_c_reboot;
         std::string tmp_mp_reboot, count_reboot;
         unsigned int icount_reboot;

         count_reboot.clear();
         icount_reboot = 0;
         #ifdef DBGREBOOT
         std::cout << "Count reboot1: " << icount_reboot << std::endl;
         #endif

         if_mp_reboot.open(LCREBOOT.c_str());
         while(if_mp_reboot.good())
         {
         std::getline(if_mp_reboot, count_reboot);
         if (count_reboot.size() > 0)
         {
         icount_reboot = count_reboot.size();
         #ifdef DBGREBOOT
         std::cout << "Count reboot2: " << icount_reboot << std::endl;
         #endif
         }
         }
         if_mp_reboot.close();
         #ifdef DBGREBOOT
         std::cout << "Count reboot3: " << icount_reboot << std::endl;
         #endif
         tmp_mp_reboot.clear();
         if_mp_reboot.open(LMPREBOOT.c_str());
         while(if_mp_reboot.good())
         {
         std::getline(if_mp_reboot, tmp_mp_reboot);
         if ((tmp_mp_reboot.size() > 0) && (icount_reboot < 2) )
         {
         #ifdef DBGREBOOT
         std::cout << "Count reboot4: " << icount_reboot << std::endl;
         #endif
         mp_reboot();
         }
         if ((tmp_mp_reboot.size() > 0) && (icount_reboot > 1) && (now_time.substr(0, 7) == "04:03:0") )
         {
         #ifdef DBGREBOOT
         std::cout << "Count reboot5: " << icount_reboot << std::endl;
         #endif

         mp_reboot();
         }
         }
         if_mp_reboot.close();
         #ifdef DBGREBOOT
         std::cout << "Count reboot6: " << icount_reboot << std::endl;
         #endif
       */
    }
  return 0;
}