int main(int argc, char **argv)
{
int rv;
appSetup(argc, argv); /* never returns on error */
sortRandom();
/* close the file */
if ((rv = skStreamClose(out_rwios))
|| (rv = skStreamDestroy(&out_rwios)))
{
skStreamPrintLastErr(out_rwios, rv, &skAppPrintErr);
appExit(EXIT_FAILURE);
}
out_rwios = NULL;
appExit(EXIT_SUCCESS);
return 0; /* NOTREACHED */
}
void borExit(int reset)
{
#ifdef GP2X
gp2x_end();
chdir("/usr/gp2x");
execl("/usr/gp2x/gp2xmenu", "/usr/gp2x/gp2xmenu", NULL);
#else
SDL_Delay(1000);
#endif
appExit(0);
}
//
// ReportWriterWindow
//
ReportWriterWindow::ReportWriterWindow()
: QMainWindow(0, tr("OpenMFG: Report Writer"), WDestructiveClose) {
setIcon(QPixmap(OpenReportsIcon_xpm));
// add the workspace
QVBox * vbox = new QVBox(this);
vbox->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
ws = new QWorkspace(vbox);
ws->setScrollBarsEnabled(TRUE);
setCentralWidget(vbox);
// setup the menubar
fileExitAction = new QAction(tr("Exit"),
tr("E&xit"),ALT+Key_F4,this,"file exit");
connect(fileExitAction, SIGNAL(activated()), this, SLOT(appExit()));
handler = new ReportHandler(this, "report handler");
#ifdef NODBSUPPORT
handler->setNoDatabase(true);
#endif
menubar = new QMenuBar(this);
int sepid = handler->populateMenuBar(menubar, fileExitAction);
windowMenu = new QPopupMenu();
windowMenu->setCheckable(TRUE);
connect(windowMenu, SIGNAL(aboutToShow()), this, SLOT(sPrepareWindowMenu()));
menubar->insertItem(tr("&Windows"), windowMenu, -1, menubar->indexOf(sepid));
// setup the toolbar
handler->docToolBars(this);
statusbar = new QStatusBar(this);
setCaption();
dbTimerId = startTimer(60000);
handler->setParentWindow(ws);
connect(handler, SIGNAL(dbOpenClosed()), this, SLOT(setCaption()));
connect(handler, SIGNAL(messageChanged(const QString &)),
statusbar, SLOT(message(const QString &)));
connect(handler, SIGNAL(messageCleared()),
statusbar, SLOT(clear()));
}
static void sigprocess(int sig)
{
int ii = 0;
void *tracePtrs[16];
int count = backtrace(tracePtrs, 16);
char **funcNames = backtrace_symbols(tracePtrs, count);
for(ii = 0; ii < count; ii++)
printf("%s\n", funcNames[ii]);
free(funcNames);
fflush(stderr);
printf("##signal %d caught\n", sig);
fflush(stdout);
if(sig == SIGINT || sig == SIGSEGV || sig == SIGTERM)
{
appExit();
}
exit(1);
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
//QTextCodec::setCodecForTr(QTextCodec::codecForName("utf-8"));
QTextCodec::setCodecForLocale(QTextCodec::codecForName("utf-8"));
appTitle = QObject::tr("凭证辅助处理系统");
QTranslator translator; //汉化标准对话框、标准上下文菜单等
translator.load("qt_zh_CN.qm","./translations");
//translator.load("i18n_zh"); //这个不行
app.installTranslator(&translator );
int errNum = appInit();
if(errNum != 0){
showErrorInfo(errNum);
return errNum;
}
FileAppender* logFile = new FileAppender("./logs/app.log");
Logger::registerAppender(logFile);
Logger::write(Logger::Must,"",0,"","");
Logger::write(Logger::Must,"",0,"",
"************************************************************");
Logger::write(QDateTime::currentDateTime(), Logger::Must,"",0,"",
QObject::tr("PzAssistant is starting......"));
//qDebug()<<"qDebug export info!";
logLevel = AppConfig::getInstance()->getLogLevel();
logFile->setDetailsLevel(logLevel);
MainWindow mainWin;
mainWin.showMaximized();
mainWin.hideDockWindows();
mainWin.getMdiAreaSize(mdiAreaWidth, mdiAreaHeight);
int exitCode = app.exec();
Logger::write(QDateTime::currentDateTime(),Logger::Must,"",0,"", QObject::tr("Quit PzAssistant!"));
AppConfig::getInstance()->setLogLevel(logLevel);
appExit();
return exitCode;
}
VJoystickMainWindow::VJoystickMainWindow(QWidget *parent) :
QMainWindow(parent), m_ui(new Ui::VJoystickMainWindow), m_adapter(0)
{
m_ui->setupUi(this);
connect(m_ui->pushButtonScan, SIGNAL(clicked()), this, SLOT(scanDevices()));
connect(m_ui->pushButtonConnect, SIGNAL(clicked()), this, SLOT(connectToDevices()));
connect(m_ui->pushButtonDisconnect, SIGNAL(clicked()), this, SLOT(disconnectFromDevices()));
connect(m_ui->actionScan, SIGNAL(triggered()), this, SLOT(scanDevices()));
connect(m_ui->actionConnect, SIGNAL(triggered()), this, SLOT(connectToDevices()));
connect(m_ui->actionDisconnect, SIGNAL(triggered()), this, SLOT(disconnectFromDevices()));
connect(m_ui->actionExit, SIGNAL(triggered()), this, SLOT(appExit()));
connect(m_ui->actionAbout, SIGNAL(triggered()), this, SLOT(about()));
m_ui->comboBoxSelectJoy->setDisabled(true);
setJoystickInfoVisible(false);
setDeviceControlVisible(false);
m_ui->ballWidget->hide();
m_ui->pushButtonScan->setFocus();
}
Application::Application() {
this->setWindowIcon(QIcon(":/images/mutter64.svg"));
view = new QWebEngineView();
this->setCentralWidget(view);
view->settings()->setAttribute(QWebEngineSettings::JavascriptCanAccessClipboard, true);
view->settings()->setAttribute(QWebEngineSettings::LocalStorageEnabled, true);
view->settings()->setAttribute(QWebEngineSettings::LocalContentCanAccessRemoteUrls, true);
view->settings()->setAttribute(QWebEngineSettings::LocalContentCanAccessFileUrls, true);
view->load(QUrl("https://test.webrtc.org/"));
trayMenu = new QMenu(this);
QAction *actionShowTalky = new QAction("Show Talky", trayMenu);
QAction *actionShowTest = new QAction("Show Troubleshooter", trayMenu);
QAction *actionExit = new QAction("Exit", trayMenu);
trayMenu->addAction(actionShowTalky);
trayMenu->addAction(actionShowTest);
trayMenu->addAction(actionExit);
trayIcon = new QSystemTrayIcon(this);
trayIcon->setIcon(QIcon(":/images/mutter64.png"));
trayIcon->setContextMenu(trayMenu);
trayIcon->show();
blockExit = true;
connect(actionShowTalky, SIGNAL(triggered()), this, SLOT(appShowTalky()));
connect(actionShowTest, SIGNAL(triggered()), this, SLOT(appShowTest()));
connect(actionExit, SIGNAL(triggered()), this, SLOT(appExit()));
connect(view->page(), SIGNAL(featurePermissionRequestCanceled(QUrl,QWebEnginePage::Feature)), this, SLOT(featurePermissionRequestCanceled(QUrl,QWebEnginePage::Feature)));
connect(view->page(), SIGNAL(featurePermissionRequested(QUrl,QWebEnginePage::Feature)), this, SLOT(featurePermissionRequested(QUrl,QWebEnginePage::Feature)));
debug("Application::Application()");
}
void close_app(GtkWidget* widget, gpointer user_data)
{
appExit(0);
}
/*
* sortRandom();
*
* Don't make any assumptions about the input. Store the input
* records in a large buffer, and sort those in-core records once
* all records are processed or the buffer is full. If the buffer
* fills up, store the sorted records into temporary files. Once
* all records are read, use mergeFiles() above to merge-sort the
* temporary files.
*
* Exits the application if an error occurs.
*/
static void
sortRandom(
void)
{
int temp_file_idx = -1;
skstream_t *input_rwios = NULL; /* input stream */
uint8_t *record_buffer = NULL; /* Region of memory for records */
uint8_t *cur_node = NULL; /* Ptr into record_buffer */
uint8_t *next_node = NULL; /* Ptr into record_buffer */
uint32_t buffer_max_recs; /* max buffer size (in number of recs) */
uint32_t buffer_recs; /* current buffer size (# records) */
uint32_t buffer_chunk_recs; /* how to grow from current to max buf */
uint32_t num_chunks; /* how quickly to grow buffer */
uint32_t record_count = 0; /* Number of records read */
int rv;
/* Determine the maximum number of records that will fit into the
* buffer if it grows the maximum size */
buffer_max_recs = buffer_size / NODE_SIZE;
TRACEMSG((("buffer_size = %" PRIu64
"\nnode_size = %" PRIu32
"\nbuffer_max_recs = %" PRIu32),
buffer_size, NODE_SIZE, buffer_max_recs));
/* We will grow to the maximum size in chunks */
num_chunks = NUM_CHUNKS;
if (num_chunks <= 0) {
num_chunks = 1;
}
/* Attempt to allocate the initial chunk. If we fail, increment
* the number of chunks---which will decrease the amount we
* attempt to allocate at once---and try again. */
for (;;) {
buffer_chunk_recs = buffer_max_recs / num_chunks;
TRACEMSG((("num_chunks = %" PRIu32
"\nbuffer_chunk_recs = %" PRIu32),
num_chunks, buffer_chunk_recs));
record_buffer = (uint8_t*)malloc(NODE_SIZE * buffer_chunk_recs);
if (record_buffer) {
/* malloc was successful */
break;
} else if (buffer_chunk_recs < MIN_IN_CORE_RECORDS) {
/* give up at this point */
skAppPrintErr("Error allocating space for %d records",
MIN_IN_CORE_RECORDS);
appExit(EXIT_FAILURE);
} else {
/* reduce the amount we allocate at once by increasing the
* number of chunks and try again */
TRACEMSG(("malloc() failed"));
++num_chunks;
}
}
buffer_recs = buffer_chunk_recs;
TRACEMSG((("buffer_recs = %" PRIu32), buffer_recs));
/* open first file */
rv = appNextInput(&input_rwios);
if (rv < 0) {
free(record_buffer);
appExit(EXIT_FAILURE);
}
record_count = 0;
cur_node = record_buffer;
while (input_rwios != NULL) {
/* read record */
if ((rv = skStreamReadRecord(input_rwios, (rwRec*)cur_node))
!= SKSTREAM_OK)
{
if (rv != SKSTREAM_ERR_EOF) {
skStreamPrintLastErr(input_rwios, rv, &skAppPrintErr);
}
/* end of file: close current and open next */
skStreamDestroy(&input_rwios);
rv = appNextInput(&input_rwios);
if (rv < 0) {
free(record_buffer);
appExit(EXIT_FAILURE);
}
continue;
}
++record_count;
cur_node += NODE_SIZE;
if (record_count == buffer_recs) {
/* Filled the current buffer */
/* If buffer not at max size, see if we can grow it */
if (buffer_recs < buffer_max_recs) {
uint8_t *old_buf = record_buffer;
/* add a chunk of records. if we are near the max,
* set the size to the max */
buffer_recs += buffer_chunk_recs;
if (buffer_recs + buffer_chunk_recs > buffer_max_recs) {
buffer_recs = buffer_max_recs;
}
TRACEMSG((("Buffer full---attempt to grow to %" PRIu32
" records, %" PRIu32 " bytes"),
buffer_recs, NODE_SIZE * buffer_recs));
/* attempt to grow */
record_buffer = (uint8_t*)realloc(record_buffer,
NODE_SIZE * buffer_recs);
if (record_buffer) {
/* Success, make certain cur_node points into the
* new buffer */
cur_node = (record_buffer + (record_count * NODE_SIZE));
} else {
/* Unable to grow it */
TRACEMSG(("realloc() failed"));
record_buffer = old_buf;
buffer_max_recs = buffer_recs = record_count;
}
}
/* Either buffer at maximum size or attempt to grow it
* failed. */
if (record_count == buffer_max_recs) {
/* Sort */
skQSort(record_buffer, record_count, NODE_SIZE, &rwrecCompare);
/* Write to temp file */
if (skTempFileWriteBufferStream(
tmpctx, &temp_file_idx,
record_buffer, NODE_SIZE, record_count))
{
skAppPrintSyserror(
"Error writing sorted buffer to temporary file");
free(record_buffer);
appExit(EXIT_FAILURE);
}
/* Reset record buffer to 'empty' */
record_count = 0;
cur_node = record_buffer;
}
}
}
/* Sort (and maybe store) last batch of records */
if (record_count > 0) {
skQSort(record_buffer, record_count, NODE_SIZE, &rwrecCompare);
if (temp_file_idx >= 0) {
/* Write last batch to temp file */
if (skTempFileWriteBufferStream(
tmpctx, &temp_file_idx,
record_buffer, NODE_SIZE, record_count))
{
skAppPrintSyserror(
"Error writing sorted buffer to temporary file");
free(record_buffer);
appExit(EXIT_FAILURE);
}
}
}
/* Generate the output */
if (record_count == 0 && temp_file_idx == -1) {
/* No records were read at all; write the header to the output
* file */
rv = skStreamWriteSilkHeader(out_rwios);
if (0 != rv) {
skStreamPrintLastErr(out_rwios, rv, &skAppPrintErr);
}
} else if (temp_file_idx == -1) {
/* No temp files written, just output batch of records */
uint32_t c;
TRACEMSG((("Writing %" PRIu32 " records to '%s'"),
record_count, skStreamGetPathname(out_rwios)));
/* get first two records from the sorted buffer */
cur_node = record_buffer;
next_node = record_buffer + NODE_SIZE;
for (c = 1; c < record_count; ++c, next_node += NODE_SIZE) {
if (0 != rwrecCompare(cur_node, next_node)) {
/* records differ. print earlier record */
rv = skStreamWriteRecord(out_rwios, (rwRec*)cur_node);
if (0 != rv) {
skStreamPrintLastErr(out_rwios, rv, &skAppPrintErr);
if (SKSTREAM_ERROR_IS_FATAL(rv)) {
free(record_buffer);
appExit(EXIT_FAILURE);
}
}
cur_node = next_node;
}
/* else records are duplicates: ignore latter record */
}
/* print remaining record */
rv = skStreamWriteRecord(out_rwios, (rwRec*)cur_node);
if (0 != rv) {
skStreamPrintLastErr(out_rwios, rv, &skAppPrintErr);
if (SKSTREAM_ERROR_IS_FATAL(rv)) {
free(record_buffer);
appExit(EXIT_FAILURE);
}
}
} else {
/* no longer have a need for the record buffer */
free(record_buffer);
record_buffer = NULL;
/* now merge all the temp files */
mergeFiles(temp_file_idx);
}
if (record_buffer) {
free(record_buffer);
}
}
/*
* mergeFiles(temp_file_idx)
*
* Merge the temporary files numbered from 0 to 'temp_file_idx'
* inclusive into the output file 'out_ios', maintaining sorted
* order. Exits the application if an error occurs.
*/
static void
mergeFiles(
int temp_file_idx)
{
char errbuf[2 * PATH_MAX];
skstream_t *fps[MAX_MERGE_FILES];
uint8_t recs[MAX_MERGE_FILES][NODE_SIZE];
uint8_t lowest_rec[NODE_SIZE];
int j;
uint16_t open_count;
uint16_t i;
uint16_t lowest;
uint16_t *top_heap;
int tmp_idx_a;
int tmp_idx_b;
skstream_t *fp_intermediate = NULL;
int tmp_idx_intermediate;
skheap_t *heap;
uint32_t heap_count;
int opened_all_temps = 0;
ssize_t rv;
/* the index of the first temp file to the merge */
tmp_idx_a = 0;
TRACEMSG(("Merging #%d through #%d to '%s'",
tmp_idx_a, temp_file_idx, skStreamGetPathname(out_rwios)));
heap = skHeapCreate2(compHeapNodes, MAX_MERGE_FILES, sizeof(uint16_t),
NULL, recs);
if (NULL == heap) {
skAppPrintOutOfMemory("heap");
appExit(EXIT_FAILURE);
}
/* This loop repeats as long as we haven't read all of the temp
* files generated in the qsort stage. */
do {
assert(SKHEAP_ERR_EMPTY==skHeapPeekTop(heap,(skheapnode_t*)&top_heap));
/* the index of the list temp file to merge */
tmp_idx_b = temp_file_idx;
/* open an intermediate temp file. The merge-sort will have
* to write records here if there are not enough file handles
* available to open all the existing tempoary files. */
fp_intermediate = skTempFileCreateStream(tmpctx, &tmp_idx_intermediate);
if (fp_intermediate == NULL) {
skAppPrintSyserror("Error creating new temporary file");
appExit(EXIT_FAILURE);
}
/* count number of files we open */
open_count = 0;
/* Attempt to open up to MAX_MERGE_FILES, though we an open
* may fail due to lack of resources (EMFILE or ENOMEM) */
for (j = tmp_idx_a; j <= tmp_idx_b; ++j) {
fps[open_count] = skTempFileOpenStream(tmpctx, j);
if (fps[open_count] == NULL) {
if ((open_count > 0)
&& ((errno == EMFILE) || (errno == ENOMEM)))
{
/* We cannot open any more files. Rewind counter
* by one to catch this file on the next merge */
tmp_idx_b = j - 1;
TRACEMSG((("FILE limit hit--"
"merging #%d through #%d into #%d: %s"),
tmp_idx_a, tmp_idx_b, tmp_idx_intermediate,
strerror(errno)));
break;
} else {
skAppPrintSyserror(("Error opening existing"
" temporary file '%s'"),
skTempFileGetName(tmpctx, j));
appExit(EXIT_FAILURE);
}
}
/* read the first record */
rv = skStreamRead(fps[open_count], recs[open_count], NODE_SIZE);
if (NODE_SIZE == rv) {
/* insert the file index into the heap */
skHeapInsert(heap, &open_count);
++open_count;
if (open_count == MAX_MERGE_FILES) {
/* We've reached the limit for this pass. Set
* tmp_idx_b to the file we just opened. */
tmp_idx_b = j;
TRACEMSG((("MAX_MERGE_FILES limit hit--"
"merging #%d through #%d to #%d"),
tmp_idx_a, tmp_idx_b, tmp_idx_intermediate));
break;
}
} else if (0 == rv) {
TRACEMSG(("Ignoring empty temporary file '%s'",
skTempFileGetName(tmpctx, j)));
skStreamDestroy(&fps[open_count]);
} else {
if (rv > 0) {
snprintf(errbuf, sizeof(errbuf),
"Short read %" SK_PRIdZ "/%" PRIu32 " from '%s'",
rv, NODE_SIZE,
skStreamGetPathname(fps[open_count]));
} else {
skStreamLastErrMessage(
fps[open_count], rv, errbuf, sizeof(errbuf));
}
skAppPrintErr(
"Error reading first record from temporary file: %s",
errbuf);
appExit(EXIT_FAILURE);
}
}
/* Here, we check to see if we've opened all temp files. If
* so, set a flag so we write data to final destination and
* break out of the loop after we're done. */
if (tmp_idx_b == temp_file_idx) {
opened_all_temps = 1;
/* no longer need the intermediate temp file */
skStreamDestroy(&fp_intermediate);
} else {
/* we could not open all temp files, so merge all opened
* temp files into the intermediate file. Add the
* intermediate file to the list of files to merge */
temp_file_idx = tmp_idx_intermediate;
}
TRACEMSG((("Merging %" PRIu16 " temporary files"), open_count));
heap_count = skHeapGetNumberEntries(heap);
assert(heap_count == open_count);
/* get the index of the file with the lowest record; which is
* at the top of the heap */
if (skHeapPeekTop(heap, (skheapnode_t*)&top_heap) != SKHEAP_OK) {
skAppPrintErr("Unable to open and read any temporary files.");
appExit(EXIT_FAILURE);
}
lowest = *top_heap;
/* exit this do...while() once all records for all opened
* files have been read */
do {
/* lowest_rec is the record pointed to by the index at the
* top of the heap */
memcpy(lowest_rec, recs[lowest], NODE_SIZE);
/* write the record */
if (fp_intermediate) {
/* write the record to intermediate tmp file */
rv = skStreamWrite(fp_intermediate, lowest_rec, NODE_SIZE);
if (NODE_SIZE != rv) {
skAppPrintSyserror(
"Error writing record to temporary file '%s'",
skTempFileGetName(tmpctx, tmp_idx_intermediate));
appExit(EXIT_FAILURE);
}
} else {
/* we successfully opened all (remaining) temp files,
* write to record to the final destination */
rv = skStreamWriteRecord(out_rwios, (rwRec*)lowest_rec);
if (0 != rv) {
skStreamPrintLastErr(out_rwios, rv, &skAppPrintErr);
if (SKSTREAM_ERROR_IS_FATAL(rv)) {
appExit(EXIT_FAILURE);
}
}
}
/* replace the record we just processed and loop over all
* files until we get a record that is not a duplicate */
do {
if ((rv = skStreamRead(fps[lowest], recs[lowest], NODE_SIZE))
!= NODE_SIZE)
{
/* read failed. there is no more data for this
* file; remove it from the heap; if the heap is
* empty, exit the loop */
skHeapExtractTop(heap, NULL);
--heap_count;
#if TRACEMSG_LEVEL > 0
if (rv == 0) {
TRACEMSG(
("Finished reading file #%u: EOF; %u files remain",
(tmp_idx_a + lowest), heap_count));
} else if (rv > 0) {
TRACEMSG(
("Finished reading file #%u: Short read "
"%" SK_PRIdZ "/%" PRIu32 "; %u files remain",
tmp_idx_a + lowest, rv, NODE_SIZE, heap_count));
} else {
skStreamLastErrMessage(
fps[open_count], rv, errbuf, sizeof(errbuf));
TRACEMSG(
("Finished reading file #%u: %s; %u files remain",
(tmp_idx_a + lowest), errbuf, heap_count));
}
#endif /* TRACEMSG_LEVEL */
if (0 == heap_count) {
break;
}
} else if (rwrecCompare(lowest_rec, recs[lowest])) {
/* read succeeded. new record is not a
* duplicate and we insert it into the heap */
/* FIXME: This comparison reduces work when the
* keys are the same, but it adds another
* comparison when the keys are different; is this
* an overall win or lose? */
skHeapReplaceTop(heap, &lowest, NULL);
} else {
/* read succeeded. record is a duplicate; ignore
* the record and leave the heap unchanged */
continue;
}
/* get the record at the top of the heap and see if it
* is a duplicate; if it is, ignore it. */
skHeapPeekTop(heap, (skheapnode_t*)&top_heap);
lowest = *top_heap;
} while (0 == rwrecCompare(lowest_rec, recs[lowest]));
} while (heap_count > 0);
TRACEMSG((("Finished processing #%d through #%d"),
tmp_idx_a, tmp_idx_b));
/* Close all open temp files */
for (i = 0; i < open_count; ++i) {
skStreamDestroy(&fps[i]);
}
/* Delete all temp files we opened (or attempted to open) this
* time */
for (j = tmp_idx_a; j <= tmp_idx_b; ++j) {
skTempFileRemove(tmpctx, j);
}
/* Close the intermediate temp file. */
if (fp_intermediate) {
rv = skStreamClose(fp_intermediate);
if (rv) {
skStreamLastErrMessage(
fp_intermediate, rv, errbuf, sizeof(errbuf));
skAppPrintErr("Error closing temporary file: %s", errbuf);
skStreamDestroy(&fp_intermediate);
appExit(EXIT_FAILURE);
}
skStreamDestroy(&fp_intermediate);
}
/* Start the next merge with the next input temp file */
tmp_idx_a = tmp_idx_b + 1;
} while (!opened_all_temps);
skHeapFree(heap);
}
int main( int argc, char **argv )
{
//int ret = 0;
PTZControlInit();
demo_setting * ext_gSettings = NULL;
// Allocate the "global" settings
ext_gSettings = (demo_setting*)malloc( sizeof( demo_setting ) );
if ( NULL == ext_gSettings ) {
printf( "main::out of memory!\n" );
return -1;
}
sig_init();
atexit(appExit);
//init the setting struct
Settings_Initialize( ext_gSettings );
read_Parse(ext_gSettings);
//printf("video type = %d \n", ext_gSettings->video_types);
//...do your job
//close the led
setled_off();
//init dma memory
akuio_pmem_init();
encode_init();
printf("encode_init ok\n");
//open camera
camera_open(ext_gSettings->width, ext_gSettings->height);
printf("camera_open ok\n");
//encode_open
T_ENC_INPUT encInput;
encInput.width = ext_gSettings->width; //实际编码图像的宽度，能被4整除
encInput.height = ext_gSettings->height; //实际编码图像的长度，能被2整除
encInput.kbpsmode = ext_gSettings->kbpsmode;
encInput.qpHdr = ext_gSettings->qpHdr; //初始的QP的值
encInput.iqpHdr = ext_gSettings->iqpHdr; //初始的QP的值
encInput.bitPerSecond = ext_gSettings->bitPerSecond; //目标bps
encInput.minQp = ext_gSettings->minQp;
encInput.maxQp = ext_gSettings->maxQp;
encInput.framePerSecond = ext_gSettings->framePerSecond;
encInput.video_tytes = ext_gSettings->video_types;
encode_open(&encInput);
printf("encode_open ok\n");
//set mux
mux_input.rec_path = ext_gSettings->rec_path;
mux_input.m_MediaRecType = MEDIALIB_REC_AVI_NORMAL;
if (ext_gSettings->bhasAudio)
{
bHasAudio = 1;
//mux_input.m_bCaptureAudio = 1;
}
else
{
bHasAudio = 0;
//mux_input.m_bCaptureAudio = 0;
}
mux_input.m_bCaptureAudio = 1;
//mux video
if(parse.format2 == 0)
{
mux_input.m_eVideoType = MEDIALIB_VIDEO_H264;
}
else if(parse.format2 == 1)
{
mux_input.m_eVideoType = MEDIALIB_VIDEO_MJPEG;
}
mux_input.m_nWidth = parse.width2;
mux_input.m_nHeight = parse.height2;
//mux audio
mux_input.m_eAudioType = MEDIALIB_AUDIO_AAC;
mux_input.m_nSampleRate = 8000;
//mux_input.abitsrate = ext_gSettings->abitsrate;
printf("mux_open ok\n");
//if (ext_gSettings->bhasAudio)
{
T_AUDIO_INPUT audioInput;
audioInput.enc_type = (AUDIO_ENCODE_TYPE_CC)ext_gSettings->audioType;
audioInput.nBitsRate = ext_gSettings->abitsrate;
audioInput.nBitsPerSample = 16;
audioInput.nChannels = 1;
audioInput.nSampleRate = ext_gSettings->aSamplerate;
audio_open(&audioInput);
printf("audio_open ok\n");
audio_start();
}
//start ftp server
//startFTPSrv();
Init_photograph();
//PTZControlInit();
//start video process
video_process_start();
InitMotionDetect();
DemuxForLiveSetCallBack();
TaskScheduler* scheduler = BasicTaskScheduler::createNew();
env = BasicUsageEnvironment::createNew(*scheduler);
UserAuthenticationDatabase* authDB = NULL;
#ifdef ACCESS_CONTROL
// To implement client access control to the RTSP server, do the following:
authDB = new UserAuthenticationDatabase;
authDB->addUserRecord("username1", "password1"); // replace these with real strings
// Repeat the above with each <username>, <password> that you wish to allow
// access to the server.
#endif
// Create the RTSP server:
RTSPServer* rtspServer = AKRTSPServer::createNew(*env, RTSPPORT, authDB);
if (rtspServer == NULL)
{
*env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";
appExit();
exit(1);
}
char const* descriptionString = "Session streamed by \"testOnDemandRTSPServer\"";
// Set up each of the possible streams that can be served by the
// RTSP server. Each such stream is implemented using a
// "ServerMediaSession" object, plus one or more
// "ServerMediaSubsession" objects for each audio/video substream.
int vsIndex = 0;
VIDEO_MODE vm[2] = {VIDEO_MODE_VGA,VIDEO_MODE_VGA};
const char* streamName1 = "vs1";
const char* streamName2 = "vs2";
((AKRTSPServer*)rtspServer)->SetStreamName(streamName1, streamName2);
if(ext_gSettings->video_types == 1)
{
if(ext_gSettings->width == 640)
{
vm[0] = VIDEO_MODE_VGA;
}
else if(ext_gSettings->width == 320)
{
vm[0] = VIDEO_MODE_QVGA;
}
else if(ext_gSettings->width == 720)
{
vm[0] = VIDEO_MODE_D1;
}
AKIPCMJPEGFramedSource* ipcMJPEGSourcecam = NULL;
ServerMediaSession* smsMJPEGcam = ServerMediaSession::createNew(*env, streamName1, 0, descriptionString);
AKIPCMJPEGOnDemandMediaSubsession* subsMJPEGcam = AKIPCMJPEGOnDemandMediaSubsession::createNew(*env,ipcMJPEGSourcecam, ext_gSettings->width, ext_gSettings->height, vsIndex);
smsMJPEGcam->addSubsession(subsMJPEGcam);
subsMJPEGcam->getframefunc = video_process_get_buf;
subsMJPEGcam->setledstart = setled_view_start;
subsMJPEGcam->setledexit = setled_view_stop;
if(bHasAudio)
smsMJPEGcam->addSubsession(AKIPCAACAudioOnDemandMediaSubsession::createNew(*env,True,getAACBuf, vsIndex));
rtspServer->addServerMediaSession(smsMJPEGcam);
char* url1 = rtspServer->rtspURL(smsMJPEGcam);
*env << "using url \"" << url1 <<"\"\n";
delete[] url1;
}
else if(ext_gSettings->video_types == 0)
{
if(ext_gSettings->width == 1280)
{
vm[0] = VIDEO_MODE_720P;
}
else if(ext_gSettings->width == 640)
{
vm[0] = VIDEO_MODE_VGA;
}
else if(ext_gSettings->width == 320)
{
vm[0] = VIDEO_MODE_QVGA;
}
else if(ext_gSettings->width == 720)
{
vm[0] = VIDEO_MODE_D1;
}
AKIPCH264FramedSource* ipcSourcecam = NULL;
ServerMediaSession* smscam = ServerMediaSession::createNew(*env, streamName1, 0, descriptionString);
AKIPCH264OnDemandMediaSubsession* subscam = AKIPCH264OnDemandMediaSubsession::createNew(*env,ipcSourcecam, 0, vsIndex);
smscam->addSubsession(subscam);
if(bHasAudio)
smscam->addSubsession(AKIPCAACAudioOnDemandMediaSubsession::createNew(*env,True,getAACBuf, vsIndex));
subscam->getframefunc = video_process_get_buf;
subscam->setledstart = setled_view_start;
subscam->setledexit = setled_view_stop;
rtspServer->addServerMediaSession(smscam);
char* url1 = rtspServer->rtspURL(smscam);
*env << "using url \"" << url1 <<"\"\n";
delete[] url1;
}
vsIndex = 1;
if(parse.format2 == 0)//264
{
if(parse.width2 == 1280)
{
vm[1] = VIDEO_MODE_720P;
}
else if(parse.width2 == 640)
{
vm[1] = VIDEO_MODE_VGA;
}
else if(parse.width2 == 320)
{
vm[1] = VIDEO_MODE_QVGA;
}
else if(parse.width2 == 720)
{
vm[1] = VIDEO_MODE_D1;
}
AKIPCH264FramedSource* ipcSourcecam = NULL;
ServerMediaSession* smscam = ServerMediaSession::createNew(*env, streamName2, 0, descriptionString);
AKIPCH264OnDemandMediaSubsession* subscam = AKIPCH264OnDemandMediaSubsession::createNew(*env,ipcSourcecam, 0, vsIndex);
smscam->addSubsession(subscam);
if(bHasAudio)
smscam->addSubsession(AKIPCAACAudioOnDemandMediaSubsession::createNew(*env,True,getAACBuf, vsIndex));
subscam->getframefunc = video_process_get_buf;
subscam->setledstart = setled_view_start;
subscam->setledexit = setled_view_stop;
rtspServer->addServerMediaSession(smscam);
char* url2 = rtspServer->rtspURL(smscam);
*env << "using url \"" << url2 <<"\"\n";
delete[] url2;
}
else if(parse.format2 == 1)//mjpeg
{
if(parse.width2 == 640)
{
vm[1] = VIDEO_MODE_VGA;
}
else if(parse.width2 == 320)
{
vm[1] = VIDEO_MODE_QVGA;
}
else if(parse.width2 == 720)
{
vm[1] = VIDEO_MODE_D1;
}
AKIPCMJPEGFramedSource* ipcMJPEGSourcecam = NULL;
ServerMediaSession* smsMJPEGcam = ServerMediaSession::createNew(*env, streamName2, 0, descriptionString);
AKIPCMJPEGOnDemandMediaSubsession* subsMJPEGcam = AKIPCMJPEGOnDemandMediaSubsession::createNew(*env,ipcMJPEGSourcecam, parse.width2, parse.height2, vsIndex);
smsMJPEGcam->addSubsession(subsMJPEGcam);
subsMJPEGcam->getframefunc = video_process_get_buf;
subsMJPEGcam->setledstart = setled_view_start;
subsMJPEGcam->setledexit = setled_view_stop;
if(bHasAudio)
smsMJPEGcam->addSubsession(AKIPCAACAudioOnDemandMediaSubsession::createNew(*env,True,getAACBuf, vsIndex));
rtspServer->addServerMediaSession(smsMJPEGcam);
char* url2 = rtspServer->rtspURL(smsMJPEGcam);
*env << "using url \"" << url2 <<"\"\n";
delete[] url2;
}
#if 0
if (rtspServer->setUpTunnelingOverHTTP(80) || rtspServer->setUpTunnelingOverHTTP(8000) || rtspServer->setUpTunnelingOverHTTP(8080))
{
*env << "\n(We use port " << rtspServer->httpServerPortNum() << " for optional RTSP-over-HTTP tunneling.)\n";
}
else
{
*env << "\n(RTSP-over-HTTP tunneling is not available.)\n";
}
#endif
//printf("streamName:%s,Port:%d\n", streamName1, RTSPPORT);
NetCtlSrvPar ncsp;
memset(&ncsp, 0, sizeof(ncsp));
getDeviceID(ncsp.strDeviceID);
printf("device id:**%s**\n", ncsp.strDeviceID);
strcpy(ncsp.strStreamName1, streamName1);
strcpy(ncsp.strStreamName2, streamName2);
ncsp.vm1 = vm[0];
ncsp.vm2 = vm[1];
ncsp.nRtspPort = RTSPPORT;
ncsp.nMainFps = parse.fps1;
ncsp.nSubFps = parse.fps2;
//start net command server
startNetCtlServer(&ncsp);
printf("[##]start record...\n");
auto_record_file();
printf("[##]auto_record_file() called..\n");
//at last,start rtsp loop
env->taskScheduler().doEventLoop(); // does not return
return 0;
}
void PlistsGroup::createList(PlaylistWidget::ListTypes listType, QString title, quint64 hash, bool bManually, bool bLast)
{
QString tabIconFile;
QString type;
switch(listType) {
case PlaylistWidget::Search:
type = tr("Search");
tabIconFile = ":/icons/tab_search";
break;
case PlaylistWidget::AudioLib:
type = tr("Library");
tabIconFile = ":/icons/tab_library";
break;
case PlaylistWidget::LocalList:
type = tr("Local");
tabIconFile = ":/icons/tab_local";
break;
case PlaylistWidget::Suggestions:
type = tr("Suggestions");
tabIconFile = ":/icons/tab_suggestions";
break;
case PlaylistWidget::DbSearch:
type = tr("Discography");
tabIconFile = ":/icons/tab_db";
break;
}
if(title == "")
m_ListsNames << type;
else
m_ListsNames << title;
if(title == "") {
if(m_ListsNames.count(type) > 1)
title = QString("%0 (%1)").arg(type).arg(m_ListsNames.count(type));
else
title = type;
} else {
if(m_ListsNames.count(title) > 1)
title = QString("%0 (%1)").arg(title).arg(m_ListsNames.count(title));
}
m_playLists.insert(m_playLists.end(), new Playlist(listType, title, hash));
m_widget->addList(m_playLists.last(), bManually);
m_widget->setTabIcon(m_playLists.size()-1, QIcon(QPixmap(tabIconFile)));
connect(m_playLists.last(), SIGNAL(message(QString,QString)), SIGNAL(message(QString,QString)));
connect(m_playLists.last(), SIGNAL(playTrack(Track*)), SIGNAL(playTrack(Track*)));
connect(m_playLists.last(), SIGNAL(playTrack(Track*)), SLOT(trackActivate(Track*)));
connect(m_playLists.last(), SIGNAL(addQueue(Track*)), SLOT(addToQueue(Track*)));
connect(m_playLists.last(), SIGNAL(active()), SLOT(setActiveList()));
connect(m_playLists.last(), SIGNAL(titleChanged(QString)), SLOT(setPlaylistTitle(QString)));
connect(this, SIGNAL(shuffleChanged(bool)), m_playLists.last(), SLOT(setShuffle(bool)));
connect(this, SIGNAL(repeatChanged(bool)), m_playLists.last(), SLOT(setRepeat(bool)));
connect(this, SIGNAL(metaTagsChanged(bool,bool)), m_playLists.last(), SIGNAL(metaTagsChanged(bool,bool)));
connect(this, SIGNAL(metaTagsChanged(bool,bool)), m_playLists.last(), SLOT(setMetaTagsChanged(bool,bool)));
connect(this, SIGNAL(appExit()), m_playLists.last(), SLOT(onExit()));
m_playLists.last()->setMetaTagsChanged(m_bLoadMeta, m_bUseMeta);
if(m_repeatMode > 2)
m_playLists.last()->setRepeat(true);
else
m_playLists.last()->setRepeat(false);
if(bLast)
m_LastList = m_playLists.last();
updateLocalLists();
}
void PlistsGroup::onExit()
{
Q_EMIT appExit();
savePlaylists();
}
