疑问：dvsdk-demo的maxframerate

Int main(Int argc, Char *argv[])
{
Args args = DEFAULT_ARGS;
Uns initMask = 0;
Int status = EXIT_SUCCESS;
Pause_Attrs pAttrs = Pause_Attrs_DEFAULT;
Rendezvous_Attrs rzvAttrs = Rendezvous_Attrs_DEFAULT;
Fifo_Attrs fAttrs = Fifo_Attrs_DEFAULT;
UI_Attrs uiAttrs;
Rendezvous_Handle hRendezvousCapStd = NULL;
Rendezvous_Handle hRendezvousInit = NULL;
Rendezvous_Handle hRendezvousWriter = NULL;
Rendezvous_Handle hRendezvousCleanup = NULL;
Pause_Handle hPauseProcess = NULL;
UI_Handle hUI = NULL;
struct sched_param schedParam;
pthread_t captureThread;
pthread_t writerThread;
pthread_t videoThread;
pthread_t audioThread;
pthread_t speechThread;
CaptureEnv captureEnv;
WriterEnv writerEnv;
VideoEnv videoEnv;
SpeechEnv speechEnv;
AudioEnv audioEnv;
CtrlEnv ctrlEnv;
Int numThreads;
pthread_attr_t attr;
Void *ret;
Bool stopped;

/* Zero out the thread environments */
Dmai_clear(captureEnv);
Dmai_clear(writerEnv);
Dmai_clear(videoEnv);
Dmai_clear(speechEnv);
Dmai_clear(audioEnv);
Dmai_clear(ctrlEnv);

/* Parse the arguments given to the app and set the app environment */
parseArgs(argc, argv, &args);

printf("Encode demo started.\n");

/* Launch interface app */
if (args.osd) {
if (launchInterface(&args) == FAILURE) {
exit(EXIT_FAILURE);
}
}

/* Initialize the mutex which protects the global data */
pthread_mutex_init(&gbl.mutex, NULL);

/* Set the priority of this whole process to max (requires root) */
setpriority(PRIO_PROCESS, 0, -20);

/* Initialize Codec Engine runtime */
CERuntime_init();

/* Initialize Davinci Multimedia Application Interface */
Dmai_init();

initMask |= LOGSINITIALIZED;

/* Create the user interface */
uiAttrs.osd = args.osd;
uiAttrs.videoStd = args.videoStd;

hUI = UI_create(&uiAttrs);

if (hUI == NULL) {
cleanup(EXIT_FAILURE);
}

/* Get configuration from QT interface if necessary */
if (args.osd) {
status = getConfigFromInterface(&args, hUI, &stopped);
if (status == FAILURE) {
ERR("Failed to get valid configuration from the GUI\n");
cleanup(EXIT_FAILURE);
}
else if (stopped == TRUE) {
cleanup(EXIT_SUCCESS);
}
}

/* Validate arguments */
if (validateArgs(&args) == FAILURE) {
cleanup(EXIT_FAILURE);
}

/* Set up the user interface */
uiSetup(hUI, &args);

/* Create the Pause object */
hPauseProcess = Pause_create(&pAttrs);

if (hPauseProcess == NULL) {
ERR("Failed to create Pause object\n");
cleanup(EXIT_FAILURE);
}

/* Determine the number of threads needing synchronization */
numThreads = 1;

if (args.videoFile) {
numThreads += 3;
}

if (args.audioFile || args.speechFile) {
numThreads += 1;
}
/* Create the objects which synchronizes the thread init and cleanup */
hRendezvousCapStd = Rendezvous_create(2, &rzvAttrs);
hRendezvousInit = Rendezvous_create(numThreads, &rzvAttrs);
hRendezvousCleanup = Rendezvous_create(numThreads, &rzvAttrs);
hRendezvousWriter = Rendezvous_create(2, &rzvAttrs);

if (hRendezvousCapStd == NULL || hRendezvousInit == NULL ||
hRendezvousCleanup == NULL || hRendezvousWriter == NULL) {
ERR("Failed to create Rendezvous objects\n");
cleanup(EXIT_FAILURE);
}

/* Initialize the thread attributes */
if (pthread_attr_init(&attr)) {
ERR("Failed to initialize thread attrs\n");
cleanup(EXIT_FAILURE);
}

/* Force the thread to use custom scheduling attributes */
if (pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED)) {
ERR("Failed to set schedule inheritance attribute\n");
cleanup(EXIT_FAILURE);
}

/* Set the thread to be fifo real time scheduled */
if (pthread_attr_setschedpolicy(&attr, SCHED_FIFO)) {
ERR("Failed to set FIFO scheduling policy\n");
cleanup(EXIT_FAILURE);
}

/* Create the video threads if a file name is supplied */
if (args.videoFile) {
/* Create the capture fifos */
captureEnv.hInFifo = Fifo_create(&fAttrs);
captureEnv.hOutFifo = Fifo_create(&fAttrs);

if (captureEnv.hInFifo == NULL || captureEnv.hOutFifo == NULL) {
ERR("Failed to open display fifos\n");
cleanup(EXIT_FAILURE);
}

/* Create the capture thread */
captureEnv.hRendezvousInit = hRendezvousInit;
captureEnv.hRendezvousCapStd = hRendezvousCapStd;
captureEnv.hRendezvousCleanup = hRendezvousCleanup;
captureEnv.hPauseProcess = hPauseProcess;
captureEnv.videoStd = args.videoStd;
captureEnv.videoInput = args.videoInput;
captureEnv.imageWidth = args.imageWidth;
captureEnv.imageHeight = args.imageHeight;
captureEnv.previewDisabled = args.previewDisabled;

if (pthread_create(&captureThread, NULL, captureThrFxn, &captureEnv)) {
ERR("Failed to create capture thread\n");
cleanup(EXIT_FAILURE);
}

initMask |= CAPTURETHREADCREATED;

/*
* Once the capture thread has detected the video standard, make it
* available to other threads. The capture thread will set the
* resolution of the buffer to encode in the environment (derived
* from the video standard if the user hasn't passed a resolution).
*/
Rendezvous_meet(hRendezvousCapStd);

/* Create the writer fifos */
writerEnv.hInFifo = Fifo_create(&fAttrs);
writerEnv.hOutFifo = Fifo_create(&fAttrs);

if (writerEnv.hInFifo == NULL || writerEnv.hOutFifo == NULL) {
ERR("Failed to open display fifos\n");
cleanup(EXIT_FAILURE);
}

/* Set the video thread priority */
schedParam.sched_priority = VIDEO_THREAD_PRIORITY;
if (pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}

/* Create the video thread */
videoEnv.hRendezvousInit = hRendezvousInit;
videoEnv.hRendezvousCleanup = hRendezvousCleanup;
videoEnv.hRendezvousWriter = hRendezvousWriter;
videoEnv.hPauseProcess = hPauseProcess;
videoEnv.hCaptureOutFifo = captureEnv.hOutFifo;
videoEnv.hCaptureInFifo = captureEnv.hInFifo;
videoEnv.hWriterOutFifo = writerEnv.hOutFifo;
videoEnv.hWriterInFifo = writerEnv.hInFifo;
videoEnv.videoEncoder = args.videoEncoder->codecName;
videoEnv.params = args.videoEncoder->params;
videoEnv.dynParams = args.videoEncoder->dynParams;
videoEnv.videoBitRate = args.videoBitRate;
videoEnv.imageWidth = captureEnv.imageWidth;
videoEnv.imageHeight = captureEnv.imageHeight;
videoEnv.engineName = engine->engineName;
if (args.videoStd == VideoStd_D1_PAL) {
videoEnv.videoFrameRate = 25000;
} else {
videoEnv.videoFrameRate = 30000;
}

if (pthread_create(&videoThread, &attr, videoThrFxn, &videoEnv)) {
ERR("Failed to create video thread\n");
cleanup(EXIT_FAILURE);
}

initMask |= VIDEOTHREADCREATED;

/*
* Wait for the codec to be created in the video thread before
* launching the writer thread (otherwise we don't know which size
* of buffers to use).
*/
Rendezvous_meet(hRendezvousWriter);

/* Create the writer thread */
writerEnv.hRendezvousInit = hRendezvousInit;
writerEnv.hRendezvousCleanup = hRendezvousCleanup;
writerEnv.hPauseProcess = hPauseProcess;
writerEnv.videoFile = args.videoFile;
writerEnv.outBufSize = videoEnv.outBufSize;
writerEnv.writeDisabled = args.writeDisabled;

if (pthread_create(&writerThread, NULL, writerThrFxn, &writerEnv)) {
ERR("Failed to create writer thread\n");
cleanup(EXIT_FAILURE);
}

initMask |= WRITERTHREADCREATED;

}
/* Create the audio thread if a file name is supplied */
if (args.audioFile) {
/* Set the thread priority */
schedParam.sched_priority = AUDIO_THREAD_PRIORITY;
if (pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}

/* Create the audio thread */
audioEnv.hRendezvousInit = hRendezvousInit;
audioEnv.hRendezvousCleanup = hRendezvousCleanup;
audioEnv.hPauseProcess = hPauseProcess;
audioEnv.engineName = engine->engineName;
audioEnv.audioEncoder = args.audioEncoder->codecName;
audioEnv.params = args.audioEncoder->params;
audioEnv.dynParams = args.audioEncoder->dynParams;
audioEnv.audioFile = args.audioFile;
audioEnv.soundInput = args.soundInput;
audioEnv.soundBitRate = args.soundBitRate;
audioEnv.sampleRate = args.sampleRate;
audioEnv.writeDisabled = args.writeDisabled;
if (pthread_create(&audioThread, &attr, audioThrFxn, &audioEnv)) {
ERR("Failed to create audio thread\n");
cleanup(EXIT_FAILURE);
}

initMask |= AUDIOTHREADCREATED;
}

/* Create the speech thread if a file name is supplied */
if (args.speechFile) {
/* Set the thread priority */
schedParam.sched_priority = SPEECH_THREAD_PRIORITY;
if (pthread_attr_setschedparam(&attr, &schedParam)) {
ERR("Failed to set scheduler parameters\n");
cleanup(EXIT_FAILURE);
}

/* Create the speech thread */
speechEnv.hRendezvousInit = hRendezvousInit;
speechEnv.hRendezvousCleanup = hRendezvousCleanup;
speechEnv.hPauseProcess = hPauseProcess;
speechEnv.speechFile = args.speechFile;
speechEnv.soundInput = args.soundInput;
speechEnv.speechEncoder = args.speechEncoder->codecName;
speechEnv.params = args.speechEncoder->params;
speechEnv.dynParams = args.speechEncoder->dynParams;
speechEnv.engineName = engine->engineName;

if (pthread_create(&speechThread, &attr, speechThrFxn, &speechEnv)) {
ERR("Failed to create speech thread\n");
cleanup(EXIT_FAILURE);
}

initMask |= SPEECHTHREADCREATED;
}

/* Main thread becomes the control thread */
ctrlEnv.hRendezvousInit = hRendezvousInit;
ctrlEnv.hRendezvousCleanup = hRendezvousCleanup;
ctrlEnv.hPauseProcess = hPauseProcess;
ctrlEnv.keyboard = args.keyboard;
ctrlEnv.time = args.time;
ctrlEnv.hUI = hUI;
ctrlEnv.engineName = engine->engineName;
ctrlEnv.osd = args.osd;

ret = ctrlThrFxn(&ctrlEnv);

if (ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}

cleanup:
if (args.osd) {
int rv;
if (hUI) {
/* Stop the UI */
UI_stop(hUI);
}
wait(&rv); /* Wait for child process to end */
}

/* Make sure the other threads aren't waiting for init to complete */
if (hRendezvousCapStd) Rendezvous_force(hRendezvousCapStd);
if (hRendezvousWriter) Rendezvous_force(hRendezvousWriter);
if (hRendezvousInit) Rendezvous_force(hRendezvousInit);
if (hPauseProcess) Pause_off(hPauseProcess);

/* Wait until the other threads terminate */
if (initMask & SPEECHTHREADCREATED) {
if (pthread_join(speechThread, &ret) == 0) {
if (ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}

if (initMask & AUDIOTHREADCREATED) {
if (pthread_join(audioThread, &ret) == 0) {
if (ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}
if (initMask & VIDEOTHREADCREATED) {
if (pthread_join(videoThread, &ret) == 0) {
if (ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}

if (initMask & WRITERTHREADCREATED) {
if (pthread_join(writerThread, &ret) == 0) {
if (ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}

if (writerEnv.hOutFifo) {
Fifo_delete(writerEnv.hOutFifo);
}

if (writerEnv.hInFifo) {
Fifo_delete(writerEnv.hInFifo);
}

if (initMask & CAPTURETHREADCREATED) {
if (pthread_join(captureThread, &ret) == 0) {
if (ret == THREAD_FAILURE) {
status = EXIT_FAILURE;
}
}
}

if (captureEnv.hOutFifo) {
Fifo_delete(captureEnv.hOutFifo);
}

if (captureEnv.hInFifo) {
Fifo_delete(captureEnv.hInFifo);
}

if (hRendezvousCleanup) {
Rendezvous_delete(hRendezvousCleanup);
}

if (hRendezvousInit) {
Rendezvous_delete(hRendezvousInit);
}

if (hPauseProcess) {
Pause_delete(hPauseProcess);
}

if (hUI) {
UI_delete(hUI);
}

/*
* In the past, there were instances where we have seen system memory
* continually reduces by 28 bytes at a time whenever there are file
* reads or file writes. This is for the application to recapture that
* memory (SDOCM00054899)
*/
system("sync");
system("echo 3 > /proc/sys/vm/drop_caches");

pthread_mutex_destroy(&gbl.mutex);

exit(status);
}