/*
* Exit from unicorn, delete sub sys and threads
*/
void unicorn_exit(int blocking)
{
printf("unicorn_exit...\n");
/* Flush stepper and planner fifo */
if (hFifo_plan2st) {
Fifo_flush(hFifo_plan2st);
}
if (hFifo_st2plan) {
Fifo_flush(hFifo_st2plan);
}
if (hPause_printing) {
Pause_off(hPause_printing);
}
heater_exit();
gcode_exit();
stepper_exit(blocking);
plan_exit();
#ifdef SERVO
if (bbp_board_type == BOARD_BBP1S) {
servo_exit();
}
#endif
lmsw_exit();
pwm_exit();
temp_exit();
analog_exit();
parameter_exit();
/* Delete fifo */
if (hFifo_plan2st) {
Fifo_delete(hFifo_plan2st);
}
if (hFifo_st2plan) {
Fifo_delete(hFifo_st2plan);
}
if (hPause_printing) {
Pause_delete(hPause_printing);
}
fan_exit(); //???? glibc detected *** /usr/bin/unicorn: corrupted double-linked list: 0x0007e330
printf("unicorn_exit..., done\n");
}
/******************************************************************************
* captureThrFxn
******************************************************************************/
Void *captureThrFxn(Void *arg)
{
CaptureEnv *envp = (CaptureEnv *) arg;
Void *status = THREAD_SUCCESS;
Capture_Attrs cAttrs = Capture_Attrs_DM365_DEFAULT;
BufferGfx_Attrs gfxAttrs = BufferGfx_Attrs_DEFAULT;
Capture_Handle hCapture = NULL;
BufTab_Handle hBufTab = NULL;
BufferGfx_Dimensions dim;
Buffer_Handle hDstBuf, hCapBuf;
Int32 width, height, bufSize;
Int fifoRet;
ColorSpace_Type colorSpace = ColorSpace_YUV420PSEMI;
/* Create capture device driver instance */
cAttrs.numBufs = NUM_CAPTURE_BUFS;
cAttrs.videoInput = envp->videoInput;
cAttrs.videoStd = envp->videoStd;
cAttrs.colorSpace = colorSpace;
if (VideoStd_getResolution(envp->videoStd, &width, &height) < 0) {
ERR("Failed to calculate resolution of video standard\n");
cleanup(THREAD_FAILURE);
}
if (envp->imageWidth > 0 && envp->imageHeight > 0) {
if (width < envp->imageWidth && height < envp->imageHeight) {
ERR("User resolution (%ldx%ld) larger than detected (%ldx%ld)\n",
envp->imageWidth, envp->imageHeight, width, height);
cleanup(THREAD_FAILURE);
}
/*
* Capture driver provides 32-byte aligned data. We 32-byte align the
* capture and video buffers to perform zero copy encoding.
*/
envp->imageWidth = Dmai_roundUp(envp->imageWidth, 32);
}
else {
/* Resolution was not set on command line. Set to defaults. */
envp->imageHeight = height;
/*
* Capture driver provides 32-byte aligned data. We 32-byte align the
* capture and video buffers to perform zero copy encoding.
*/
envp->imageWidth = Dmai_roundUp(width, 32);
}
Dmai_clear(dim);
dim.width = envp->imageWidth;
dim.height = envp->imageHeight;
dim.lineLength = Dmai_roundUp(dim.width, 32);
if (colorSpace == ColorSpace_YUV420PSEMI) {
bufSize = dim.lineLength * dim.height * 3 / 2;
} else {
bufSize = dim.lineLength * dim.height * 2;
}
gfxAttrs.dim = dim;
/* Report the video standard and image size back to the main thread */
Rendezvous_meet(envp->hRendezvousCapStd);
gfxAttrs.colorSpace = colorSpace;
hBufTab = BufTab_create(NUM_CAPTURE_BUFS, bufSize,
BufferGfx_getBufferAttrs(&gfxAttrs));
if (hBufTab == NULL) {
ERR("Failed to create buftab\n");
cleanup(THREAD_FAILURE);
}
if ((envp->videoStd == VideoStd_720P_60) && (!envp->passThrough)) {
cAttrs.videoStd = VideoStd_720P_30;
}
else {
cAttrs.videoStd = envp->videoStd;
}
cAttrs.colorSpace = colorSpace;
cAttrs.captureDimension = &dim;
cAttrs.numBufs = NUM_CAPTURE_BUFS;
hCapture = Capture_create(hBufTab, &cAttrs);
if (hCapture == NULL) {
ERR("Failed to create capture device\n");
cleanup(THREAD_FAILURE);
}
/* Get a buffer from the video thread */
fifoRet = Fifo_get(envp->hInFifo, &hDstBuf);
if (fifoRet < 0) {
ERR("Failed to get buffer from video thread\n");
cleanup(THREAD_FAILURE);
}
if (fifoRet == Dmai_EFLUSH) {
cleanup(THREAD_SUCCESS);
}
/* Signal that initialization is done and wait for other threads */
Rendezvous_meet(envp->hRendezvousInit);
while (!gblGetQuit()) {
/* Get a buffer from the capture driver to encode */
if (Capture_get(hCapture, &hCapBuf) < 0) {
ERR("Failed to get capture buffer\n");
cleanup(THREAD_FAILURE);
}
/* Send captured buffer to video thread for encoding */
if (Fifo_put(envp->hOutFifo, hCapBuf) < 0) {
ERR("Failed to send buffer to video thread\n");
cleanup(THREAD_FAILURE);
}
/* Pause processing? */
Pause_test(envp->hPauseProcess);
/* Get a buffer from the video thread */
fifoRet = Fifo_get(envp->hInFifo, &hDstBuf);
if (fifoRet < 0) {
ERR("Failed to get buffer from video thread\n");
cleanup(THREAD_FAILURE);
}
/* Did the video thread flush the fifo? */
if (fifoRet == Dmai_EFLUSH) {
cleanup(THREAD_SUCCESS);
}
/* Return a buffer to the capture driver */
if (Capture_put(hCapture, hDstBuf) < 0) {
ERR("Failed to put capture buffer\n");
cleanup(THREAD_FAILURE);
}
}
cleanup:
/* Make sure the other threads aren't waiting for us */
Rendezvous_force(envp->hRendezvousCapStd);
Rendezvous_force(envp->hRendezvousInit);
Pause_off(envp->hPauseProcess);
Fifo_flush(envp->hOutFifo);
/* Meet up with other threads before cleaning up */
Rendezvous_meet(envp->hRendezvousCleanup);
if (hCapture) {
Capture_delete(hCapture);
}
/* Clean up the thread before exiting */
if (hBufTab) {
BufTab_delete(hBufTab);
}
return status;
}
/******************************************************************************
* captureThrFxn
******************************************************************************/
Void *captureThrFxn(Void *arg)
{
CaptureEnv *envp = (CaptureEnv *) arg;
Void *status = THREAD_SUCCESS;
Capture_Attrs cAttrs = Capture_Attrs_DM365_DEFAULT;
Display_Attrs dAttrs = Display_Attrs_DM365_VID_DEFAULT;
BufferGfx_Attrs gfxAttrs = BufferGfx_Attrs_DEFAULT;
Capture_Handle hCapture = NULL;
Display_Handle hDisplay = NULL;
BufTab_Handle hBufTab = NULL;
BufTab_Handle hDispBufTab = NULL;
BufTab_Handle hFifoBufTab = NULL;
Buffer_Handle hDstBuf, hCapBuf, hDisBuf, hBuf;
BufferGfx_Dimensions capDim;
VideoStd_Type videoStd;
Int32 width, height, bufSize;
Int fifoRet;
ColorSpace_Type colorSpace = ColorSpace_YUV420PSEMI;
Int bufIdx;
Int numCapBufs;
/* Create capture device driver instance */
cAttrs.numBufs = NUM_CAPTURE_BUFS;
cAttrs.videoInput = envp->videoInput;
cAttrs.videoStd = envp->videoStd;
cAttrs.colorSpace = colorSpace;
videoStd = envp->videoStd;
/* We only support D1, 720P and 1080P input */
if (videoStd != VideoStd_D1_NTSC && videoStd != VideoStd_D1_PAL
&& videoStd != VideoStd_720P_60 && videoStd != VideoStd_720P_50 &&
videoStd != VideoStd_1080I_30) {
ERR("Need D1/720P/1080P input to this demo\n");
cleanup(THREAD_FAILURE);
}
if (envp->imageWidth > 0 && envp->imageHeight > 0) {
if (VideoStd_getResolution(videoStd, &width, &height) < 0) {
ERR("Failed to calculate resolution of video standard\n");
cleanup(THREAD_FAILURE);
}
if (width < envp->imageWidth && height < envp->imageHeight) {
ERR("User resolution (%ldx%ld) larger than detected (%ldx%ld)\n",
envp->imageWidth, envp->imageHeight, width, height);
cleanup(THREAD_FAILURE);
}
/*
* Capture driver provides 32 byte aligned data. We 32 byte align the
* capture and video buffers to perform zero copy encoding.
*/
envp->imageWidth = Dmai_roundUp(envp->imageWidth,32);
capDim.x = 0;
capDim.y = 0;
capDim.height = envp->imageHeight;
capDim.width = envp->imageWidth;
capDim.lineLength = BufferGfx_calcLineLength(capDim.width, colorSpace);
}
else {
/* Calculate the dimensions of a video standard given a color space */
if (BufferGfx_calcDimensions(videoStd, colorSpace, &capDim) < 0) {
ERR("Failed to calculate Buffer dimensions\n");
cleanup(THREAD_FAILURE);
}
/*
* Capture driver provides 32 byte aligned data. We 32 byte align the
* capture and video buffers to perform zero copy encoding.
*/
capDim.width = Dmai_roundUp(capDim.width,32);
envp->imageWidth = capDim.width;
envp->imageHeight = capDim.height;
}
numCapBufs = NUM_CAPTURE_BUFS;
gfxAttrs.dim.height = capDim.height;
gfxAttrs.dim.width = capDim.width;
gfxAttrs.dim.lineLength =
Dmai_roundUp(BufferGfx_calcLineLength(gfxAttrs.dim.width,
colorSpace), 32);
gfxAttrs.dim.x = 0;
gfxAttrs.dim.y = 0;
if (colorSpace == ColorSpace_YUV420PSEMI) {
bufSize = gfxAttrs.dim.lineLength * gfxAttrs.dim.height * 3 / 2;
}
else {
bufSize = gfxAttrs.dim.lineLength * gfxAttrs.dim.height * 2;
}
/* Create a table of buffers to use with the capture driver */
gfxAttrs.colorSpace = colorSpace;
hBufTab = BufTab_create(numCapBufs, bufSize,
BufferGfx_getBufferAttrs(&gfxAttrs));
if (hBufTab == NULL) {
ERR("Failed to create buftab\n");
cleanup(THREAD_FAILURE);
}
/* Create a table of buffers to use to prime Fifo to video thread */
hFifoBufTab = BufTab_create(VIDEO_PIPE_SIZE, bufSize,
BufferGfx_getBufferAttrs(&gfxAttrs));
if (hFifoBufTab == NULL) {
ERR("Failed to create buftab\n");
cleanup(THREAD_FAILURE);
}
/* Update global data for user interface */
gblSetImageWidth(envp->imageWidth);
gblSetImageHeight(envp->imageHeight);
/* Report the video standard and image size back to the main thread */
Rendezvous_meet(envp->hRendezvousCapStd);
/* Capture at half frame rate if using COMPONENT input at 720P */
if ((envp->videoStd == VideoStd_720P_60)
&& (envp->videoInput == Capture_Input_COMPONENT)) {
cAttrs.videoStd = VideoStd_720P_30;
}
else {
cAttrs.videoStd = envp->videoStd;
}
/*If its component input and video std is 1080I_30 then make it 1080I_60.*/
if (cAttrs.videoStd == VideoStd_1080I_30 && cAttrs.videoInput
== Capture_Input_COMPONENT) {
cAttrs.videoStd = VideoStd_1080I_60;
}
cAttrs.numBufs = NUM_CAPTURE_BUFS;
cAttrs.colorSpace = colorSpace;
cAttrs.captureDimension = &gfxAttrs.dim;
/* Create the capture device driver instance */
hCapture = Capture_create(hBufTab, &cAttrs);
if (hCapture == NULL) {
ERR("Failed to create capture device. Is video input connected?\n");
cleanup(THREAD_FAILURE);
}
/* Create a table of buffers to use with the display driver */
hDispBufTab = BufTab_create(NUM_DISPLAY_BUFS, bufSize,
BufferGfx_getBufferAttrs(&gfxAttrs));
if (hDispBufTab == NULL) {
ERR("Failed to create buftab\n");
cleanup(THREAD_FAILURE);
}
/* Create display device driver instance if preview is needed */
if (!envp->previewDisabled) {
dAttrs.videoStd = envp->videoStd;
if ( (dAttrs.videoStd == VideoStd_CIF) ||
(dAttrs.videoStd == VideoStd_SIF_NTSC) ||
(dAttrs.videoStd == VideoStd_SIF_PAL) ||
(dAttrs.videoStd == VideoStd_VGA) ||
(dAttrs.videoStd == VideoStd_D1_NTSC) ||
(dAttrs.videoStd == VideoStd_D1_PAL) ) {
dAttrs.videoOutput = Display_Output_COMPOSITE;
} else {
dAttrs.videoOutput = Display_Output_COMPONENT;
}
dAttrs.numBufs = NUM_DISPLAY_BUFS;
dAttrs.colorSpace = colorSpace;
dAttrs.width = capDim.width;
dAttrs.height = capDim.height;
hDisplay = Display_create(hDispBufTab, &dAttrs);
if (hDisplay == NULL) {
ERR("Failed to create display device\n");
cleanup(THREAD_FAILURE);
}
}
for (bufIdx = 0; bufIdx < VIDEO_PIPE_SIZE; bufIdx++) {
/* Queue the video buffers for main thread processing */
hBuf = BufTab_getFreeBuf(hFifoBufTab);
if (hBuf == NULL) {
ERR("Failed to fill video pipeline\n");
cleanup(THREAD_FAILURE);
}
/* Fill with black the buffer */
CapBuf_blackFill(hBuf);
/* Send buffer to video thread for encoding */
if (Fifo_put(envp->hOutFifo, hBuf) < 0) {
ERR("Failed to send buffer to display thread\n");
cleanup(THREAD_FAILURE);
}
}
/* Signal that initialization is done and wait for other threads */
Rendezvous_meet(envp->hRendezvousInit);
while (!gblGetQuit()) {
/* Pause processing? */
Pause_test(envp->hPauseProcess);
/* Capture a frame */
if (Capture_get(hCapture, &hCapBuf) < 0) {
ERR("Failed to get capture buffer\n");
cleanup(THREAD_FAILURE);
}
/* Get a buffer from the display device */
if ((!envp->previewDisabled) && (Display_get(hDisplay, &hDisBuf) < 0)) {
ERR("Failed to get display buffer\n");
cleanup(THREAD_FAILURE);
}
/* Send buffer to video thread for encoding */
if (Fifo_put(envp->hOutFifo, hCapBuf) < 0) {
ERR("Failed to send buffer to display thread\n");
cleanup(THREAD_FAILURE);
}
/* Get a buffer from the video thread */
fifoRet = Fifo_get(envp->hInFifo, &hDstBuf);
if (fifoRet < 0) {
ERR("Failed to get buffer from video thread\n");
cleanup(THREAD_FAILURE);
}
/* Did the video thread flush the fifo? */
if (fifoRet == Dmai_EFLUSH) {
cleanup(THREAD_SUCCESS);
}
if (!envp->previewDisabled) {
/* Release buffer to the display device driver */
if (Display_put(hDisplay, hDstBuf) < 0) {
ERR("Failed to put display buffer\n");
cleanup(THREAD_FAILURE);
}
}
if (envp->previewDisabled) {
/* Return the processed buffer to the capture driver */
if (Capture_put(hCapture, hDstBuf) < 0) {
ERR("Failed to put capture buffer\n");
cleanup(THREAD_FAILURE);
}
}
else {
/* Return the displayed buffer to the capture driver */
if (Capture_put(hCapture, hDisBuf) < 0) {
ERR("Failed to put capture buffer\n");
cleanup(THREAD_FAILURE);
}
}
/* Increment statistics for the user interface */
gblIncFrames();
}
cleanup:
/* Make sure the other threads aren't waiting for us */
Rendezvous_force(envp->hRendezvousCapStd);
Rendezvous_force(envp->hRendezvousInit);
Pause_off(envp->hPauseProcess);
Fifo_flush(envp->hOutFifo);
/* Meet up with other threads before cleaning up */
Rendezvous_meet(envp->hRendezvousCleanup);
if (hDisplay) {
Display_delete(hDisplay);
}
if (hCapture) {
Capture_delete(hCapture);
}
/* Clean up the thread before exiting */
if (hBufTab) {
BufTab_delete(hBufTab);
}
if (hFifoBufTab) {
BufTab_delete(hFifoBufTab);
}
if (hDispBufTab) {
BufTab_delete(hDispBufTab);
}
return status;
}
/******************************************************************************
* displayThrFxn
******************************************************************************/
Void *displayThrFxn(Void *arg)
{
DisplayEnv *envp = (DisplayEnv *) arg;
Display_Attrs dAttrs = Display_Attrs_DM365_VID_DEFAULT;
Display_Handle hDisplay = NULL;
Framecopy_Handle hFc = NULL;
Void *status = THREAD_SUCCESS;
Uns frameCnt = 0;
BufferGfx_Dimensions srcDim;
Buffer_Handle hSrcBuf, hDstBuf;
Int fifoRet;
ColorSpace_Type colorSpace = ColorSpace_YUV420PSEMI;
BufferGfx_Attrs gfxAttrs = BufferGfx_Attrs_DEFAULT;
BufTab_Handle hBufTab = NULL;
Int32 bufSize;
Time_Attrs tAttrs = Time_Attrs_DEFAULT;
Time_Handle hTime = NULL;
Int32 time, waitTime;
Int bufCnt = 1;
hTime = Time_create(&tAttrs);
if (hTime == NULL) {
ERR("Failed to create Time object\n");
cleanup(THREAD_FAILURE);
}
if(Time_reset(hTime) != Dmai_EOK) {
ERR("Failed to reset timer\n");
cleanup(THREAD_FAILURE);
}
/* Signal that initialization is done and wait for other threads */
Rendezvous_meet(envp->hRendezvousInit);
while (!gblGetQuit()) {
/* Pause processing? */
Pause_test(envp->hPauseProcess);
/* Pause for priming? */
Pause_test(envp->hPausePrime);
/* Get decoded video frame */
fifoRet = Fifo_get(envp->hInFifo, &hSrcBuf);
if (fifoRet < 0) {
ERR("Failed to get buffer from video thread\n");
cleanup(THREAD_FAILURE);
}
/* Did the video thread flush the fifo? */
if (fifoRet == Dmai_EFLUSH) {
cleanup(THREAD_SUCCESS);
}
BufferGfx_getDimensions(hSrcBuf, &srcDim);
/* Prime the display driver with the first NUM_DISPLAY_BUFS buffers */
if (bufCnt <= NUM_DISPLAY_BUFS) {
if (bufCnt == 1) { // Create the Display at the first frame
gfxAttrs.dim.width = srcDim.width;
gfxAttrs.dim.height = srcDim.height;
gfxAttrs.dim.lineLength = srcDim.lineLength;
gfxAttrs.dim.x = srcDim.x;
gfxAttrs.dim.y = srcDim.y;
if (colorSpace == ColorSpace_YUV420PSEMI) {
bufSize = gfxAttrs.dim.lineLength * gfxAttrs.dim.height *
3 / 2;
} else {
bufSize = gfxAttrs.dim.lineLength * gfxAttrs.dim.height * 2;
}
/* Create a table of buffers to use with the device drivers */
gfxAttrs.colorSpace = colorSpace;
hBufTab = BufTab_create(NUM_DISPLAY_BUFS, bufSize,
BufferGfx_getBufferAttrs(&gfxAttrs));
if (hBufTab == NULL) {
ERR("Failed to create buftab\n");
cleanup(THREAD_FAILURE);
}
/* Create the display device instance */
dAttrs.delayStreamon = TRUE;
dAttrs.numBufs = NUM_DISPLAY_BUFS;
dAttrs.videoStd = envp->videoStd;
/*
* Round down the width to a multiple of 32 as required by
* display driver. Otherwise, the driver would internally round
* up the width, resulting in the codec padding showing up
* on the display when the image width is not a multiple of 32.
*/
dAttrs.width = ((gfxAttrs.dim.width & 0x1f) ?
(gfxAttrs.dim.width & ~(0x1f)) : gfxAttrs.dim.width);
dAttrs.height = gfxAttrs.dim.height;
dAttrs.videoOutput = envp->displayOutput;
dAttrs.colorSpace = colorSpace;
hDisplay = Display_create(hBufTab, &dAttrs);
if (hDisplay == NULL) {
ERR("Failed to create display device\n");
cleanup(THREAD_FAILURE);
}
}
bufCnt++;
}
else {
/* Get a buffer from the display device driver */
if (Display_get(hDisplay, &hDstBuf) < 0) {
ERR("Failed to get display buffer\n");
cleanup(THREAD_FAILURE);
}
/* Send buffer back to the video thread */
if (Fifo_put(envp->hOutFifo, hDstBuf) < 0) {
ERR("Failed to send buffer to video thread\n");
cleanup(THREAD_FAILURE);
}
}
if (envp->videoStd == VideoStd_720P_60) {
if (Time_delta(hTime, (UInt32*)&time) < 0) {
ERR("Failed to get timer delta\n");
cleanup(THREAD_FAILURE);
}
waitTime = DISPLAYLOOPLATENCY - time;
if(waitTime > 0) {
usleep(waitTime);
}
if(Time_reset(hTime) != Dmai_EOK) {
ERR("Failed to reset timer\n");
cleanup(THREAD_FAILURE);
}
}
/* Incremement statistics for the user interface */
gblIncFrames();
/* Give a filled buffer back to the display device driver */
if (Display_put(hDisplay, hSrcBuf) < 0) {
ERR("Failed to put display buffer\n");
cleanup(THREAD_FAILURE);
}
frameCnt++;
}
cleanup:
/* Make sure the other threads aren't waiting for us */
Rendezvous_force(envp->hRendezvousInit);
Pause_off(envp->hPauseProcess);
Pause_off(envp->hPausePrime);
Fifo_flush(envp->hOutFifo);
/* Meet up with other threads before cleaning up */
Rendezvous_meet(envp->hRendezvousCleanup);
/* Clean up the thread before exiting */
if (hFc) {
Framecopy_delete(hFc);
}
if (hDisplay) {
Display_delete(hDisplay);
}
/* Clean up the thread before exiting */
if (hBufTab) {
BufTab_delete(hBufTab);
}
if(hTime) {
Time_delete(hTime);
}
return status;
}
/******************************************************************************
* writerThrFxn
******************************************************************************/
Void *writerThrFxn(Void *arg)
{
WriterEnv *envp = (WriterEnv *) arg;
Void *status = THREAD_SUCCESS;
FILE *outFile = NULL;
Buffer_Attrs bAttrs = Buffer_Attrs_DEFAULT;
BufTab_Handle hBufTab = NULL;
Buffer_Handle hOutBuf;
Int fifoRet;
Int bufIdx;
/* Open the output video file */
outFile = fopen(envp->videoFile, "w");
if (outFile == NULL) {
ERR("Failed to open %s for writing\n", envp->videoFile);
cleanup(THREAD_FAILURE);
}
/*
* Create a table of buffers for communicating buffers to
* and from the video thread.
*/
hBufTab = BufTab_create(NUM_WRITER_BUFS, envp->outBufSize, &bAttrs);
if (hBufTab == NULL) {
ERR("Failed to allocate contiguous buffers\n");
cleanup(THREAD_FAILURE);
}
/* Send all buffers to the video thread to be filled with encoded data */
for (bufIdx = 0; bufIdx < NUM_WRITER_BUFS; bufIdx++) {
if (Fifo_put(envp->hOutFifo, BufTab_getBuf(hBufTab, bufIdx)) < 0) {
ERR("Failed to send buffer to display thread\n");
cleanup(THREAD_FAILURE);
}
}
/* Signal that initialization is done and wait for other threads */
Rendezvous_meet(envp->hRendezvousInit);
while (TRUE) {
/* Get an encoded buffer from the video thread */
fifoRet = Fifo_get(envp->hInFifo, &hOutBuf);
if (fifoRet < 0) {
ERR("Failed to get buffer from video thread\n");
cleanup(THREAD_FAILURE);
}
/* Did the video thread flush the fifo? */
if (fifoRet == Dmai_EFLUSH) {
cleanup(THREAD_SUCCESS);
}
if (!envp->writeDisabled) {
/* Store the encoded frame to disk */
if (Buffer_getNumBytesUsed(hOutBuf)) {
if (fwrite(Buffer_getUserPtr(hOutBuf),
Buffer_getNumBytesUsed(hOutBuf), 1, outFile) != 1) {
ERR("Error writing the encoded data to video file\n");
cleanup(THREAD_FAILURE);
}
}
else {
printf("Warning, writer received 0 byte encoded frame\n");
}
}
/* Return buffer to capture thread */
if (Fifo_put(envp->hOutFifo, hOutBuf) < 0) {
ERR("Failed to send buffer to display thread\n");
cleanup(THREAD_FAILURE);
}
}
cleanup:
/* Make sure the other threads aren't waiting for us */
Rendezvous_force(envp->hRendezvousInit);
Pause_off(envp->hPauseProcess);
Fifo_flush(envp->hOutFifo);
/* Meet up with other threads before cleaning up */
Rendezvous_meet(envp->hRendezvousCleanup);
/* Clean up the thread before exiting */
if (outFile) {
fclose(outFile);
}
if (hBufTab) {
BufTab_delete(hBufTab);
}
return status;
}
