void Gn2DMeshObject::SetFlipX(bool val)
{
if( GetFlipX() != val )
{
SetVectorExtraDataFlipX();
}
mpMesh->setFlipX( val );
SetPosition( GetOriginalPosition() );
if( GetAVData() )
{
if( val )
{
GetAVData()->FlipX( val, GetOriginalPosition().x );
}
else
{
GetAVData()->FlipX( val, GetOriginalPosition().x );
}
}
//if( mpsAVData )
//{
// if( mpMesh->isFlipX() )
// {
// mpMesh->setPosition( GetOriginalPosition() - GetAVData()->GetAnchorPoint() );
// }
// else
// {
// mpMesh->setPosition( GetOriginalPosition() + GetAVData()->GetAnchorPoint() );
// }
//}
}
int audio_get(request * req, int video_type)
{
AV_DATA av_data;
int ret;
if (req->audio_book == 0) {
GetAVData(AV_OP_GET_ULAW_SERIAL, -1, &av_data );
if (av_data.serial <= req->audio_lock) {
dbg("av_data.serial <= req->audio_lock!!!\n");
req->busy_flag &= ~BUSY_FLAG_AUDIO;
return 0;
}
req->audio_book = av_data.serial;
}
ret = GetAVData(AV_OP_LOCK_ULAW, req->audio_book, &av_data );
if (ret == RET_SUCCESS) {
extern int CheckAudioStatus(void);
if (req->audio_lock > 0) {
GetAVData(AV_OP_UNLOCK_ULAW, req->audio_lock, NULL);
req->audio_lock = 0;
}
if(CheckAudioStatus())
{
req->data_mem = av_data.ptr;
}else{
static int IsFirst = 1;
if(IsFirst)
{
IsFirst = 0;
memset(AUDIO_MUTE_ARRAY,0xff,sizeof(AUDIO_MUTE_ARRAY));
}
req->data_mem = AUDIO_MUTE_ARRAY;
}
req->filesize = av_data.size;
req->filepos = 0;
req->audio_lock = av_data.serial;
req->audio_book = av_data.serial + 1;
req->audio_sync = av_data.ref_serial[video_type];
reset_output_buffer(req);
req_write(req, "\r\n");
print_audio_headers(req);
return 1;
}
else if (ret == RET_NO_VALID_DATA) {
req->busy_flag &= ~BUSY_FLAG_AUDIO;
return 0;
}
else {
req->audio_book = 0;
dbg("ERROR, ret=%d\n", ret);
return -1;
}
}
void Gn2DMeshObject::SetVectorExtraDataFlipX()
{
if( GetAVData() && GetAVData()->GetCollisionCount() )
{
float* point;
GnVector2ExtraData* vector2Extra;
for( gtuint i = 0; i < GetExtraDataSize(); i++ )
{
vector2Extra = GnDynamicCast( GnVector2ExtraData, GetExtraData( i ) );
if( vector2Extra )
{
Gn2DAVData::CollisionRect& baseRect = GetAVData()->GetOriginalCollisionRect( 0 );
float flip = baseRect.mRect.left + baseRect.mRect.right;
point = vector2Extra->GetValue();
point[0] = flip - point[0];
vector2Extra->SetValue( point );
}
}
}
}
int audio_get(request * req)
{
AV_DATA av_data;
int ret;
if (req->audio_book == 0) {
GetAVData(AV_OP_GET_ULAW_SERIAL, -1, &av_data );
if (av_data.serial <= req->audio_lock) {
dbg("av_data.serial <= req->audio_lock!!!\n");
req->busy_flag &= ~BUSY_FLAG_AUDIO;
return 0;
}
req->audio_book = av_data.serial;
}
ret = GetAVData(AV_OP_LOCK_ULAW, req->audio_book, &av_data );
if (ret == RET_SUCCESS) {
if (req->audio_lock > 0)
GetAVData(AV_OP_UNLOCK_ULAW, req->audio_lock, NULL);
if (req->audio_length + av_data.size > SOCKETBUF_SIZE)
req->audio_length = 0;
memcpy(req->audio_data+req->audio_length, av_data.ptr, av_data.size);
req->audio_length += av_data.size;
req->audio_lock = av_data.serial;
req->audio_book = av_data.serial + 1;
//dbg("av_data.serial = %d, av_data.size = %d\n", av_data.serial, av_data.size);
return 1;
}
else if (ret == RET_NO_VALID_DATA) {
req->busy_flag &= ~BUSY_FLAG_AUDIO;
return 0;
}
else {
req->audio_book = 0;
dbg("ERROR, ret=%d\n", ret);
return -1;
}
}
void Gn2DMeshObject::SetPosition(GnVector2 val)
{
SetOriginalPosition( val );
if( GetAVData() )
{
if( mpMesh->isFlipX() )
{
val = GetOriginalPosition() - GetAVData()->GetImageCenter();
mpMesh->setPosition( CCPointMake(val.x, val.y) );
}
else
{
mpMesh->setPosition( CCPointMake(val.x, val.y) );
}
GetAVData()->Move( GetOriginalPosition() );
}
else
{
mpMesh->setPosition( CCPointMake(val.x, val.y) );
}
}
/**
* @brief Save specific JPEG file to JPG_PATH.
*
* @param iSerial [I ] Serial number in Appro interface.
* @param pFilePath [O ] File name.
* @return Error code from Appro interface.
* @retval -1028 File create fail.
*/
int SaveJpegBySerial(int iSerial, char *pFilePath)
{
int ret = 0;
AV_DATA tAVData;
int fd;
char strJpegFile[JPG_PATH_LEN];
if((ret = GetAVData(AV_OP_LOCK_MJPEG, iSerial, &tAVData)) != RET_SUCCESS)
return ret;
GenerateJpegFileName(pFilePath);
sprintf(strJpegFile, "%s/%s", TEMP_FOLDER, pFilePath);
fd = open(strJpegFile, O_CREAT | O_TRUNC | O_WRONLY, 0666);
if(fd){
if(write(fd, tAVData.ptr, tAVData.size) != tAVData.size)
JPG_ERR("File write fail\n");
fsync(fd);
posix_fadvise(fd, 0,0, POSIX_FADV_DONTNEED );
close(fd);
} else {
JPG_ERR("File open fail\n");
ret = -1028;
}
GetAVData(AV_OP_UNLOCK_MJPEG, iSerial, &tAVData);
return ret;
}
int process_get(request * req)
{
int bytes_written;
volatile int bytes_to_write;
bytes_to_write = req->filesize - req->filepos;
if (bytes_to_write > SOCKETBUF_SIZE)
bytes_to_write = SOCKETBUF_SIZE;
if (sigsetjmp(env, 1) == 0) {
handle_sigbus = 1;
#ifdef SERVER_SSL
if(req->ssl == NULL){
#endif /*SERVER_SSL*/
bytes_written = write(req->fd, req->data_mem + req->filepos,
bytes_to_write);
#ifdef SERVER_SSL
}else{
bytes_written = SSL_write(req->ssl, req->data_mem + req->filepos, bytes_to_write);
#if 0
printf("SSL_write\n");
#endif /*0*/
}
#endif /*SERVER_SSL*/
handle_sigbus = 0;
/* OK, SIGBUS **after** this point is very bad! */
} else {
/* sigbus! */
log_error_doc(req);
/* sending an error here is inappropriate
* if we are here, the file is mmapped, and thus,
* a content-length has been sent. If we send fewer bytes
* the client knows there has been a problem.
* We run the risk of accidentally sending the right number
* of bytes (or a few too many) and the client
* won't be the wiser.
*/
req->status = DEAD;
fprintf(stderr, "%sGot SIGBUS in write(2)!\n", get_commonlog_time());
return 0;
}
if (bytes_written < 0) {
if (errno == EWOULDBLOCK || errno == EAGAIN)
return -1;
/* request blocked at the pipe level, but keep going */
else {
if (errno != EPIPE) {
log_error_doc(req);
/* Can generate lots of log entries, */
perror("write");
/* OK to disable if your logs get too big */
}
req->status = DEAD;
return 0;
}
}
req->filepos += bytes_written;
req->busy_flag = BUSY_FLAG_AUDIO|BUSY_FLAG_VIDEO;
if (req->filepos == req->filesize) { /* EOF */
#ifdef DAVINCI_IPCAM
if (req->http_stream == URI_STREAM_MJPEG) {
#if 1
#if 0
while (audio_get(req) > 0);
if (req->audio_length >= AUDIO_SEND_SIZE) {
audio_send(req);
return 1;
}
#else
if (audio_get(req, FMT_MJPEG) > 0)
return 1;
#endif
#else
req->busy_flag &= ~BUSY_FLAG_AUDIO;
#endif
if (req->serial_lock) {
GetAVData(AV_OP_UNLOCK_MJPEG, req->serial_lock, NULL);
req->serial_lock = 0;
}
GetAVData(AV_OP_GET_MJPEG_SERIAL, -1, &req->av_data);
if (req->av_data.serial < req->serial_book) {
req->busy_flag &= ~BUSY_FLAG_VIDEO;
return 1;
}
GetAVData(AV_OP_LOCK_MJPEG, req->av_data.serial, &req->av_data );
req->data_mem = req->av_data.ptr;
req->filesize = req->av_data.size+16;
req->filepos = 0;
req->serial_lock = req->av_data.serial;
req->serial_book = req->av_data.serial+1;
reset_output_buffer(req);
req_write(req, "\r\n");
print_mjpeg_headers(req);
return 1;
}
if (req->http_stream == URI_STREAM_MPEG4 || req->http_stream == URI_STREAM_AVC) {
int ret;
#if 1
#if 0
while (audio_get(req) > 0);
if (req->audio_length > AUDIO_SEND_SIZE) {
req->busy_flag |= BUSY_FLAG_AUDIO;
audio_send(req);
return 1;
}
#else
if (audio_get(req, FMT_MPEG4) > 0)
return 1;
#endif
#else
req->busy_flag &= ~BUSY_FLAG_AUDIO;
#endif
ret = GetAVData(AV_OP_LOCK_MP4, req->serial_book, &req->av_data);
if (ret == RET_SUCCESS) {
GetAVData(AV_OP_UNLOCK_MP4, req->serial_lock, NULL);
req->data_mem = req->av_data.ptr;
req->filesize = req->av_data.size+16;
req->filepos = 0;
req->serial_lock = req->av_data.serial;
req->serial_book = req->av_data.serial+1;
reset_output_buffer(req);
req_write(req, "\r\n");
if (req->http_stream == URI_STREAM_AVC)
{ print_avc_headers(req); }
else
{ print_mpeg4_headers(req); }
return 1;
}
else if (ret == RET_NO_VALID_DATA) {
req->busy_flag &= ~BUSY_FLAG_VIDEO;
return 1;
}
else {
GetAVData(AV_OP_GET_MPEG4_SERIAL, -1, &req->av_data );
req->serial_book = req->av_data.serial;
dbg("lock error ret=%d\n", ret);
return 1;
}
}
if (req->http_stream == URI_STREAM_MPEG4CIF || req->http_stream == URI_STREAM_AVCCIF) {
int ret;
#if 1
#if 0
while (audio_get(req) > 0);
if (req->audio_length > AUDIO_SEND_SIZE) {
audio_send(req);
return 1;
}
#else
if (audio_get(req, FMT_MPEG4_EXT) > 0)
return 1;
#endif
#else
req->busy_flag &= ~BUSY_FLAG_AUDIO;
#endif
ret = GetAVData(AV_OP_LOCK_MP4_CIF, req->serial_book, &req->av_data);
if (ret == RET_SUCCESS) {
GetAVData(AV_OP_UNLOCK_MP4_CIF, req->serial_lock, NULL);
req->data_mem = req->av_data.ptr;
req->filesize = req->av_data.size+16;
req->filepos = 0;
req->serial_lock = req->av_data.serial;
req->serial_book = req->av_data.serial+1;
reset_output_buffer(req);
req_write(req, "\r\n");
if (req->http_stream == URI_STREAM_AVCCIF)
{ print_avc_headers(req); }
else
{ print_mpeg4_headers(req); }
return 1;
}
else if (ret == RET_NO_VALID_DATA) {
req->busy_flag &= ~BUSY_FLAG_VIDEO;
return 1;
}
else {
GetAVData(AV_OP_GET_MPEG4_CIF_SERIAL, -1, &req->av_data );
req->serial_book = req->av_data.serial;
dbg("lock error ret=%d\n", ret);
return 1;
}
}
#endif // DAVINCI_IPCAM
return 0;
} else
return 1; /* more to do */
}
/**
* @brief Save some JPEG files.
*
* @retval 0 Success.
* @param nDstFlg [I ] Where JPEG will save.
* @retval -1 Fail.
*/
int SaveJpeg(int nDstFlg)
{
int ret = 0, i, iSerial, nCount, nState;
int j, nSleepCount;
unsigned int nTime, nDiffTime;
char strFileName[80];
char JpegFiles[JPEG_COUNT][JPG_PATH_LEN];
AV_DATA tAVData;
JPG_DBG("Enter %s\n", __func__);
if((ret = GetAVData(AV_OP_GET_MJPEG_SERIAL, -1, &tAVData)) != 0){
JPG_ERR("Can't get JPEG image\n");
return ret;
}
/* If JpegStartSerial < 0 or JpegStartSerial is very old. */
if((iSerial = GetJpegStartSerial()) < 0 || tAVData.serial - iSerial > 40){
iSerial = tAVData.serial;
} else {
GetAVData(AV_OP_GET_MJPEG_SERIAL, iSerial, &tAVData);
}
nTime = tAVData.timestamp;
nCount = pSysinfo->smtp_config.attachments;
JPG_DBG("Count:%d\n", nCount);
nSleepCount = 200 / nCount;
nDiffTime = 10000 / nCount;
for(i = 0;i < nCount;){
JPG_DBG("Serial = %d\n", iSerial);
if(SaveJpegBySerial(iSerial, JpegFiles[i]) == 0){
i++;
} else
JPG_DBG("Not save\n");
nState = GetJpgState(JPG_STOP);
if(nState & JPG_STOP){
JPG_DBG("JPG_STOP flag is set\n");
break;
}
/* Get new JPEG */
if(nState & JPG_SERIAL_UPDATE){
iSerial = GetJpegStartSerial();
GetAVData(AV_OP_GET_MJPEG_SERIAL, iSerial, &tAVData);
nTime = tAVData.timestamp;
} else
nTime += nDiffTime;
j = 0;
while(nTime > tAVData.timestamp && j++ < nSleepCount){
usleep(100000);
GetAVData(AV_OP_GET_MJPEG_SERIAL, -1, &tAVData);
}
if(j > nSleepCount){
JPG_DBG("Time out!!!\n");
ret = -1;
break;
}
iSerial = tAVData.serial;
}
if(i > 0){
strcpy(strFileName, JpegFiles[0]);
strcpy(strFileName + strlen(strFileName) - 3, "cfg");
GenerateJpgConfigFile(JpegFiles, strFileName, i);
DoFileDispatch(strFileName, nDstFlg);
}
/* Update JPEG start serial */
pthread_mutex_lock(&gJpgMutex);
if(!(gJpgState & JPG_SERIAL_UPDATE))
gJpgStartSerial = iSerial;
pthread_mutex_unlock(&gJpgMutex);
return ret;
}
