/*!-----------------------------------------------------------------------
s e m a p h o r e P o s t
@brief Perform a "post" operation on a semaphore.
This function will perform a "post" operation on a semaphore object
(similar to a "signal" on a mutex). This operation will increment the
semaphore's count value and if there are any processes waiting on this
semahore, one (or possibly more) of them will be released and allowed to
run. Under normal conditions, only one waiting process will be released
when this signal occurs but there is a very small window in which more
than one could be released. This is not a problem - See the man page for
pthread_cond_signal.
That this code assumes that the semaphore object to be operated on already
exists and has been mapped into this process's shared memory segment. The
semaphore must already have been initialized as well.
@param[in] semaphore - The address of the semaphore object to operate on.
------------------------------------------------------------------------*/
void semaphorePost ( semaphore_p semaphore )
{
int status;
//
// If the semaphore count is at 0 then someone may be currently waiting
// on this semaphore so just signal the condition variable to indicate
// that the resource is available and release the process(s) that are
// waiting.
//
LOG ( "%'lu Before semaphore broadcast of %p:\n", getIntervalTime(),
semaphore );
SEM_DUMP ( semaphore );
status = pthread_cond_broadcast ( &semaphore->conditionVariable );
if ( status != 0 )
{
printf ( "Unable to broadcast to condition variable - "
"errno: %u[%s].\n", status, strerror(status) );
}
LOG ( "%'lu After semaphore broadcast of %p:\n", getIntervalTime(),
semaphore );
SEM_DUMP ( semaphore );
}
void semaphoreWait ( semaphore_p semaphore )
{
int status;
//
// If the semaphore count is at 0 then the resource is not available so
// we need to wait for it to become available. This is done in a "while"
// loop because we could be released spuriously due to a very small
// windown in the semaphore code that results in more than one process
// being released at times. By checking the semaphore again after being
// released, we guarantee that only one process will actually acquire the
// semaphore.
//
LOG ( "%'lu Before semaphore wait on %p:\n", getIntervalTime(),
semaphore );
SEM_DUMP ( semaphore );
while ( semaphore->messageCount == 0 )
{
LOG ( "%'lu In semaphore while[%p] - waiterCount: %d, messageCount: %d\n",
getIntervalTime(), semaphore, semaphore->waiterCount,
semaphore->messageCount );
//
// Install the cancellation cleanup handler function.
//
pthread_cleanup_push ( semaphoreCleanupHandler, &semaphore->mutex );
status = pthread_cond_wait ( &semaphore->conditionVariable,
&semaphore->mutex );
if ( status != 0 )
{
printf ( "Unable to wait on condition variable - "
"errno: %u[%s].\n", status, strerror(status) );
}
//
// Release the cancellation cleanup handler function.
//
pthread_cleanup_pop ( 0 );
}
LOG ( "%'lu After semaphore wait on %p:\n", getIntervalTime(),
semaphore );
SEM_DUMP ( semaphore );
}
/*==============================================================================
函数: <pkg_placed_in_frame>
功能: <组帧>
参数: int8_t *frame_data, int32_t part_frame_len, stream_handle *M_handle
返回值: 成功返回1，失败返回0.
Created By liuchsh 2012.11.16 15:40:28 For EDU
==============================================================================*/
int32_t pkg_placed_in_frame(int8_t *frame_data, int32_t part_frame_len, stream_handle *M_handle)
{
hdb_freame_head_t *fh = (hdb_freame_head_t *)frame_data;
int32_t return_code = OPERATION_SUCC;
uint32_t current_time = 0;
uint32_t video_cal_time = 0, video_cal_sys_time = 0;
if(NULL == M_handle || NULL == frame_data) {
nslog(NS_ERROR, "M_handle = %p, frame_data = %p", M_handle, frame_data);
return OPERATION_ERR;
}
#if 1
current_time = getCurrentTime();
if(0 >= M_handle->recv_time_t.init_video_flag) {
M_handle->recv_time_t.video_init_time = fh->m_time_tick;
M_handle->recv_time_t.init_video_flag = 1;
M_handle->recv_time_t.video_cal_time = 0;
M_handle->recv_time_t.prev_video_time_tick = fh->m_time_tick;
nslog(NS_INFO, "init video_flag id=%d", M_handle->stream_id);
}
if(fh->m_time_tick > M_handle->recv_time_t.video_init_time) {
video_cal_time = fh->m_time_tick - M_handle->recv_time_t.video_init_time;
} else {
video_cal_time = M_handle->recv_time_t.video_init_time - fh->m_time_tick;
}
if(H264_CODEC_TYPE == fh->m_data_codec) {
if(fh->m_time_tick < M_handle->recv_time_t.prev_video_time_tick ||
(fh->m_time_tick > M_handle->recv_time_t.prev_video_time_tick &&
(fh->m_time_tick - M_handle->recv_time_t.prev_video_time_tick) > EXAMIN_TIME) &&
M_handle->av_connect_flag == 0) {
M_handle->recv_time_t.time_video_tick = M_handle->recv_time_t.time_video_tick + getIntervalTime(M_handle->recv_time_t.prev_video_time, current_time);
M_handle->recv_time_t.video_init_time = fh->m_time_tick;
M_handle->recv_time_t.video_cal_time = M_handle->recv_time_t.time_video_tick;
nslog(NS_WARN, "video:time_cal = %u, current_time = %u,vo_init_time = %u, tm_vo_tick = %u, vo_cal_time=%u, gap_time = %uid = %d",
video_cal_time,
current_time,
M_handle->recv_time_t.video_init_time,
M_handle->recv_time_t.time_video_tick,
M_handle->recv_time_t.video_cal_time,
M_handle->recv_time_t.prev_video_time_tick - current_time,
M_handle->stream_id);
} else {
M_handle->av_connect_flag == 0;
M_handle->recv_time_t.time_video_tick = video_cal_time + M_handle->recv_time_t.video_cal_time;
}
}
if(JPEG_CODEC_TYPE == fh->m_data_codec) {
if(fh->m_time_tick < M_handle->recv_time_t.prev_video_time_tick) {
M_handle->recv_time_t.time_video_tick = M_handle->recv_time_t.time_video_tick + getJpgIntervalTime(M_handle->recv_time_t.prev_video_time, current_time);
M_handle->recv_time_t.video_init_time = fh->m_time_tick;
M_handle->recv_time_t.video_cal_time = M_handle->recv_time_t.time_video_tick;
nslog(NS_WARN, "JPG:time_cal = %u, prev_video_time_cal = %u, time_video_tick = %u, video_cal_time=%u, id = %d",
video_cal_time,
M_handle->recv_time_t.prev_video_time_tick,
M_handle->recv_time_t.time_video_tick,
M_handle->recv_time_t.video_cal_time,
M_handle->stream_id);
} else {
M_handle->recv_time_t.time_video_tick = video_cal_time + M_handle->recv_time_t.video_cal_time;
}
}
M_handle->recv_time_t.prev_video_time_tick = fh->m_time_tick;
M_handle->recv_time_t.prev_video_time = current_time;
#endif
switch(fh->m_dw_segment) {
case START_FRAME:
if(fh->m_frame_length > MAX_FRAME_LEN) {
nslog(NS_ERROR, "fh->m_frame_length : [%d]", fh->m_frame_length);
return_code = OPERATION_ERR;
break;
}
if(((M_handle->offset) + part_frame_len) > fh->m_frame_length) {
M_handle->offset = 0;
return_code = OPERATION_ERR;
nslog(NS_WARN, "(M_handle->offset)+ part_frame_len = %d fh->m_frame_length = %d, id = %d", (M_handle->offset) + part_frame_len, fh->m_frame_length, M_handle->stream_id);
break;
}
M_handle->offset = 0;
r_memcpy(M_handle->frame_data, frame_data + FH_LEN, part_frame_len);
M_handle->offset += part_frame_len;;
return_code = OPERATION_SUCC;
break;
case MIDDLE_FRAME: //0表示中间包
if(M_handle->offset + part_frame_len > fh->m_frame_length) {
M_handle->offset = 0;
return_code = OPERATION_SUCC;
nslog(NS_WARN, "(M_handle->offset)+ part_frame_len = %d fh->m_frame_length = %d, id = %d", (M_handle->offset) + part_frame_len, fh->m_frame_length, M_handle->stream_id);
break;
}
r_memcpy(M_handle->frame_data + M_handle->offset, frame_data + FH_LEN, part_frame_len);
M_handle->offset += part_frame_len;
return_code = OPERATION_SUCC;
break;
case LAST_FRAME: //表示结尾包
if(M_handle->offset + part_frame_len > fh->m_frame_length) {
M_handle->offset = 0;
return_code = OPERATION_SUCC;
nslog(NS_WARN, "(M_handle->offset)+ part_frame_len = %d fh->m_frame_length = %d, id = %d", (M_handle->offset) + part_frame_len, fh->m_frame_length, M_handle->stream_id);
break;
}
r_memcpy(M_handle->frame_data + M_handle->offset, frame_data + FH_LEN, part_frame_len);
M_handle->offset = 0;
return_code = OPERATION_CONTINUE;
break;
case INDEPENDENT_FRAME:
r_memcpy(M_handle->frame_data, frame_data + FH_LEN, fh->m_frame_length);
return_code = OPERATION_CONTINUE;
break;
default:
nslog(NS_WARN, "fh->m_dw_segment : [%d]", fh->m_dw_segment);
return_code = OPERATION_SUCC;
break;
}
return return_code;
}
