www.pudn.com > wav_mp3_recorder.rar > mediarecorder.cpp

#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include 
#include 

#include "mediarecorder.h"
#include "mediarecorderbase.h"
#include "timeprogressbar.h"
#include "waveform.h"

#include "playlistbase.h"

#define timesec   100
#define sizes     512

QString path = QPEApplication::qpeDir();

MediaRecorder::MediaRecorder( QWidget *parent, const char *name, WFlags f )
    : QMainWindow( parent, name, f )
{

    setToolBarsMovable( FALSE );
    setBackgroundMode( PaletteButton );
    setCaption( tr("Voice Recorder --Whut") );

	  QFont hevia("helvetica", 12);
    hevia.setPixelSize(12);
    setFont( hevia );

    setIcon( Resource::loadPixmap( "SoundPlayer" ) );

    stack = new QWidgetStack( this );
    stack->setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
    setCentralWidget( stack );

    contents = new MediaRecorderBase( stack );
    stack->addWidget( contents, 0 );
      
    initializeContents();
    stack->raiseWidget( contents );

   // sampleBuffer = 0;
    process = 0;
    recordTime = 0;
    tenTimes = 0;
    recording = FALSE;
    playing = FALSE;
    read_data = 0;
    wave_mp3_id = 0;
    loopTimes = 1000/timesec;
    
    //lightTimer = new QTimer( this );
    sample_Timer = new QTimer(this);
    get_sample_data();
    
    connect( contents->recordButton, SIGNAL( clicked() ),
	     this, SLOT(recordClicked()) ); //// mp3_encode()
	  connect( contents->Group, SIGNAL(clicked(int)),
	     this, SLOT(changebid(int)) );
	  connect( contents->replayButton, SIGNAL(clicked()),
	     this, SLOT( replayclicked()));
	  connect(sample_Timer, SIGNAL(timeout()),
	     this, SLOT(ShowWaveData()));	  
}

MediaRecorder::~MediaRecorder()
{
   if ( sampleBuffer )
	delete[] sampleBuffer;

	 if(sample_Timer)
	 	delete sample_Timer;
}


void MediaRecorder::initializeContents()
{
	  qualities.frequency = 8000;
	  qualities.channels = 1;
	  
	 // playbase = new PlayListBase(this, "playbase");
    contents->waveform->setBackgroundColor ( black );
    contents->progress->setTotalSteps( 10 );
    contents->progress->setProgress( -1 ); 
}

void MediaRecorder::changebid(int index)
{
	wave_mp3_id = index;
	qDebug("index = %d", index);
}

void MediaRecorder::loadplay()
{
	PlayListBase playbase(this);
	if( playbase.exec()) {
	   //qDebug("PlayListBase ok");
	   playing = TRUE;
	   contents->replayButton->setText(tr("stop"));
	   contents->recordButton->setEnabled(FALSE);
	   contents->Group->setEnabled(FALSE);
	   sample_Timer->start(timesec, FALSE );
	   QString filename = playbase.get_playfile_name();
	   //qDebug(filename);
	   play_mp3_wav(filename);                //start playing
	  //play_mp3_wav("/home/music/4.mp3");
  }
}

void MediaRecorder::startSave()
{
   QString hms = tr("Recorded Sound_%1").arg(TimeString::localHMS(QTime::currentTime()));
   hms.replace( QRegExp(":"), "_" );
  // qDebug(hms);
   lastSaved = "/Documents/audio/record/";
   lastSaved = lastSaved.append(hms);;
   //qDebug(lastSaved);

 if (wave_mp3_id == 0)
    lastSaved = lastSaved.append(".mp3");
 else if(wave_mp3_id == 1)
  	lastSaved = lastSaved.append(".wav");
  qDebug(lastSaved);
}


void MediaRecorder::startRecording()
{ 
   // get_sample_data();
	  QPEApplication::setTempScreenSaverMode( QPEApplication::DisableSuspend ); 
    startSave();

    contents->waveform->changeSettings(qualities.frequency,
					 qualities.channels);

    contents->progress->setTotalSteps( 120 );
    contents->progress->setProgress( 0 );
    contents->progress->setRecording();
    recording = TRUE;
    contents->recordButton->setText( tr("Stop") );
    contents->recordButton->setEnabled( TRUE );
    contents->replayButton->setEnabled( FALSE);
	contents->Group->setEnabled(FALSE);

    sample_Timer->start(timesec, FALSE );
    mp3_encode();
    ShowWaveData();
    
}


void MediaRecorder::stopRecording()
{
    contents->waveform->reset();
    contents->recordButton->setEnabled( TRUE );
    recording = FALSE;
    contents->recordButton->setText( tr("Record") );
    sample_Timer->stop();
    contents->replayButton->setEnabled(TRUE);
	  contents->Group->setEnabled(TRUE);
    contents->progress->setProgress(0);
    recordTime = 0;
    kill(pidtomp3, SIGUSR1);
    QPEApplication::setTempScreenSaverMode( QPEApplication::Enable );
}


void MediaRecorder::recordClicked()
{
    if ( recording ) {
	stopRecording();
    } else {
	startRecording();
    }
}

void MediaRecorder::ShowWaveData()
{   
	int i = 1000/timesec;
	 if( tenTimes < i ) {
	 	   tenTimes++;
	  }
	  else {
	  	tenTimes = 0;
	    contents->progress->setProgress( ++recordTime );
	  }
           if(recordTime > contents->progress->totalSteps())
              contents->progress->setTotalSteps( contents->progress->totalSteps()*4);
	  contents->waveform->newSamples( sampleBuffer, sizes );
}

void MediaRecorder::mp3_encode()
{
	if( process )
		 delete process;
	process = new QProcess(this);
	QString bin_name = path + "bin/rec";
	qDebug(bin_name);
	process->addArgument(bin_name); //"/home/x86-qtopia/qtopia/bin/rec"
	if(wave_mp3_id == 0)
	   process->addArgument("-m");
	else if(wave_mp3_id == 1)
		 process->addArgument("-w");
	process->addArgument(lastSaved);
	connect( process, SIGNAL( processExited() ),
           this, SLOT( Exit()) );
           
	process->start();
	pidtomp3 = process->processIdentifier();
	qDebug("process's pid is %d", (int)pidtomp3);
}

void MediaRecorder::Exit()
{
   if ( process->normalExit() )
	  	  qDebug( "Recorde Successed!" );
	  else
	  	  qDebug( "Process Not normalexit!" ); 
	  delete process;
	  process = 0;
}


void MediaRecorder::replayclicked()
{
	if ( playing ) {
		stopplay();
	}
	else {
		startplay();
	}
		 
}
void MediaRecorder::startplay()
{
	 contents->waveform->changeSettings(qualities.frequency,
					qualities.channels);
	    contents->progress->setTotalSteps( 120 );
   contents->progress->setProgress( 0 );
   contents->progress->setRecording();
	 loadplay(); 
}

void MediaRecorder::tellmp(const QString & command) {
	//if (process->isRunning()) 
		process->writeToStdin(command + "\n");
}

void MediaRecorder::stopplay()
{
	 playing = FALSE;
	 contents->replayButton->setText(tr("Repaly"));
   sample_Timer->stop();
   contents->waveform->reset();
   contents->recordButton->setEnabled(TRUE);
   contents->Group->setEnabled(TRUE);
   recordTime = 0;
   contents->progress->setProgress(0);
     if(!process->isRunning()) {
		return;
	}
	tellmp("quit");
  // process->tryTerminate();
  // QTimer::singleShot( 5000, process, SLOT( kill() ) );
}
	
void MediaRecorder::get_sample_data()
{
		//if ( sampleBuffer )
  	//  delete[] sampleBuffer;
    sampleBuffer = new short [256];
    QString path_name = path + "pics/sample.txt";
    qDebug(path_name);
    FILE* file = fopen(path_name, "rb"); //"/home/x86-qtopia/qtopia/pics/sample.txt"
    if(file == NULL) {
    	qDebug("Fails on open wav file");
    	return;
    }
    fseek(file, 44, SEEK_SET);
    read_data = fread(sampleBuffer, sizeof(short), 256, file);
    fclose(file);
}

void MediaRecorder::play_mp3_wav(const QString& fileName)
{
	//qDebug(fileName);
	if(process)
		  delete process;
	process = new QProcess(this);
	process->addArgument("/home/MPlayer-1.0rc1/mplayer");  //加入板子上的mplayer路径
	process->addArgument(fileName);
	connect( process, SIGNAL( processExited() ),
           this, SLOT( PlayExit()) );
           
	process->start();
	qDebug("process's pid is %d", (int)process->processIdentifier());
}

void MediaRecorder::PlayExit()
{  
	 playing = FALSE;
	 contents->replayButton->setText(tr("Repaly"));
   sample_Timer->stop();
   contents->waveform->reset();
   contents->recordButton->setEnabled(TRUE);
   contents->Group->setEnabled(TRUE);
   recordTime = 0;
   contents->progress->setProgress(0);
	  if ( process->normalExit() )
	  	  qDebug( "Playing Over Sucessed end!" );
	  else
	  	  qDebug( "Process Not normalexit!" ); 
	  delete process;
	  process = 0;
}