void producer(std::atomic<bool>& keep_working, concurrent_queue<std::vector<char> >& sink)
{
    while (keep_working.load())
    {
        if (sink.size() > 10000)
            std::this_thread::yield();
        else
            sink.push(std::vector<char>(rand() % 10000));
    }
}

void* worker(void* d) {
    shared_ptr<UploadBuffer> pdata;
    srand(time(NULL));
    // get data from fq
    while (1) {
        fq.deQ(pdata);

        if (pdata->index == 0) {
            // inited data??
            cout << "inited data" << std::endl;
        }

        if (pdata->index == -1) {  //  finished
            // cout<<"finished"<<std::endl;
            break;
        }

        MD5Calc m;
        m.Update(pdata->data.getdata(), pdata->data.len());
        cout << pdata->index << "\t" << m.Get() << std::endl;
        // sleep(rand()%5);

        // reset pdata
        pdata->data.reset();
        pdata->index = 0;

        // re queue to empty queue
        eq.enQ(pdata);
    }
    // cout<<"quit...\n";
}

void child() {
    for (int i=1; i<=max_num; i++) {
        cq.push(i);
    }
    // Queue is closed only if all child threads are finished
    if(bar.wait()) cq.close();
}

int main()
{
    srand(time(0));

    // Custom scheduling is not required - can be integrated
    // to other systems transparently
    main_tasks.push([]
    {
        asynchronous([]
        {
            return async_user_handler(),
                   finished = true;
        });
    });

    Task task;
    while(!finished)
    {
        main_tasks.pop(task);
        task();
    }

    cout << "Done" << std::endl;

    return EXIT_SUCCESS;
}

static void* ccr_worker(void *arg)
{
    int r, resume;
    process_t *proc;
    while (1)
    {
        // Checks if threads need to be killed and the the ready procces's queue is empty
        // That way only when the queue is empty the threads are killed
        // if ((free_flag.compare_and_swap(false, true)) && (prc_ready.empty()))
        if (free_flag.compare_and_swap(false, true))
        {
            pthread_t thread = pthread_self();
            // removes reference from the pool
            thr_pool.remove(thread);

            // checks if threre's more threads to kill and set the flag
            if (free_workers.fetch_and_decrement() > 1)
            {
                free_flag.compare_and_swap(true, false);
            }

            //kills the current thread
            pthread_exit(NULL);
        }
        prc_ready.pop(proc);
        if (!proc) return NULL;
        r = lua_resume(proc->L, 0);
        switch (r)
        {
            case  LUA_YIELD:
                //cerr << "Yield!\n";
                switch (proc->status)
                {
                    case PS_READY:
                        // releasing the lock acquired in ccr_yield
                        proc->wlock.release();
                        prc_ready.push(proc);
                        break;
                    case PS_BLOCKING:
                        proc->status = PS_BLOCKED;
                        // releasing the lock acquired in ccr_yield
                        proc->wlock.release();
                        break;
                }
                break;
            case LUA_ERRRUN:
            case LUA_ERRMEM:
            case LUA_ERRERR:
                cerr << "[ERROR][PROCESSING A LUA PROCESS] " << lua_tostring(proc->L, -1) << endl;
                // fall-through
            case 0:
                lua_close(proc->L);
                mbx_close(proc->mbox);
                prc_free(proc);
                break;
        }
    }
    return NULL;
}

 //! Get pair of matricies if present
 bool pop_if_present( pair<Matrix2x2, Matrix2x2> &mm ) {
     // get first matrix if present
     if(!Queue.pop_if_present(mm.first)) return false;
     // get second matrix if present
     if(!Queue.pop_if_present(mm.second)) {
         // if not, then push back first matrix
         Queue.push(mm.first); return false;
     }
     return true;
 }

int main(int argc, char*argv[])
{
    size_t nElements = 1280000;
    size_t nthreads = 1;
    struct timeval start, stop;

    if (argc >= 2) {
        nthreads = atoi(argv[1]);
    }
    if (argc >= 3) {
        nElements = atoi(argv[2]);
    }
    if (argc >= 4) {
        objsize = atoi(argv[3]);
    }

    task_scheduler_init init(nthreads);

    for (uintptr_t i = 0; i < nElements; i++) {
        cq.push((void*)i);
    }
    for (uintptr_t i = 0; i < nElements; i++) {
        void* j;
        cq.try_pop(j);
        assert(i == (uintptr_t)j);
    }
    assert(cq.empty());

    tick_count t0 = tick_count::now();
    parallel_for(blocked_range<size_t>(0, nElements), loop_queuer());
    tick_count t1 = tick_count::now();
    printf("queue time: %f secs\n", (t1 - t0).seconds());

    t0 = tick_count::now();
    parallel_for(blocked_range<size_t>(0, nElements), loop_dequeuer());
    t1 = tick_count::now();
    printf("dequeue time: %f secs\n", (t1 - t0).seconds());

    assert(cq.empty());

    t0 = tick_count::now();
    parallel_for(blocked_range<size_t>(0, nElements), loop_queuer());
    parallel_for(blocked_range<size_t>(0, nElements), loop_dequeuer());
    t1 = tick_count::now();
    printf("both time: %f secs\n", (t1 - t0).seconds());

    assert(cq.empty());

    printf("success!\n");
    return 0;
}

 //! executing filter
 /*override*/ void* operator()(void*)
 {
     int n = --N;
     if(n <= 0) return 0;
     Queue.push( Matrix1110 );
     return &Queue;
 }

void *worker(void *a) {
    int r;
    while (1) {
        q.deQ(r);
        if (r == -1) break;
    }
    return NULL;
}

    void operator() (const blocked_range<size_t>&r) const
    {
        size_t begin = r.begin();
        size_t end = r.end();

        for (size_t i = begin; i < end; i++) {
            void * tmp = tbballoc.allocate(1);
            memset(tmp, 1, objsize);
            cq.push(tmp);
        }
    }

int ccr_rawsend(process_t *proc, message_t *msg)
{
    queuing_rw_mutex::scoped_lock rlock;
    rlock.acquire(proc->lock, false);
    if (mbx_put(proc->mbox, msg))
    {
        if (proc->status.compare_and_swap(PS_READY, PS_BLOCKED) == PS_BLOCKED)
            prc_ready.push(proc);
        rlock.release();
        return 1;
    }
    rlock.release();
    return 0;
}

void writefn(std::string outaudio, std::string outdiff)
{
	std::ofstream oaudio(outaudio, std::ios::binary);
	//int fourcc = CV_FOURCC('4', '6', '2', 'H');
	int fourcc = -1;
	std::cout << "creating VideoWriter\n";
	std::cout << "fps " << vid_fps << ", reduction " << reduction << "\n";
	cv::VideoWriter odiff(outdiff.c_str(), fourcc, vid_fps / reduction, cv::Size(width, height), true);
	//cv::VideoWriter omask(outmask.c_str(), fourcc, vid_fps / reduction, cv::Size(width, height), true);
	std::cout << "done creating VideoWriter\n";

	WriteElement element;

	while (true)
	{
		bool rv = writequeue.try_pop(element);
		if (!rv) continue;

		if (element.done) break;

		// video

		odiff.write(element.mat);

		// audio

		int u = (int)iround(audiorate * (element.frameno + 0) / (vid_fps / reduction));
		int v = (int)iround(audiorate * (element.frameno + 1) / (vid_fps / reduction));
		int nsamples = v - u;
		std::vector<int16_t> samples(nsamples, 0);

		for (int k = 0; k < nsamples; k += 1)
			samples[k] = sin(audiofreq * 2 * M_PI / audiorate * (u + k))
			* ((1<<15)-1)
			* linmap(20 * log10(element.masksum), -90.0, 0.0, 0.0, 1.0);

		oaudio.write((char*)samples.data(), sizeof(samples[0]) * nsamples);

	}

	odiff.release();
	oaudio.close();

	std::cout << "writer is done\n";
}

static int ccr_finalize(lua_State *L)
{
    int i;
    process_t *proc;
    lua_getfield(L, LUA_REGISTRYINDEX, CCR_SELF);
    proc = (process_t*)lua_touserdata(L, -1);
    if (proc->main)
    {
        for (i = 0; i < THR_SIZE; i++)
        {
            prc_ready.push(NULL);
        }

        for (list<pthread_t>::iterator thread = thr_pool.begin(); thread!=thr_pool.end(); ++thread)
        {
            pthread_join(*thread, NULL);
        }
    }
    return 0;
}

static int ccr_spawn(lua_State *L)
{
    process_t *proc;
    const char *str = luaL_checkstring(L, 1);
    proc = new process_t();
    if (proc)
    {
        proc->main = 0;
        proc->counter = 1;
        proc->status = PS_READY;
        proc->mbox = mbx_create();
        if (proc->mbox)
        {
            proc->L = luaL_newstate();
            if (proc->L)
            {
                // luaL_openlibs(proc->L);
                ccr_openlibs(proc->L);
                lua_pushstring(proc->L, CCR_SELF);
                lua_pushlightuserdata(proc->L, proc);
                lua_rawset(proc->L, LUA_REGISTRYINDEX);
                if (!luaL_loadstring(proc->L, str))
                {
                    prc_ready.push(proc);
                    lua_pushboolean(L, 1);
                    return 1;
                }
                cerr << "[ERROR][CREATING LUA PROCESS] " << lua_tostring(proc->L, -1) << endl;
                lua_close(proc->L);
            }
            mbx_free(proc->mbox);
        }
        delete proc;
    }
    lua_pushboolean(L, 0);
    return 1;
}

 concurrent( T t_ ) : t{t_}, thd{[=]{ while(!done) q.pop()(); }} { }

int main(int argc, char* argv[]) {
    vector<pthread_t> threads;
    shared_ptr<UploadBuffer> curdata;

    if (argc < 2) {
        printf("not enough args\n");
        return 1;
    }

    int fd = open(argv[1], O_RDONLY);
    if (fd == -1) {
        perror("open file fail");
        return 1;
    }

    char* localbuf = (char*)malloc(READLEN);
    int readlen = READLEN;

    for (int tnum = 0; tnum < NUMTHREADS; tnum++) threads.emplace_back();

    for (int tnum = 0; tnum < NUMTHREADS; tnum++) {
        eq.enQ(make_shared<UploadBuffer>(CHUCKSIZE));
    }

    for (int tnum = 0; tnum < NUMTHREADS; tnum++) {
        pthread_create(&threads[tnum], NULL, worker, NULL);
    }

    eq.deQ(curdata);
    // assert (curdata->index == 0)
    int count = 1;
    curdata->index = count++;

    int tmplen;

    while (1) {
        // read data from file
        readlen = read(fd, localbuf, READLEN);
        if (readlen == -1) {
            perror("read fail");
            break;
        } else if (readlen == 0) {  // EOF
            // cout<<"end of file\n";
            if (curdata->index > 0) fq.enQ(curdata);
            break;
        }

        //
        while (1) {
            tmplen = curdata->data.append(localbuf, readlen);
            if (tmplen < readlen) {  // change to next queue, enqueue
                fq.enQ(curdata);
                eq.deQ(curdata);
                curdata->index = count++;

                // assert (curdata->index == 0)
                readlen -= tmplen;
            } else {
                break;  // contineu to read
            }
        }
    }

    printf("Start teardown\n");

    // terminate thread
    for (int tnum = 0; tnum < NUMTHREADS; tnum++) {
        eq.deQ(curdata);
        curdata->index = -1;
        fq.enQ(curdata);
    }
    curdata.reset();
    for (int tnum = 0; tnum < NUMTHREADS; tnum++) {
        pthread_join(threads[tnum], NULL);
    }

    free(localbuf);
    close(fd);
    return 0;
}

int comm_request_cs( unsigned int group ) {
  int error = 0;

  // Check to see if the reply is for a group that exists if not skip
  group_map_t::iterator group_it = comm_groups.find( group );
  if ( group_it == comm_groups.end() ) {
  cout << "comm_request_cs Cannot request critical section for group " << group << endl;
    error = -1;
    return error;
  }
  
  // Request critical section for specified group. Record stats for waiting time
  cs_entry_t req;
  req.seq_num = 0;
  req.wait_time = 0;
  req.msg_count = 0;
  CStopWatch timer;
  msg_t      outgoing;
  outgoing.send_ID  = NODE_INFO.id;
  outgoing.dest_ID  = 0;
  outgoing.ts       = comm_seq_num.num;
  outgoing.group_ID = group;
  outgoing.msg_type = MSG_T_REQUEST_CS;
  
  timer.startTimer();
  
  // Lock cs entries so they don't change while reading
  // comm_seq_num.mutex.lock();
  // group_it->second.cs.mutex.lock();
  SHARED_VARS.lock();
  
  group_it->second.cs.requesting = true;
  
  // Update and record sequence numbers
  comm_seq_num.num = comm_seq_num.max_num + 1;
  outgoing.ts = comm_seq_num.num;
  req.seq_num = comm_seq_num.num;  
  
  for ( map<unsigned int, critical_section_t>::iterator it = group_it->second.cs.cs_map.begin();
        it != group_it->second.cs.cs_map.end();
        it++ ) {
    if ( !(it->second.mutex_token) ) {
      req.msg_count++;
      outgoing.dest_ID = it->first;
      comm_send( outgoing );
    }
  }
  
  // Total messages exchanged is always 1 sent + 1 recv = 2*sent
  req.msg_count *= 2;
  
  // group_it->second.cs.mutex.unlock();  
  // comm_seq_num.mutex.unlock();
  SHARED_VARS.unlock();
 
  // If no requests were made, do not wait on any replies
  if ( req.msg_count > 0 ) {
    group_it->second.cs.entry_ok.wait( group_it->second.cs.entry_ok_mutex );
  }
 
  // Record wait time
  timer.stopTimer();
  req.wait_time = timer.getElapsedTime();

  cout << "cs log entry: " << "seq_num " << req.seq_num
       << " wait_time = " << req.wait_time
       << " msg_count = " << req.msg_count << endl;

  comm_cs_log.push( req );
  
  return 0;
}

int main()
{
    try
    {
        dExternalDustCurrentOffset = DUST_OFFSET_INIT_VALUE ;
        dExternalDustCurrentMinValue = DUST_MIN_INIT_VALUE ;
        bContinueExecution = true ;

        // Registriamo il segnale interrupt Software del S.O. scatenato con il CTRL+C  e l'handler da evocare a fronte del suo
        // "lancio" da parte del S.O. stesso
        signal( SIGINT , Signal_Callback_Handler ) ;

        // Crea il thread che "consuma" i valori rilevati dai sensori
        thread threadConsumatore( ( CConsumaValoriSensori() ) ) ;
        // Detach perche' la sua esecuzione puo' viaggiare indipendente e noi non dobbiamo conoscerne lo stato
        threadConsumatore.detach() ;

        // Crea il thread per la lettura del sensore I2C interno
        // async per poterne facilmente attendere la chiusura prima del return del main, se si esce con CTRL+C
        future<void> threadI2C = async( launch::async , CReadI2C() ) ;

        // Crea il thread che "tara" i valori rilevati dal sensore delle polveri
        thread threadTaraPolveri( ( CTaratoreValoriPolveri() ) ) ;
        // Detach perche' la sua esecuzione puo' viaggiare indipendente e noi non dobbiamo conoscerne lo stato
        threadTaraPolveri.detach() ;

        CUsbUtils usbUtils ;
        unsigned char pReadBuffer[6] = { 0 , 0 , 0 , 0 , 0 , 0 } ;

        uint16_t nsReadCounter = 0 ;
        /*
        * Misuriamo le polveri ogni 10 ms e temperatura ed umidita' ogni 1000 ms
        */
        while ( bContinueExecution )
        {
            try
            {
                nsReadCounter++ ;

                int nReadedBytes = 0 ;

                if ( usbUtils.Read( pReadBuffer , 6 , &nReadedBytes ) )
                {
                    // Elaborazione della lettura delle polveri
                    uint16_t nsDust = ( pReadBuffer[0] << 8 ) + pReadBuffer[1] ;

                    externalDustMeasurements.push( CUtils::FormatDustValue( nsDust ) ) ;

                    // Se abbiamo raggiunto il valore HUMIDITY_AND_TEMPERATURE_PERIOD_COUNTER del contatore, significa che siamo pronti per
                    // processare anche temperatura ed umidita', oltre alla polvere
		    if ( nsReadCounter == HUMIDITY_AND_TEMPERATURE_PERIOD_COUNTER )
                    {
                        // Elaborazione della lettura della temperatura e dell'umidita' (esterne)
                        uint16_t nsHumidity = ( pReadBuffer[2] << 8 ) + pReadBuffer[3] ;
                        uint16_t nsTemperature = ( pReadBuffer[4] << 8 ) + pReadBuffer[5] ;
					
                        if ( nsHumidity == HUMIDITY_AND_TEMPERATURE_ERR_CODE || nsTemperature == HUMIDITY_AND_TEMPERATURE_ERR_CODE )
                        {
                            CUtils::AddWarningMessage( "Errore nel Sensore di Temperatura e Umidita' del PIC" ) ; 
                        }
                        else 
                        {
                            double dExternalTemperatureCelsius = CUtils::FormatTemperatureValue( nsTemperature ) ;
                            double dExternalHumidityPercentage = CUtils::FormatHumidityValue( nsHumidity ) ;
                            //cout << "Temperatura: " << dExternalTemperatureCelsius ;
                            //cout << " Umidita': " << dExternalHumidityPercentage << endl ;

                            // Aggiungo i valori di temperatura ed umidita'
                            t_HumidityAndTemperatureMeasurementData humidityAndTemperatureMeasurementData ;
                            humidityAndTemperatureMeasurementData.m_dHumidityPercentage = dExternalHumidityPercentage ;
                            humidityAndTemperatureMeasurementData.m_dTemperatureCelsius = dExternalTemperatureCelsius ;
                            externalHumidityAndTemperatureMeasurements.push( humidityAndTemperatureMeasurementData ) ;
                        }

                        nsReadCounter = 0 ;
                    }
                }
                else
                {
                    CUtils::AddWarningMessage( string( "main - usbUtils.Read fallita. VID Device: " ) + to_string( PIC_VID ) + string( " PID Device: " ) + to_string( PIC_PID ) ) ;
                }

                std::chrono::milliseconds sleep_duration( DUST_MEASUREMENT_PERIOD_MS ) ;
                std::this_thread::sleep_for( sleep_duration ) ;
            }
            catch( const exception& e )
            {
                CUtils::AddWarningMessage( "main - Eccezione durante la lettura dei dati dai sensori. Testo: " + string( e.what() ) ) ;
            }
        }

        threadI2C.wait() ;
    }
    catch( const exception& e )
    {
        CUtils::AddWarningMessage( "main - Eccezione generica. Testo: " + string( e.what() ) ) ;
    }

    return 0 ;
}

int main(int argc, char **argv)
{
	/*
	cv::Mat foo(50,1, CV_32FC3);
	cv::Mat bar(3,1, CV_32FC1);

	cv::Mat baz = bar.t() * foo.reshape(1).t();
	cout << baz.size() << endl;

	return 0;
	//*/

	parse_args(argc, argv);

	if (videofile.empty())
	{
		std::cout << "no input file given" << std::endl;
		return 0;
	}

	auto vid = new cv::VideoCapture(videofile);

	if (!vid->isOpened())
	{
		std::cerr << "vid could not be opened!" << std::endl;
		delete vid;
		exit(1);
	}

	// build file names
	char buf[1000];
	std::string basename = splitext(videofile);
	sprintf_s(buf, "%s-foreground-r%d%s-b%dx%d-a%g-d%g-s%g-mst%g", 
		basename.c_str(),
		reduction, (blendframes ? "b" : ""),
		blur.x, blur.y,
		alpha_avg,
		alpha_dev,
		sigma_dev,
		masksum_threshold
	);
	std::string outbase(buf);
	if (suffix.length() > 0) outbase += "-" + suffix;

	std::cout << "outbase: " << outbase << std::endl;

	std::string inmaskname(basename + "-inmask.bmp");
	cv::Mat inmask = cv::imread(inmaskname, cv::IMREAD_GRAYSCALE);
	bool const use_inmask = (inmask.data != NULL);
	if (use_inmask)
	{
		std::cout << "using inmask " << inmaskname << std::endl;
		//cv::imshow("inmask", inmask);
	}

	std::string outaudio(outbase + "-audio.raw"); // raw pcm_s16le
	//std::string outmask    (outbase + "-mask.avi");
	std::string outdiff    (outbase + "-maskdiff.avi");

	vid_fps = vid->get(CV_CAP_PROP_FPS);
	width = (int)vid->get(CV_CAP_PROP_FRAME_WIDTH);
	height = (int)vid->get(CV_CAP_PROP_FRAME_HEIGHT);
	nframes = (int)vid->get(CV_CAP_PROP_FRAME_COUNT);

	if (override_fps)
	{
		cout << "fps " << vid_fps << " uncorrected" << endl;
		cout << "nframes " << nframes << " uncorrected" << endl;

		// compensate
		nframes = nframes / vid_fps * override_fps;

		vid_fps = override_fps;
	}
	
	cout << "fps " << vid_fps << endl;
	cout << "nframes " << nframes << endl;

	assert(fmod((double)audiorate, vid_fps) < 1.0);

	cv::Mat frameu8(height, width, CV_8UC3, cv::Scalar::all(0.0f));
	cv::Mat frame(height, width, CV_32FC3, cv::Scalar::all(0.0f));
	cv::Mat gray(height, width, CV_32F, cv::Scalar::all(0.0f));
	cv::Mat average(height, width, CV_32F, cv::Scalar::all(0.0f));
	cv::Mat deviation(height, width, CV_32F, cv::Scalar::all(0.0f));

	ValuePlot plot_avg("plot avg", 640, 360, 0, 640, 0, 1, 0.2);
	
	ValuePlot plot_diff("plot diff", 640, 360, 0, 640, -0.03, 0.03, 1/256.);

	ValuePlot plot_absdiff("plot absdiff", 640, 360, 0, 640, -4, 0, 1);
	plot_absdiff.use_vmap = true;
	plot_absdiff.vmap = [](float v) { return log10(v); };
	
	ValuePlot plot_dev("plot dev", 640, 360, 0, 640, -4, 0);
	plot_dev.use_vmap = true;
	plot_dev.vmap = [](float v) { return log10(v); };

	cv::Mat diff(height, width, CV_32F, cv::Scalar::all(0.0f));
	cv::Mat absdiff(height, width, CV_32F, cv::Scalar::all(0.0f));
//.........这里部分代码省略.........

void readfn(cv::VideoCapture *vid)
{
	int frameno = (int)vid->get(CV_CAP_PROP_POS_FRAMES);
	int const width = (int)vid->get(CV_CAP_PROP_FRAME_WIDTH);
	int const height = (int)vid->get(CV_CAP_PROP_FRAME_HEIGHT);

	cv::Mat blendedframe, curframe;
	cv::Mat floatframe;
	cv::Mat grayframe;

	blendedframe.create(cv::Size(width, height), CV_16UC3);

	while (running)
	{
		if (!vid->grab())
			break;

		bool do_process = true;

		if (blendframes)
		{
			vid->retrieve(curframe);
			//curframe.convertTo(curframe, CV_16UC3);

			/*
			std::ostringstream label;
			label << "Frame " << frameno;
			cv::putText(curframe, label.str(), cv::Point(10, 20 * (frameno % 50)), cv::FONT_HERSHEY_PLAIN, 2, cv::Scalar::all(255), 2);
			//*/

			//std::cerr << "%reduction = " << (frameno % reduction) << std::endl;

			if (frameno % reduction == 0)
				blendedframe.setTo(0);

			//blendedframe = cv::max(blendedframe, curframe);
			cv::add(blendedframe, curframe, blendedframe, cv::noArray(), CV_16UC3);

			if (frameno % reduction == reduction - 1)
				blendedframe.convertTo(floatframe, CV_32FC3, 1.0 / (reduction * 255));
			else
				do_process = false;



			/*
			cv::Mat foo;
			cv::resize(blendedframe, foo, cv::Size(640, 360));
			cv::imshow("debug", foo);
			if (cv::waitKey(100) != -1) exit(0);
			//*/

			//std::cerr << "do_process = " << (do_process) << std::endl;

		}
		else
		{
			if (frameno % reduction == reduction - 1)
			{
				vid->retrieve(curframe);
				curframe.convertTo(floatframe, CV_32FC3, 1.0 / 255);
			}
			else
			{
				do_process = false;
			}

		}

		frameno += 1;

		if (!do_process)
			continue;

		// TODO: proper bounded queue...
		while (running)
		{
			bool foo;
			bool res = donequeue.try_pop(foo);
			if (res)
				break;
		}

		// frameu8 is ready
		cv::cvtColor(floatframe, grayframe, CV_BGR2GRAY, 1);
		cv::blur(grayframe, grayframe, blur);

		MatOrNothing const tmp = { true, floatframe.clone(), grayframe.clone(), frameno };
		framequeue.push(tmp);
		//std::cout << "pushing frame " << frameno << std::endl;
	}

	MatOrNothing const tmp = { false };
	framequeue.push(tmp);
}