// When this is running, no member variable should be accessed
// from other threads
status_t
MovieEncoder::_EncoderThread()
{
int32 framesLeft = fFileList->CountItems();
int32 framesWritten = 0;
if (framesLeft <= 0) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)B_ERROR);
fMessenger.SendMessage(&message);
return B_ERROR;
}
// Create movie
entry_ref movieRef;
get_ref_for_path(fOutputFile.Path(), &movieRef);
BitmapEntry* entry = fFileList->ItemAt(0);
BBitmap* bitmap = entry->Bitmap();
BRect sourceFrame = bitmap->Bounds();
delete bitmap;
if (!fDestFrame.IsValid())
fDestFrame = sourceFrame.OffsetToCopy(B_ORIGIN);
// Calc the average time difference between the first 100 frames,
// and use it to calculate the framerate.
// TODO: Actually we could just calculate the number of frames and
// the time difference between the first and the last one.
/*int32 maxTimeStampNum = std::min((int32)100, fFileList->CountItems());
bigtime_t previousFrameTime = entry->TimeStamp();
bigtime_t diffSum = 0;
for (int32 i = 0; i < maxTimeStampNum; i++) {
BitmapEntry* entry = fFileList->ItemAt(i);
bigtime_t currentFrameTime = entry->TimeStamp();
diffSum += currentFrameTime - previousFrameTime;
previousFrameTime = currentFrameTime;
}
float medianDiffTime = diffSum / maxTimeStampNum;
*/
int32 numFrames = fFileList->CountItems();
BitmapEntry* firstEntry = fFileList->ItemAt(0);
BitmapEntry* lastEntry = fFileList->ItemAt(numFrames - 1);
int frameSeconds = (1000000 * numFrames) / (lastEntry->TimeStamp() - firstEntry->TimeStamp());
media_format inputFormat = fFormat;
inputFormat.u.raw_video.field_rate = frameSeconds;
status_t status = _CreateFile(movieRef, fFileFormat, inputFormat, fCodecInfo);
if (status < B_OK) {
DisposeData();
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
fMessenger.SendMessage(&message);
return status;
}
// Bitmap and view used to convert the source bitmap
// to the correct size and depth
BBitmap* destBitmap = new BBitmap(fDestFrame, fColorSpace, true);
BView* destDrawer = new BView(fDestFrame, "drawing view", B_FOLLOW_NONE, 0);
if (destBitmap->Lock()) {
destBitmap->AddChild(destDrawer);
destBitmap->Unlock();
}
const uint32 keyFrameFrequency = 10;
// TODO: Make this tunable
BMessage progressMessage(B_UPDATE_STATUS_BAR);
progressMessage.AddFloat("delta", 1.0);
destBitmap->Bounds().PrintToStream();
PrintMediaFormat(inputFormat);
status = B_OK;
while (BitmapEntry* entry = const_cast<FileList*>(fFileList)->Pop()) {
if (fKillThread)
break;
bool keyFrame = (framesWritten % keyFrameFrequency == 0);
BBitmap* frame = entry->Bitmap();
if (frame == NULL) {
// TODO: What to do here ? Exit with an error ?
std::cerr << "Error while loading bitmap entry" << std::endl;
delete entry;
continue;
}
// Draw scaled
if (status == B_OK) {
destBitmap->Lock();
destDrawer->DrawBitmap(frame, frame->Bounds(), destDrawer->Bounds());
destDrawer->Sync();
destBitmap->Unlock();
}
delete frame;
delete entry;
if (status == B_OK)
status = _WriteFrame(destBitmap, keyFrame);
if (status != B_OK)
break;
framesWritten++;
if (fMessenger.IsValid())
fMessenger.SendMessage(new BMessage(progressMessage));
else {
// BMessenger is no longer valid. This means that the application
// has been closed or it has crashed.
break;
}
}
delete destBitmap;
DisposeData();
if (fMessenger.IsValid()) {
BMessage message(kEncodingFinished);
message.AddInt32("status", (int32)status);
message.AddInt32("frames", (int32)framesWritten);
fMessenger.SendMessage(&message);
}
return status;
}
// DataHandler receives data from the server
void __cdecl DataHandler(sFrameOfMocapData* data, void* pUserData)
{
if (acommand.packet_counter != 4) {
acommand.packet_counter++;
return;
}
acommand.packet_counter = 0;
NatNetClient* pClient = (NatNetClient*) pUserData;
printf("Received frame %d\n", data->iFrame);
if(fp)
_WriteFrame(fp,data);
int i=0;
// same system latency test
float fThisTick = (float)GetTickCount();
float fDiff = fThisTick - data->fLatency;
double dDuration = fDiff;
printf("Latency (same system) (msecs): %3.2lf\n", dDuration);
// timecode
// decode to values
int hour, minute, second, frame, subframe;
bool bValid = pClient->DecodeTimecode(data->Timecode, data->TimecodeSubframe, &hour, &minute, &second, &frame, &subframe);
// decode to friendly string
char szTimecode[128] = "";
pClient->TimecodeStringify(data->Timecode, data->TimecodeSubframe, szTimecode, 128);
printf("Timecode : %s\n", szTimecode);
// Other Markers
printf("Other Markers [Count=%d]\n", data->nOtherMarkers);
for(i=0; i < data->nOtherMarkers; i++)
{
printf("Other Marker %d : %3.2f\t%3.2f\t%3.2f\n",
i,
data->OtherMarkers[i][0],
data->OtherMarkers[i][1],
data->OtherMarkers[i][2]);
}
// Rigid Bodies
printf("Rigid Bodies [Count=%d]\n", data->nRigidBodies);
double theta = calculate_angle(data->RigidBodies[0], data->RigidBodies[1], data->RigidBodies[2]);
double dist_calc = calculate_distance(data->RigidBodies[0], data->RigidBodies[3]);
printf("\n\n\nAngle is %Lf and distance is %Lf\n\n\n", theta*180/3.14, dist_calc);
for(i=0; i < data->nRigidBodies; i++)
{
//location_data[i] = data->RigidBodies[i];
printf("Rigid Body [ID=%d Error=%3.2f]\n", data->RigidBodies[i].ID, data->RigidBodies[i].MeanError);
printf("\tx\ty\tz\tqx\tqy\tqz\tqw\n");
printf("\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\n",
data->RigidBodies[i].x,
data->RigidBodies[i].y,
data->RigidBodies[i].z,
data->RigidBodies[i].qx,
data->RigidBodies[i].qy,
data->RigidBodies[i].qz,
data->RigidBodies[i].qw);
printf("\tRigid body markers [Count=%d]\n", data->RigidBodies[i].nMarkers);
for(int iMarker=0; iMarker < data->RigidBodies[i].nMarkers; iMarker++)
{
printf("\t\t");
if(data->RigidBodies[i].MarkerIDs)
printf("MarkerID:%d", data->RigidBodies[i].MarkerIDs[iMarker]);
if(data->RigidBodies[i].MarkerSizes)
printf("\tMarkerSize:%3.2f", data->RigidBodies[i].MarkerSizes[iMarker]);
if(data->RigidBodies[i].Markers)
printf("\tMarkerPos:%3.2f,%3.2f,%3.2f\n" ,
data->RigidBodies[i].Markers[iMarker][0],
data->RigidBodies[i].Markers[iMarker][1],
data->RigidBodies[i].Markers[iMarker][2]);
}
}
// skeletons
printf("Skeletons [Count=%d]\n", data->nSkeletons);
for(i=0; i < data->nSkeletons; i++)
{
sSkeletonData skData = data->Skeletons[i];
printf("Skeleton [ID=%d Bone count=%d]\n", skData.skeletonID, skData.nRigidBodies);
for(int j=0; j< skData.nRigidBodies; j++)
{
sRigidBodyData rbData = skData.RigidBodyData[j];
printf("Bone %d\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\n",
rbData.ID, rbData.x, rbData.y, rbData.z, rbData.qx, rbData.qy, rbData.qz, rbData.qw );
printf("\tRigid body markers [Count=%d]\n", rbData.nMarkers);
for(int iMarker=0; iMarker < data->RigidBodies[i].nMarkers; iMarker++)
{
printf("\t\t");
if(rbData.MarkerIDs)
printf("MarkerID:%d", rbData.MarkerIDs[iMarker]);
if(rbData.MarkerSizes)
printf("\tMarkerSize:%3.2f", rbData.MarkerSizes[iMarker]);
if(rbData.Markers)
printf("\tMarkerPos:%3.2f,%3.2f,%3.2f\n" ,
data->RigidBodies[i].Markers[iMarker][0],
data->RigidBodies[i].Markers[iMarker][1],
data->RigidBodies[i].Markers[iMarker][2]);
}
}
}
// labeled markers
printf("Labeled Markers [Count=%d]\n", data->nLabeledMarkers);
for(i=0; i < data->nLabeledMarkers; i++)
{
sMarker marker = data->LabeledMarkers[i];
printf("Labeled Marker [ID=%d] [size=%3.2f] [pos=%3.2f,%3.2f,%3.2f]\n", marker.ID, marker.size, marker.x, marker.y, marker.z);
}
if (!init_called) {
//init();
init_called = true;
}
EnterCriticalSection(&dest_cont.lock);
int destination = dest_cont.dests[dest_cont.step_num];
int stn = dest_cont.step_num;
int nsc = num_same_cmds;
int num_dests = dest_cont.num_dests;
LeaveCriticalSection(&dest_cont.lock);
if (destination >0) {
double angle_to_dest = calculate_angle(data->RigidBodies[0], data->RigidBodies[1], data->RigidBodies[destination]);
double dist_to_dest = calculate_distance(data->RigidBodies[0], data->RigidBodies[destination]);
printf("==================================== %f", dist_to_dest);
printf("angle is %f", angle_to_dest);
char return_val[1];
if (dist_to_dest < .4) {
if (acommand.state != '0' || last_dest != destination) {
acommand.cmd = '0';
send_cmd(NULL);
last_dest = destination;
//HANDLE thread = (HANDLE)::_beginthreadex(NULL, 0, send_cmd, &(acommand.cmd), 0, NULL);
//state = '0';
EnterCriticalSection(&dest_cont.lock);
dest_cont.step_num += 1;
//dest_cont.num_dests -= 1;
LeaveCriticalSection(&dest_cont.lock);
num_same_cmds = 0;
} else {
num_same_cmds += 1;
if (num_same_cmds > 20) {
acommand.cmd = '0';
send_cmd(NULL);
num_same_cmds = 0;
}
}
//dest_cont.step_num += 1;
return;
}
if ( angle_to_dest <165 ) {
if (acommand.state != 'R') {
acommand.cmd = 'R';
send_cmd(NULL);
num_same_cmds = 0;
//HANDLE thread = (HANDLE)::_beginthreadex(NULL, 0, send_cmd, &(acommand.cmd), 0, NULL);
} else {
num_same_cmds += 1;
if (num_same_cmds > 20) {
acommand.cmd = 'R';
send_cmd(NULL);
num_same_cmds = 0;
}
}
state = 'R';
return;
} else if (angle_to_dest > 170) {
if (acommand.state == 'R' || acommand.state == 'L') {
acommand.cmd = '0';
send_cmd(NULL);
num_same_cmds = 0;
//HANDLE thread = (HANDLE)::_beginthreadex(NULL, 0, send_cmd, &(acommand.cmd), 0, NULL);
//state = '0';
} else {
if (acommand.state != 'D') {
acommand.cmd = 'D';
send_cmd(NULL);
num_same_cmds = 0;
//HANDLE thread = (HANDLE)::_beginthreadex(NULL, 0, send_cmd, &(acommand.cmd), 0, NULL);
} else {
num_same_cmds += 1;
if (num_same_cmds > 20) {
acommand.cmd = 'D';
send_cmd(NULL);
num_same_cmds = 0;
}
}
//state = 'D';
}
}
}
}
// DataHandler receives data from the server
void __cdecl DataHandler(sFrameOfMocapData* data, void* pUserData)
{
NatNetClient* pClient = (NatNetClient*) pUserData;
printf("Received data frame %d\n", data->iFrame);
if(fpf) _WriteFrame(fpf,data);
int i,j;
char ts[100];
char buffer[(sizeof(sFrameOfMocapData))];
osc::OutboundPacketStream p(buffer, sizeof(sFrameOfMocapData));
p << osc::BeginBundle(getOscTime());
#if 0
// timestamp
p << osc::BeginMessage("/ts");
p << _getOSCTimeStamp(ts);
p << osc::EndMessage;
#endif
//srv latency
p << osc::BeginMessage("/srvlag");
p << data->fLatency;
p << osc::EndMessage;
// Mocap MarkerSet Markers
for(j=0; j < data->nMarkerSets; j++){
for(i =0; i < data->MocapData[j].nMarkers; i++){
// ATENCAO AO SPRINTF
char ns[300];
sprintf(ns,"/markerset/%s/%d", data->MocapData[j].szName, i);
p << osc::BeginMessage(ns);
p << data->MocapData[j].Markers[i][0];
p << data->MocapData[j].Markers[i][1];
p << data->MocapData[j].Markers[i][2];
p << osc::EndMessage;
}
}
// Other Markers
for(i=0; i < data->nOtherMarkers; i++){
char ns[50];
sprintf(ns,"/othermarker/%d", i);
p << osc::BeginMessage(ns);
p << data->OtherMarkers[i][0];
p << data->OtherMarkers[i][1];
p << data->OtherMarkers[i][2];
p << osc::EndMessage;
}
// Rigid Bodies
for(i=0; i < data->nRigidBodies; i++){
char ns[50];
sprintf(ns,"/rigidbody/%d", data->RigidBodies[i].ID);
p << osc::BeginMessage(ns);
p << data->RigidBodies[i].x;
p << data->RigidBodies[i].y;
p << data->RigidBodies[i].z;
p << data->RigidBodies[i].qx;
p << data->RigidBodies[i].qy;
p << data->RigidBodies[i].qz;
p << data->RigidBodies[i].qw;
p << osc::EndMessage;
for(int iMarker=0; iMarker < data->RigidBodies[i].nMarkers; iMarker++){
char nsMarker[50];
sprintf(nsMarker,"/rigidbody/%d/%d", data->RigidBodies[i].ID, iMarker);
p << osc::BeginMessage(nsMarker);
p << data->RigidBodies[i].Markers[iMarker][0];
p << data->RigidBodies[i].Markers[iMarker][1];
p << data->RigidBodies[i].Markers[iMarker][2];
p << osc::EndMessage;
}
}
p << osc::EndBundle;
if(transmitSocket)transmitSocket->Send(p.Data(), p.Size());
}
// DataHandler receives data from the server
void __cdecl DataHandler(sFrameOfMocapData* data, void* pUserData)
{
NatNetClient* pClient = (NatNetClient*) pUserData;
printf("Received frame %d\n", data->iFrame);
if(fp)
_WriteFrame(fp,data);
int i=0;
// same system latency test
float fThisTick = (float)GetTickCount();
float fDiff = fThisTick - data->fLatency;
double dDuration = fDiff;
//printf("Latency (same system) (msecs): %3.2lf\n", dDuration);
// Other Markers
//printf("Other Markers [Count=%d]\n", data->nOtherMarkers);
for(i=0; i < data->nOtherMarkers; i++)
{
//printf("Other Marker %d : %3.2f\t%3.2f\t%3.2f\n",
//i,
//data->OtherMarkers[i][0],
//data->OtherMarkers[i][1],
//data->OtherMarkers[i][2]);
}
// Rigid Bodies
//printf("Rigid Bodies [Count=%d]\n", data->nRigidBodies);
for(i=0; i < data->nRigidBodies; i++)
{
//printf("Rigid Body [ID=%d Error=%3.2f]\n", data->RigidBodies[i].ID, data->RigidBodies[i].MeanError);
//printf("\tx\ty\tz\tqx\tqy\tqz\tqw\n");
//printf("\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\n",
//data->RigidBodies[i].x,
//data->RigidBodies[i].y,
//data->RigidBodies[i].z,
//data->RigidBodies[i].qx,
//data->RigidBodies[i].qy,
//data->RigidBodies[i].qz,
//data->RigidBodies[i].qw);
//printf("\tRigid body markers [Count=%d]\n", data->RigidBodies[i].nMarkers);
//for(int iMarker=0; iMarker < data->RigidBodies[i].nMarkers; iMarker++)
//{
//printf("\t\t");
//if(data->RigidBodies[i].MarkerIDs)
//printf("MarkerID:%d", data->RigidBodies[i].MarkerIDs[iMarker]);
//if(data->RigidBodies[i].MarkerSizes)
//printf("\tMarkerSize:%3.2f", data->RigidBodies[i].MarkerSizes[iMarker]);
//if(data->RigidBodies[i].Markers)
//printf("\tMarkerPos:%3.2f,%3.2f,%3.2f\n" ,
//data->RigidBodies[i].Markers[iMarker][0],
//data->RigidBodies[i].Markers[iMarker][1],
//data->RigidBodies[i].Markers[iMarker][2]);
// }
}
// skeletons
//printf("Skeletons [Count=%d]\n", data->nSkeletons);
for(i=0; i < data->nSkeletons; i++)
{
sSkeletonData skData = data->Skeletons[i];
//printf("Skeleton [ID=%d Bone count=%d]\n", skData.skeletonID, skData.nRigidBodies);
for(int j=0; j< skData.nRigidBodies; j++)
{
sRigidBodyData rbData = skData.RigidBodyData[j];
//printf("Bone %d\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\t%3.2f\n",
//rbData.ID, rbData.x, rbData.y, rbData.z, rbData.qx, rbData.qy, rbData.qz, rbData.qw );
//printf("\tRigid body markers [Count=%d]\n", rbData.nMarkers);
// for(int iMarker=0; iMarker < data->RigidBodies[i].nMarkers; iMarker++)
//{
//printf("\t\t");
// if(rbData.MarkerIDs)
//printf("MarkerID:%d", rbData.MarkerIDs[iMarker]);
//if(rbData.MarkerSizes)
//printf("\tMarkerSize:%3.2f", rbData.MarkerSizes[iMarker]);
//if(rbData.Markers)
//printf("\tMarkerPos:%3.2f,%3.2f,%3.2f\n" ,
//data->RigidBodies[i].Markers[iMarker][0],
//data->RigidBodies[i].Markers[iMarker][1],
//data->RigidBodies[i].Markers[iMarker][2]);
//}
}
}
}
