void V4L2encStreamHandler::RestartEncoding(void)
{
LOG(VB_RECORD, LOG_INFO, LOC + "RestartEncoding()");
StopEncoding();
StartEncoding();
}
bool V4L2encRecorder::PauseAndWait(int timeout)
{
QMutexLocker locker(&m_pauseLock);
if (m_request_pause)
{
if (!IsPaused(true))
{
LOG(VB_RECORD, LOG_INFO, LOC + "PauseAndWait() -- pause");
StopEncoding();
m_paused = true;
m_pauseWait.wakeAll();
if (m_tvrec)
m_tvrec->RecorderPaused();
}
}
else if (IsPaused(true))
{
LOG(VB_RECORD, LOG_INFO, LOC + "PauseAndWait() -- unpause");
StartEncoding();
if (m_stream_data)
m_stream_data->Reset(m_stream_data->DesiredProgram());
m_paused = false;
}
// Always wait a little bit, unless woken up
m_unpauseWait.wait(&m_pauseLock, timeout);
return IsPaused(true);
}
/***************************************
* End
* Termina la conferencia activa
***************************************/
int AudioEncoderWorker::End()
{
//Terminamos de enviar
StopEncoding();
return 1;
}
/***************************************
* StartSending
* Comienza a mandar a la ip y puertos especificados
***************************************/
int AudioEncoderWorker::StartEncoding()
{
Log(">Start encoding audio\n");
//Si estabamos mandando tenemos que parar
if (encodingAudio)
//paramos
StopEncoding();
encodingAudio=1;
//Start thread
createPriorityThread(&encodingAudioThread,startEncoding,this,1);
Log("<StartSending audio [%d]\n",encodingAudio);
return 1;
}
int FLVEncoder::End()
{
//if inited
if (!inited)
//error
return 0;
//Stop Encodings
StopEncoding();
//Lock mutexk
pthread_mutex_lock(&mutex);
//Remove all rmpt media listenere
RTMPMediaStream::RemoveAllMediaListeners();
//Clear media listeners
mediaListeners.clear();
//Unlock
pthread_mutex_unlock(&mutex);
//Not inited
inited = 0;
return 1;
}
int FLVEncoder::StartEncoding()
{
Log(">Start encoding FLV [id:%d]\n",id);
//Si estabamos mandando tenemos que parar
if (encodingAudio || encodingVideo)
//paramos
StopEncoding();
//Set init time
getUpdDifTime(&first);
//Check if got old meta
if (meta)
//Delete
delete(meta);
//Create metadata object
meta = new RTMPMetaData(0);
//Set name
meta->AddParam(new AMFString(L"@setDataFrame"));
//Set name
meta->AddParam(new AMFString(L"onMetaData"));
//Create properties string
AMFEcmaArray *prop = new AMFEcmaArray();
//Set audio properties
switch(audioCodec)
{
case AudioCodec::SPEEX16:
prop->AddProperty(L"audiocodecid" ,(float)RTMPAudioFrame::SPEEX ); //Number Audio codec ID used in the file (see E.4.2.1 for available SoundFormat values)
prop->AddProperty(L"audiosamplerate" ,(float)16000.0 ); // Number Frequency at which the audio stream is replayed
break;
case AudioCodec::NELLY11:
prop->AddProperty(L"audiocodecid" ,(float)RTMPAudioFrame::NELLY ); //Number Audio codec ID used in the file (see E.4.2.1 for available SoundFormat values)
prop->AddProperty(L"audiosamplerate" ,(float)11025.0 ); // Number Frequency at which the audio stream is replayed
break;
case AudioCodec::NELLY8:
prop->AddProperty(L"audiocodecid" ,(float)RTMPAudioFrame::NELLY8khz ); //Number Audio codec ID used in the file (see E.4.2.1 for available SoundFormat values)
prop->AddProperty(L"audiosamplerate" ,(float)8000.0 ); // Number Frequency at which the audio stream is replayed
break;
}
prop->AddProperty(L"stereo" ,new AMFBoolean(false) ); // Boolean Indicating stereo audio
prop->AddProperty(L"audiodelay" ,0.0 ); // Number Delay introduced by the audio codec in seconds
//Set video codecs
if (videoCodec==VideoCodec::SORENSON)
//Set number
prop->AddProperty(L"videocodecid" ,(float)RTMPVideoFrame::FLV1 ); // Number Video codec ID used in the file (see E.4.3.1 for available CodecID values)
else if (videoCodec==VideoCodec::H264)
//AVC
prop->AddProperty(L"videocodecid" ,new AMFString(L"avc1") ); // Number Video codec ID used in the file (see E.4.3.1 for available CodecID values)
prop->AddProperty(L"framerate" ,(float)fps ); // Number Number of frames per second
prop->AddProperty(L"height" ,(float)height ); // Number Height of the video in pixels
prop->AddProperty(L"videodatarate" ,(float)bitrate ); // Number Video bit rate in kilobits per second
prop->AddProperty(L"width" ,(float)width ); // Number Width of the video in pixels
prop->AddProperty(L"canSeekToEnd" ,new AMFBoolean(false) ); // Boolean Indicating the last video frame is a key frame
//Add param
meta->AddParam(prop);
//Send metadata
SendMetaData(meta);
//If got audio
if (audioInput)
{
//We are enconding
encodingAudio = 1;
//Start thread
createPriorityThread(&encodingAudioThread,startEncodingAudio,this,1);
}
//If got video
if (videoInput)
{
//We are enconding
encodingVideo = 1;
//Start thread
createPriorityThread(&encodingVideoThread,startEncodingVideo,this,1);
}
Log("<Stop encoding FLV [%d]\n",encodingAudio);
return 1;
}
void V4L2encRecorder::run(void)
{
LOG(VB_RECORD, LOG_INFO, LOC + "run() -- begin");
bool failing, failed;
bool is_TS = false;
if (!m_stream_data)
{
m_error = "MPEGStreamData pointer has not been set";
LOG(VB_GENERAL, LOG_ERR, LOC + "run() -- " + m_error);
Close();
return;
}
m_stream_handler->Configure();
{
QMutexLocker locker(&m_pauseLock);
m_request_recording = true;
m_recording = true;
m_recordingWait.wakeAll();
}
if (m_channel->HasGeneratedPAT())
{
const ProgramAssociationTable *pat = m_channel->GetGeneratedPAT();
const ProgramMapTable *pmt = m_channel->GetGeneratedPMT();
m_stream_data->Reset(pat->ProgramNumber(0));
m_stream_data->HandleTables(MPEG_PAT_PID, *pat);
m_stream_data->HandleTables(pat->ProgramPID(0), *pmt);
LOG(VB_GENERAL, LOG_INFO, LOC + "PMT set"); // debugging
}
StartNewFile();
is_TS = (m_stream_handler->GetStreamType() == V4L2_MPEG_STREAM_TYPE_MPEG2_TS);
if (is_TS)
{
LOG(VB_RECORD, LOG_INFO, LOC + "mpeg2ts");
m_stream_data->AddAVListener(this);
m_stream_data->AddWritingListener(this);
}
else
{
LOG(VB_RECORD, LOG_INFO, LOC + "program stream (non mpeg2ts)");
m_stream_data->AddPSStreamListener(this);
}
m_stream_handler->AddListener(m_stream_data, false, true);
StartEncoding();
while (IsRecordingRequested() && !IsErrored())
{
if (PauseAndWait())
continue;
if (is_TS && !m_input_pmt)
{
LOG(VB_GENERAL, LOG_WARNING, LOC +
"Recording will not commence until a PMT is set.");
std::this_thread::sleep_for(std::chrono::milliseconds(5));
continue;
}
if (!m_stream_handler->Status(failed, failing))
{
if (failed)
{
m_error = "Stream handler died unexpectedly.";
LOG(VB_GENERAL, LOG_ERR, LOC + "run() -- " + m_error);
}
else if (failing)
{
SetRecordingStatus(RecStatus::Failing, __FILE__, __LINE__);
}
}
}
LOG(VB_RECORD, LOG_INFO, LOC + "Shutting down");
StopEncoding();
m_stream_handler->RemoveListener(m_stream_data);
if (m_stream_handler->GetStreamType() == V4L2_MPEG_STREAM_TYPE_MPEG2_TS)
{
m_stream_data->RemoveWritingListener(this);
m_stream_data->RemoveAVListener(this);
}
else
m_stream_data->RemovePSStreamListener(this);
Close();
FinishRecording();
QMutexLocker locker(&m_pauseLock);
m_recording = false;
m_recordingWait.wakeAll();
LOG(VB_RECORD, LOG_INFO, LOC + "run() -- end");
}
void V4L2encStreamHandler::run(void)
{
RunProlog();
LOG(VB_RECORD, LOG_INFO, LOC + "run() -- begin");
if (!IsOpen())
{
LOG(VB_GENERAL, LOG_WARNING, LOC +
"Starting stream handler, but v4l2 is not open!");
if (!Open())
{
LOG(VB_GENERAL, LOG_ERR, LOC +
QString("run() -- Failed to open %1: ")
.arg(_device) + ENO);
_error = true;
return;
}
}
#if 0
// VBI
if (m_vbi_fd >= 0)
m_vbi_thread = new VBIThread(this);
#endif
bool good_data = false;
bool gap = false;
QDateTime gap_start;
int len, remainder = 0;
QByteArray buffer;
char* pkt_buf = new char[PACKET_SIZE + 1];
SetRunning(true, true, false);
while (_running_desired && !_error)
{
// Get V4L2 data
if (m_streaming_cnt.load() == 0)
{
LOG(VB_RECORD, LOG_INFO, LOC + "Waiting for stream start.");
QMutexLocker locker(&_start_stop_lock);
_running_state_changed.wait(&_start_stop_lock, 5000);
continue;
}
// Check for errors
if (!m_drb)
break;
len = m_drb->Read(reinterpret_cast<unsigned char *>(pkt_buf),
PACKET_SIZE);
if (m_drb->IsErrored())
{
LOG(VB_GENERAL, LOG_ERR, LOC + "run() -- Device error detected");
if (good_data)
{
if (gap)
{
/* Already processing a gap, which means
* restarting the encoding didn't work! */
m_failing = true;
}
else
gap = true;
}
RestartEncoding();
}
else if (m_drb->IsEOF())
{
LOG(VB_GENERAL, LOG_ERR, LOC + "run() -- Device EOF detected");
_error = true;
}
else
{
#if 0 // For this to work, the data needs to be propagated back up to
// the 'recorder', but there could be multiple rcorders...
// If we have seen good data, but now have a gap, note it
if (good_data)
{
if (gap)
{
QMutexLocker locker(&statisticsLock);
QDateTime gap_end(MythDate::current());
for (Irec = m_rec_gaps.begin();
Irec != m_rec_caps.end(); ++Irec)
{
(*Irec).push_back(RecordingGap
(gap_start, gap_end));
}
LOG(VB_RECORD, LOG_DEBUG,
LOC + QString("Inserted gap %1 dur %2")
.arg(recordingGaps.back().toString())
.arg(gap_start.secsTo(gap_end)));
gap = false;
}
else
gap_start = MythDate::current();
}
else
good_data = true;
#else
good_data = true;
#endif
}
if (len < 0)
{
if (errno != EAGAIN)
LOG(VB_GENERAL, LOG_ERR, LOC +
QString("run() -- error reading from: %1")
.arg(_device) + ENO);
continue;
}
buffer.append(pkt_buf, len);
len = buffer.size();
if (len < static_cast<int>(TSPacket::kSize))
continue;
if (!_listener_lock.tryLock())
continue;
if (_stream_data_list.empty())
{
LOG(VB_GENERAL, LOG_ERR, LOC +
QString("run() -- _stream_data_list is empty, %1 buffered")
.arg(buffer.size()));
_listener_lock.unlock();
continue;
}
StreamDataList::const_iterator sit = _stream_data_list.begin();
for (; sit != _stream_data_list.end(); ++sit)
remainder = sit.key()->ProcessData
(reinterpret_cast<const uint8_t *>
(buffer.constData()), len);
_listener_lock.unlock();
if (remainder > 0 && (len > remainder)) // leftover bytes
buffer.remove(0, len - remainder);
else
buffer.clear();
}
QString tmp(_error);
LOG(VB_GENERAL, LOG_WARNING, LOC +
QString("_running_desired(%1) _error(%2)")
.arg(_running_desired).arg(tmp));
LOG(VB_RECORD, LOG_INFO, LOC + "run() -- finishing up");
StopEncoding();
delete[] pkt_buf;
SetRunning(false, true, false);
RunEpilog();
LOG(VB_RECORD, LOG_INFO, LOC + "run() -- end");
}
V4L2encStreamHandler::~V4L2encStreamHandler(void)
{
StopEncoding();
Close();
}
