/*****************************************************************************
* main
*****************************************************************************/
int main(int i_argc, char* pa_argv[])
{
int i_fd;
uint8_t data[188];
dvbpsi_handle h_dvbpsi;
int b_ok;
if(i_argc != 2)
return 1;
i_fd = open(pa_argv[1], 0);
h_dvbpsi = dvbpsi_AttachDemux(NewSubtableBAT, NULL);
b_ok = ReadPacket(i_fd, data);
while(b_ok)
{
uint16_t i_pid = ((uint16_t)(data[1] & 0x1f) << 8) + data[2];
if(i_pid == 0x11)
dvbpsi_PushPacket(h_dvbpsi, data);
b_ok = ReadPacket(i_fd, data);
}
dvbpsi_DetachDemux(h_dvbpsi);
return 0;
}
static void receive_avstream(conn* conn)
{
#define RTP_HEADER_SIZE 12
#define PACKET_SIZE 188
unsigned char payload[PACKET_SIZE + RTP_HEADER_SIZE] = {0};
for(;;) {
int nread = recvfrom(conn->sockfd, (void *)payload, sizeof(payload), 0, ( struct sockaddr *)&conn->serveraddr, (socklen_t *)&conn->client_addr_len);
if(nread < 0) { // timeout
ERR("no stream");
continue;
}
if(nread != PACKET_SIZE + RTP_HEADER_SIZE) {
ERR("rtp: %d / %d", nread, PACKET_SIZE + RTP_HEADER_SIZE);
H_(payload, 16);
}
else {
fprintf(stderr, "@\r");
#if (RTP_HEADER_SIZE == 12)
memmove(payload, &payload[12], 188);
#endif
KASSERT(payload[0] == 0x47);
unsigned short pid = ((uint16_t)(payload[1] & 0x1f) << 8) + payload[2];
if(pid == 0) { // PAT
dvbpsi_PushPacket(conn->hdvbpsi, payload);
}
}
// H_(payload, 16);
}
leave(conn);
}
bool scan_session_Push( scan_session_t *p_scan, block_t *p_block )
{
if( p_block->i_buffer < 188 || p_block->p_buffer[0] != 0x47 )
{
block_Release( p_block );
return false;
}
/* */
const int i_pid = ( (p_block->p_buffer[1]&0x1f)<<8) | p_block->p_buffer[2];
if( i_pid == 0x00 )
{
if( !p_scan->pat )
p_scan->pat = dvbpsi_AttachPAT( (dvbpsi_pat_callback)PATCallBack, p_scan );
if( p_scan->pat )
dvbpsi_PushPacket( p_scan->pat, p_block->p_buffer );
}
else if( i_pid == 0x11 )
{
if( !p_scan->sdt )
p_scan->sdt = dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack, p_scan );
if( p_scan->sdt )
dvbpsi_PushPacket( p_scan->sdt, p_block->p_buffer );
}
else if( i_pid == p_scan->i_nit_pid )
{
#ifdef DVBPSI_USE_NIT
if( !p_scan->nit )
p_scan->nit = dvbpsi_AttachDemux( (dvbpsi_demux_new_cb_t)PSINewTableCallBack, p_scan );
if( p_scan->nit )
dvbpsi_PushPacket( p_scan->nit, p_block->p_buffer );
#endif
}
block_Release( p_block );
return p_scan->p_pat && p_scan->p_sdt &&
#ifdef DVBPSI_USE_NIT
p_scan->p_nit;
#else
true;
#endif
}
bool DvbPatLoader::ProcessPacket(uint8_t* data)
{
uint16_t i_pid = ((uint16_t) (data[1] & 0x1f) << 8) + data[2];
if (i_pid == 0x0)
{
dvbpsi_PushPacket(m_dvbpsi, data);
return true;
}
}
static void TSHandle( uint8_t *p_ts )
{
uint16_t i_pid = ts_GetPID( p_ts );
int i;
if ( !ts_CheckSync( p_ts ) )
{
fprintf( stderr, "lost TS synchro, go and fix your file (pos=%ju)\n",
(uintmax_t)i_ts_read * TS_SIZE );
exit(EXIT_FAILURE);
}
if ( i_pid == 0 && !i_nb_programs )
{
dvbpsi_PushPacket( p_pat_dvbpsi_fd, p_ts );
}
for ( i = 0; i < i_nb_programs; i++ )
{
if ( pi_pmt_pids[i] == i_pid )
dvbpsi_PushPacket( p_pmt_dvbpsi_fds[i], p_ts );
}
}
/*****************************************************************************
* main
*****************************************************************************/
int main(int i_argc, char* pa_argv[])
{
int i_fd;
uint8_t data[188];
dvbpsi_t *p_dvbpsi;
bool b_ok;
if(i_argc != 2)
return 1;
i_fd = open(pa_argv[1], 0);
if (i_fd < 0)
return 1;
p_dvbpsi = dvbpsi_NewHandle(&message, DVBPSI_MSG_DEBUG);
if (p_dvbpsi == NULL)
goto out;
if (!dvbpsi_AttachDemux(p_dvbpsi, NewSubtable, NULL))
goto out;
b_ok = ReadPacket(i_fd, data);
while(b_ok)
{
uint16_t i_pid = ((uint16_t)(data[1] & 0x1f) << 8) + data[2];
if(i_pid == 0x11)
dvbpsi_PushPacket(p_dvbpsi, data);
b_ok = ReadPacket(i_fd, data);
}
out:
if (p_dvbpsi)
{
dvbpsi_DetachDemux(p_dvbpsi);
dvbpsi_DeleteHandle(p_dvbpsi);
}
close(i_fd);
return 0;
}
DemuxPacket* CDVDDemuxSMD::Read()
{
ismd_result_t result = ISMD_SUCCESS;
ismd_port_status_t port_status;
ismd_buffer_handle_t buffer = ISMD_BUFFER_HANDLE_INVALID;
ismd_buffer_descriptor_t buffer_desc;
char data_buffer[READ_SIZE];
int data_buffer_size = 0;
unsigned int amount_to_read;
unsigned int amount_read = 0;
char *virtual_buffer_address = NULL;
bool full = false;
uint8_t *chunk;
ismd_es_buf_attr_t *buf_attrs;
char buf[READ_SIZE];
DemuxPacket* pPacket = NULL;
int packets_num;
const std::vector<DvbTunerPtr>& tuners = DVBManager::GetInstance().GetTuners();
amount_to_read = READ_SIZE;
amount_read = m_pInput->Read((BYTE *) buf, amount_to_read);
// no use to continue if we're not tuned
if (tuners[0]->GetTuningState() != DvbTuner::TUNING_STATE_TUNED)
{
Stop();
goto end;
}
if(!tuners[0]->IsSignalOk())
{
Stop();
goto end;
}
if (amount_read == 0)
{
//CLog::Log(LOGWARNING, "CDVDDemuxSMD::Read time out");
goto end;
}
if (amount_read == -1 && tuners[0]->GetTuningState() == DvbTuner::TUNING_STATE_TUNED)
{
CLog::Log(LOGERROR, "CDVDDemuxSMD::Read amount_read is -1 while tuning");
goto end;
}
if (amount_read % 188 != 0 && tuners[0]->GetTuningState() == DvbTuner::TUNING_STATE_TUNED)
CLog::Log(LOGWARNING, "CDVDDemuxSMD:Read: amount_read % 188 != 0 (%d)", amount_read);
if(tuners[0]->GetTuningState() == DvbTuner::TUNING_STATE_TUNED)
Start();
if(m_lastPatStopWatch.GetElapsedMilliseconds() > PAT_TIMEOUT)
{
CLog::Log(LOGWARNING, "CDVDDemuxSMD:Read: timeout for PAT. Reopening DVR");
tuners[0]->RemoveAllPidFilters();
m_lastPatStopWatch.StartZero();
}
chunk = (uint8_t*) buf;
packets_num = amount_read / 188;
for (int i = 0; i < packets_num; i++)
{
if (chunk[0] != 0x47)
{
CLog::Log(LOGWARNING, "CDVDDemuxSMD::Read sync byte is not 0x47 (%02X)", chunk[0]);
chunk += 188;
continue;
}
uint16_t chunkPid = ((uint16_t) (chunk[1] & 0x1f) << 8) + chunk[2];
if (chunkPid == PAT_PID && m_state == DEMUX_STATE_IDLE)
{
dvbpsi_PushPacket(dvbpsiPAT, chunk);
}
else if (chunkPid == m_pmtPid && m_state == DEMUX_STATE_FOUND_PAT)
{
dvbpsi_PushPacket(dvbpsiPMT, chunk);
}
else if (m_state == DEMUX_STATE_FOUND_PMT)
{
if (m_nAudioCodec == CODEC_ID_NONE)
CLog::Log(LOGWARNING, "CDVDDemuxSMD::Read audio codec not found");
if (m_nVideoCodec == CODEC_ID_NONE)
CLog::Log(LOGWARNING, "CDVDDemuxSMD::Read video codec not found");
if (m_pcrPid == -1)
CLog::Log(LOGWARNING, "CDVDDemuxSMD::Read PCR not found");
SetState(DEMUX_STATE_RUNNING);
CLog::Log(LOGINFO,"CDVDDemuxSMD::Read Audio PID %d Video PID %d Audio Codec %d Video Codec %d PCR %d\n",
m_nAudioPID, m_nVideoPID, m_nAudioCodec, m_nVideoCodec, m_pcrPid);
StartDemuxer();
}
else if (chunkPid == EIT_PID && tuners[0]->GetTunerType() == DvbTuner::TUNER_TYPE_DVBT)
{
if(m_epgLoader)
m_epgLoader->ProcessPacket(chunk);
}
else if (chunkPid == m_nVideoPID || chunkPid == m_nAudioPID)
{
if (chunkPid == m_nVideoPID)
m_videoStats.AddSampleBytes(188 - 4);
if (chunkPid == m_nAudioPID)
m_audioStats.AddSampleBytes(188 - 4);
OS_MEMCPY(data_buffer + data_buffer_size, chunk, 188);
data_buffer_size += 188;
if (data_buffer_size > BUFFER_SIZE)
{
CLog::Log(LOGERROR, "CDVDDemuxSMD::Read data_buffer_size is too big: %d", data_buffer_size);
goto end;
}
}
chunk += 188;
}
// no video/audio data was found, nothing to push into SMD
if (data_buffer_size == 0)
{
goto end;
}
if(m_state != DEMUX_STATE_RUNNING)
{
goto end;
}
result = ismd_port_get_status(m_demux_input_port, &port_status);
if (result != ISMD_SUCCESS)
{
CLog::Log(LOGERROR, "CDVDDemuxSMD:Read: ismd_port_get_status failed %d", result);
goto end;
}
else
{
full = port_status.cur_depth >= port_status.max_depth;
}
// if port/queue has no space
if (full)
{
// wait for the port event - this will indicate when there is space
result = ismd_event_wait(m_reading_thread_port_event, 100);
ismd_event_acknowledge(m_reading_thread_port_event);
if (result == ISMD_SUCCESS || result == ISMD_ERROR_TIMEOUT)
{
if (result == ISMD_ERROR_TIMEOUT)
{
CLog::Log(LOGWARNING, "CDVDDemuxSMD::Read Demux is full");
goto end;
}
}
else
{
CLog::Log(LOGERROR, "CDVDDemuxSMD::Read ismd_event_wait failed on reading_thread_port_event %d", result);
goto end;
}
}
// get buffer
buffer = ISMD_BUFFER_HANDLE_INVALID;
result = ismd_buffer_alloc(BUFFER_SIZE, &buffer);
if (result != ISMD_SUCCESS)
{
CLog::Log(LOGERROR, "CDVDDemuxSMD::Read ismd_buffer_alloc failed %d", result);
goto end;
}
result = ismd_buffer_read_desc(buffer, &buffer_desc);
if (result != ISMD_SUCCESS)
{
CLog::Log(LOGERROR, "CDVDDemuxSMD::Read ismd_buffer_read_desc failed %d", result);
ismd_buffer_dereference(buffer);
goto end;
}
virtual_buffer_address = (char*)OS_MAP_IO_TO_MEM_NOCACHE(buffer_desc.phys.base, buffer_desc.phys.size);
OS_MEMCPY(virtual_buffer_address, data_buffer, data_buffer_size);
buf_attrs = (ismd_es_buf_attr_t *) buffer_desc.attributes;
buffer_desc.phys.level = data_buffer_size;
buf_attrs->original_pts = 0;
buf_attrs->local_pts = ISMD_NO_PTS;
buf_attrs->discontinuity = false;
result = ismd_buffer_update_desc(buffer, &buffer_desc);
if (result != ISMD_SUCCESS)
{
CLog::Log(LOGERROR, "CDVDDemuxSMD::Read ismd_buffer_update_desc failed %d", result);
ismd_buffer_dereference(buffer);
goto end;
}
OS_UNMAP_IO_FROM_MEM(virtual_buffer_address, buffer_desc.phys.size);
result = ismd_port_write(m_demux_input_port, buffer);
if (result != ISMD_SUCCESS)
{
CLog::Log(LOGERROR, "CDVDDemuxSMD::Read ismd_port_write failed %d", result);
ismd_buffer_dereference(buffer);
goto end;
}
// we wait until first frame show up and then unmute the renderer
if (!m_bFirstFrame)
{
ismd_vidrend_stream_position_info_t info;
ismd_vidrend_get_stream_position(g_IntelSMDGlobals.GetVidRender(), &info);
if (info.flip_time != ISMD_NO_PTS)
{
g_IntelSMDGlobals.MuteVideoRender(false);
m_bFirstFrame = true;
}
}
// look for video changes
ConfigureVideo();
end:
pPacket = CDVDDemuxUtils::AllocateDemuxPacket(0);
pPacket->flags |= DEMUX_PACKET_FLAG_PASSTHROUGH;
return pPacket;
}
