Ejemplo n.º 1
0
bool cSoppalusikkaLogoCache::LoadXpm(const char *fileNameP)
{
  struct stat stbuf;
  cBitmap *bmp = new cBitmap(1, 1, 1);

  // create absolute filename
  cString filename = cString::sprintf("%s/%s.xpm", SoppalusikkaConfig.GetLogoDir(), fileNameP);
  debug1("%s (%s)", __PRETTY_FUNCTION__, *filename);
  // check validity
  if ((stat(*filename, &stbuf) == 0) && bmp->LoadXpm(*filename)) {
     // assign bitmap
     debug2("%s Logo found", __PRETTY_FUNCTION__);
     if (!DoubleEqual(1.0, xFactorM) || !DoubleEqual(1.0, yFactorM) || (bmp->Width() != DEFAULT_LOGO_WIDTH) || (bmp->Height() != DEFAULT_LOGO_HEIGHT)) {
        cBitmap *tmp = bmp;
        // scale bitmap keeping default proportions
        bmp = bmp->Scaled(yFactorM * DEFAULT_LOGO_WIDTH / bmp->Width(), yFactorM * DEFAULT_LOGO_HEIGHT / bmp->Height(), bmp->Bpp() > 4);
        debug2("%s Logo scaled", __PRETTY_FUNCTION__);
        DELETENULL(tmp);
        }
     bitmapM = bmp;
     return true;
     }
  // no valid xpm logo found - delete bitmap
  debug2("%s Logo not found or invalid resolution", __PRETTY_FUNCTION__);
  DELETENULL(bmp);
  bitmapM = NULL;
  return false;
}
Ejemplo n.º 2
0
void cDvbSubtitleBitmaps::Draw(cOsd *Osd)
{
  bool Scale = !(DoubleEqual(osdFactorX, 1.0) && DoubleEqual(osdFactorY, 1.0));
  bool AntiAlias = true;
  if (Scale && osdFactorX > 1.0 || osdFactorY > 1.0) {
     // Upscaling requires 8bpp:
     int Bpp[MAXOSDAREAS];
     for (int i = 0; i < numAreas; i++) {
         Bpp[i] = areas[i].bpp;
         areas[i].bpp = 8;
         }
     if (Osd->CanHandleAreas(areas, numAreas) != oeOk) {
        for (int i = 0; i < numAreas; i++)
            Bpp[i] = areas[i].bpp = Bpp[i];
        AntiAlias = false;
        }
     }
  if (Osd->SetAreas(areas, numAreas) == oeOk) {
     for (int i = 0; i < bitmaps.Size(); i++) {
         cBitmap *b = bitmaps[i];
         if (Scale)
            b = b->Scaled(osdFactorX, osdFactorY, AntiAlias);
         Osd->DrawBitmap(int(round(b->X0() * osdFactorX)), int(round(b->Y0() * osdFactorY)), *b);
         if (b != bitmaps[i])
            delete b;
         }
     Osd->Flush();
     }
}
Ejemplo n.º 3
0
void cFemonSymbolCache::Refresh()
{
  int width, height;
  double aspect, xfactor, yfactor;
  cDevice::PrimaryDevice()->GetOsdSize(width, height, aspect);
  debug1("%s width=%d height=%d", __PRETTY_FUNCTION__, width, height);
  xfactor = (double)width / DEFAULT_WIDTH;
  yfactor = (double)height / DEFAULT_HEIGHT;
  if (!DoubleEqual(xfactor, xFactorM) || !DoubleEqual(yfactor, yFactorM)) {
     xFactorM = xfactor;
     yFactorM = yfactor;
     Populate();
     }
}
Ejemplo n.º 4
0
bool COARpeak::Equal(
  const IOARpeak &x1, const IOARpeak &x2,
  bool bCheckAllele, bool bCheckArtifact)
{
  bool bRtn = true;
  if(bCheckArtifact)
  {
    bool bArtifact = x1.IsArtifact();
    if(bArtifact != x2.IsArtifact())
    {
      bRtn = false;
    }
    else if(bArtifact)
    {
      int n1 = x1.GetCriticalLevel();
      int n2 = x2.GetCriticalLevel();
      bRtn = (n1 == n2) &&
        (x1.IsEditable() == x2.IsEditable());
    }
  }
  if(!bRtn) {;}
  else if(x1.GetID() != x2.GetID())
  { bRtn = false; }
  else if(x1.GetAlleleCount() != x2.GetAlleleCount())
  { bRtn = false; }
  else if(!DoubleEqual(x1.GetBPS(),x2.GetBPS()))
  { bRtn = false; }
  else if(!DoubleEqual(x1.GetMeanBPS(),x2.GetMeanBPS()))
  { bRtn = false; }
  else if(!DoubleEqual(x1.GetRFU(),x2.GetRFU()))
  { bRtn = false; }
  else if(!DoubleEqual(x1.GetPullupHeightCorrection(),x2.GetPullupHeightCorrection()))
  { bRtn = false; }
  else if(!DoubleEqual(x1.GetTime(),x2.GetTime()))
  { bRtn = false; }
  else if(!DoubleEqual(x1.GetPeakArea(),x2.GetPeakArea()))
  { bRtn = false; }
  else if(!DoubleEqual(x1.GetWidth(),x2.GetWidth()))
  { bRtn = false; }
  else if(!DoubleEqual(x1.GetFit(),x2.GetFit(),FIT_DIGIT_MATCH))
  { bRtn = false; }
//  else if( bCheckArtifact && (x1.IsArtifact() != x2.IsArtifact()) )
//  { bRtn = false; }
  else if( bCheckAllele && (x1.IsAllele() != x2.IsAllele()) )
  { bRtn = false; }
  else if(x1.IsDisabled() != x2.IsDisabled())
  { bRtn = false; }
  else if(x1.GetOffLadderString() != x2.GetOffLadderString())
  { bRtn = false; }
  else if(x1.GetAlleleName() != x2.GetAlleleName())
  { bRtn = false; }
  else if(x1.GetLocusName() != x2.GetLocusName())
  { bRtn = false; }
  else if(bCheckArtifact && (x1.GetArtifactLabel() != x2.GetArtifactLabel()))
  { bRtn = false; }
  else if(bCheckArtifact && (x1.GetArtifactUserDisplay() != x2.GetArtifactUserDisplay()))
  { bRtn = false; }

  return bRtn;
}
Ejemplo n.º 5
0
void cRecorder::Action(void)
{
  cTimeMs t(MAXBROKENTIMEOUT);
  bool InfoWritten = false;
  bool FirstIframeSeen = false;
  while (Running()) {
        int r;
        uchar *b = ringBuffer->Get(r);
        if (b) {
           int Count = frameDetector->Analyze(b, r);
           if (Count) {
              if (!Running() && frameDetector->IndependentFrame()) // finish the recording before the next independent frame
                 break;
              if (frameDetector->Synced()) {
                 if (!InfoWritten) {
                    cRecordingInfo RecordingInfo(recordingName);
                    if (RecordingInfo.Read()) {
                       if (frameDetector->FramesPerSecond() > 0 && DoubleEqual(RecordingInfo.FramesPerSecond(), DEFAULTFRAMESPERSECOND) && !DoubleEqual(RecordingInfo.FramesPerSecond(), frameDetector->FramesPerSecond())) {
                          RecordingInfo.SetFramesPerSecond(frameDetector->FramesPerSecond());
                          RecordingInfo.Write();
                          Recordings.UpdateByName(recordingName);
                          }
                       }
                    InfoWritten = true;
                    cRecordingUserCommand::InvokeCommand(RUC_STARTRECORDING, recordingName);
                    }
                 if (FirstIframeSeen || frameDetector->IndependentFrame()) {
                    FirstIframeSeen = true; // start recording with the first I-frame
                    if (!NextFile())
                       break;
                    if (index && frameDetector->NewFrame())
                       index->Write(frameDetector->IndependentFrame(), fileName->Number(), fileSize);
                    if (frameDetector->IndependentFrame()) {
                       recordFile->Write(patPmtGenerator.GetPat(), TS_SIZE);
                       fileSize += TS_SIZE;
                       int Index = 0;
                       while (uchar *pmt = patPmtGenerator.GetPmt(Index)) {
                             recordFile->Write(pmt, TS_SIZE);
                             fileSize += TS_SIZE;
                             }
                       }
                    if (recordFile->Write(b, Count) < 0) {
                       LOG_ERROR_STR(fileName->Name());
                       break;
                       }
                    fileSize += Count;
                    t.Set(MAXBROKENTIMEOUT);
                    }
                 }
              ringBuffer->Del(Count);
              }
           }
        if (t.TimedOut()) {
           esyslog("ERROR: video data stream broken");
           ShutdownHandler.RequestEmergencyExit();
           t.Set(MAXBROKENTIMEOUT);
           }
        }
}
Ejemplo n.º 6
0
TEST(LINE, GetLength) {
  for (int i = -20; i != 20; ++i) {
    for (int j = -20; j != 20; ++j) {
    Shape2D* line = new Line2D(Point2D(i, j));
    for (int k = 0; k <= line->GetLength(); ++k) {
      Point2D temp(0.0, 0.0);
      line->GetPoint(k, temp);
      if (i == 0 && j == 0)
        continue;
      ASSERT_TRUE(DoubleEqual(temp.x, i * k / line->GetLength()));
      ASSERT_TRUE(DoubleEqual(temp.y, j * k / line->GetLength()));
    }
    ASSERT_TRUE(DoubleEqual(line->GetLength(), sqrt(i * i + j * j)));   
    delete line;
    }
  }
}
Ejemplo n.º 7
0
void PrintDoubleChange(const char* desc, double oldVal, double newVal)
{
	if(!(DoubleEqual(oldVal, newVal)))
	{
		logger.Info(boost::str(boost::format("%s has been changed : %.2f => %.2f")
		% desc % oldVal %newVal));
	}
}
Ejemplo n.º 8
0
trade::PosiDirectionType CScalperStrategy2::GetTradeDirection()
{
	double askDiff = fabs(m_Ask - m_prevAsk);
	double bidDiff = fabs(m_Bid - m_prevBid);

	double absDiffDiff = fabs(askDiff - bidDiff);

	if(m_Ask > m_prevAsk && m_Bid > m_prevBid)
	{
		return trade::LONG;
	}
	else if(m_Ask < m_prevAsk && m_Bid < m_prevBid)
	{
		return trade::SHORT;
	}
	else if(DoubleEqual(m_Bid, m_prevBid) && DoubleEqual(m_Ask, m_prevAsk))
	{
		return CalcTradeDirection(m_AskSize, m_BidSize, askDiff, bidDiff, m_CaseNoChange);
	}
	else if(DoubleLessEqual(absDiffDiff, m_priceTick * 2))
	{
		return CalcTradeDirection(m_AskSize, m_BidSize, askDiff, bidDiff, m_CaseLE2Tick);
	}
	else if(DoubleLessEqual(absDiffDiff, m_priceTick * 3))
	{
		return CalcTradeDirection(m_AskSize, m_BidSize, askDiff, bidDiff, m_CaseLE3Tick);
	}
	else if(DoubleGreaterEqual(absDiffDiff, m_priceTick * 4))
	{
		return CalcTradeDirection(m_AskSize, m_BidSize, askDiff, bidDiff, m_CaseGE4Tick);
	}
	else
	{
		return m_AskSize < m_BidSize ? trade::SHORT : trade::LONG;
	}
}
Ejemplo n.º 9
0
BOOL PrivateAssertDouble(double fExpected, double fActual, int iDecimals, int iLine, char* szFile)
{
	char	szExpected[32];
	char	szActual[32];
	double	fTolerance;

	fTolerance = DoubleToleranceForDecimals(iDecimals);
	if (!DoubleEqual(fExpected, fActual, fTolerance))
	{
		ToDoubleString(fExpected, szExpected, iDecimals);
		ToDoubleString(fActual, szActual, iDecimals);
		return Fail(szExpected, szActual, iLine, szFile);
	}
	else
	{
		return Pass();
	}
}
Ejemplo n.º 10
0
double AngleFromStartByClockInCircle(double start_x,
                                     double start_y,
                                     double center_x,
                                     double center_y,
                                     double angle_x,
                                     double angle_y) {
  double a = center_x;
  double b = center_y;
  double r_square = pow(center_y - start_y, 2) + pow(center_x - start_x, 2); 
  double select_angle = 0;
  if (DoubleEqual(angle_x, center_x)) {
    double y1 = b + sqrt(a * a + r_square);
    double y2 = b - sqrt(a * a + r_square);
    if (fabs(y1 - angle_y) > fabs(y2 - angle_y)) y1 = y2;
    if (y1 - center_y > 0)
      select_angle = T_PI / 2.0;
    else
      select_angle = 3.0 * T_PI / 2.0;
  } else {
    double c = angle_y - ((angle_y - center_y) 
        / (angle_x - center_x)) * angle_x;
    double k = (angle_y - center_y) / (angle_x - center_x);
    double l = 1 + k * k;
    double m = 2 * (c * k - a - b * k);
    double n = a * a + (c - b) * (c - b) - r_square;
    double x1 = (-m + sqrt(m * m - 4 * n * l)) / 2 / l;
    double y1 = k * x1 + c;
    double x2 = (-m - sqrt(m * m - 4 * n * l)) / 2 / l;
    double y2 = k * x2 + c;
    if (fabs(angle_x - x1) > fabs(angle_x - x2)) {
      x1 = x2;
      y1 = y2;
    }
    select_angle = AngleInCircle(x1 - center_x, y1 - center_y);
  }
  double start_angle = AngleInCircle(start_x - center_x, start_y - center_y);
  double delta_angle = start_angle - select_angle;
  if (delta_angle < 0) delta_angle += 2 * T_PI;
  assert(delta_angle >= 0.0 && delta_angle <= 2 * T_PI);
  return delta_angle;
}
Ejemplo n.º 11
0
double AngleInCircle(double x, double y) {
  assert(!(DoubleEqual(x, 0.0) && DoubleEqual(y, 0.0)));
  if (DoubleEqual(x, 0.0) && y > 0.0)
    return T_PI / 2;
  if (DoubleEqual(x, 0.0) && y < 0.0)
    return 3 * T_PI / 2;
  if (DoubleEqual(y, 0.0) && x > 0.0)
    return 0.0;
  if (DoubleEqual(y, 0.0 ) && x < 0.0)
    return T_PI;
  if ( x > 0.0 && y > 0.0 )
    return atan(y / x);
  if (x < 0.0 && y > 0.0)
    return T_PI + atan(y / x);
  if (x < 0.0 && y < 0.0 )
    return T_PI + atan(y / x);
  if(x > 0.0 && y < 0.0 )
    return 2 * T_PI + atan(y / x);
  return 0.0;
}
Ejemplo n.º 12
0
bool cFemonSymbolCache::Populate(void)
{
  debug1("%s xFactor=%.02f yFactor=%.02f", __PRETTY_FUNCTION__, xFactorM, yFactorM);
  if (!DoubleEqual(0.0, xFactorM) || !DoubleEqual(0.0, yFactorM)) {
     Flush();

     // pushing order must follow the enumeration - keep original proportions except for frontend status ones
     cacheM.Append(bmOnePixel.Scaled(yFactorM, yFactorM, antiAliasM));        // SYMBOL_ONEPIXEL
     cacheM.Append(bmStereo.Scaled(yFactorM, yFactorM, antiAliasM));          // SYMBOL_STEREO
     cacheM.Append(bmMonoLeft.Scaled(yFactorM, yFactorM, antiAliasM));        // SYMBOL_MONO_LEFT
     cacheM.Append(bmMonoRight.Scaled(yFactorM, yFactorM, antiAliasM));       // SYMBOL_MONO_RIGHT
     cacheM.Append(bmDolbyDigital.Scaled(yFactorM, yFactorM, antiAliasM));    // SYMBOL_DD
     cacheM.Append(bmDolbyDigital20.Scaled(yFactorM, yFactorM, antiAliasM));  // SYMBOL_DD20
     cacheM.Append(bmDolbyDigital51.Scaled(yFactorM, yFactorM, antiAliasM));  // SYMBOL_DD51
     cacheM.Append(bmMpeg2.Scaled(yFactorM, yFactorM, antiAliasM));           // SYMBOL_MPEG2
     cacheM.Append(bmH264.Scaled(yFactorM, yFactorM, antiAliasM));            // SYMBOL_H264
     cacheM.Append(bmH265.Scaled(yFactorM, yFactorM, antiAliasM));            // SYMBOL_H265
     cacheM.Append(bmPal.Scaled(yFactorM, yFactorM, antiAliasM));             // SYMBOL_PAL
     cacheM.Append(bmNtsc.Scaled(yFactorM, yFactorM, antiAliasM));            // SYMBOL_NTSC
     cacheM.Append(bmEncrypted.Scaled(yFactorM, yFactorM, antiAliasM));       // SYMBOL_ENCRYPTED
     cacheM.Append(bmSvdrp.Scaled(yFactorM, yFactorM, antiAliasM));           // SYMBOL_SVDRP
     cacheM.Append(bmLock.Scaled(xFactorM, yFactorM, antiAliasM));            // SYMBOL_LOCK
     cacheM.Append(bmSignal.Scaled(xFactorM, yFactorM, antiAliasM));          // SYMBOL_SIGNAL
     cacheM.Append(bmCarrier.Scaled(xFactorM, yFactorM, antiAliasM));         // SYMBOL_CARRIER
     cacheM.Append(bmViterbi.Scaled(xFactorM, yFactorM, antiAliasM));         // SYMBOL_VITERBI
     cacheM.Append(bmSync.Scaled(xFactorM, yFactorM, antiAliasM));            // SYMBOL_SYNC
     cacheM.Append(bmAspectRatio11.Scaled(yFactorM, yFactorM, antiAliasM));   // SYMBOL_AR_1_1
     cacheM.Append(bmAspectRatio169.Scaled(yFactorM, yFactorM, antiAliasM));  // SYMBOL_AR_16_9
     cacheM.Append(bmAspectRatio2211.Scaled(yFactorM, yFactorM, antiAliasM)); // SYMBOL_AR_2_21_1
     cacheM.Append(bmAspectRatio43.Scaled(yFactorM, yFactorM, antiAliasM));   // SYMBOL_AR_4_3
     cacheM.Append(bmDevice.Scaled(yFactorM, yFactorM, antiAliasM));          // SYMBOL_DEVICE
     cacheM.Append(bmZero.Scaled(yFactorM, yFactorM, antiAliasM));            // SYMBOL_ZERO
     cacheM.Append(bmOne.Scaled(yFactorM, yFactorM, antiAliasM));             // SYMBOL_ONE
     cacheM.Append(bmTwo.Scaled(yFactorM, yFactorM, antiAliasM));             // SYMBOL_TWO
     cacheM.Append(bmThree.Scaled(yFactorM, yFactorM, antiAliasM));           // SYMBOL_THREE
     cacheM.Append(bmFour.Scaled(yFactorM, yFactorM, antiAliasM));            // SYMBOL_FOUR
     cacheM.Append(bmFive.Scaled(yFactorM, yFactorM, antiAliasM));            // SYMBOL_FIVE
     cacheM.Append(bmSix.Scaled(yFactorM, yFactorM, antiAliasM));             // SYMBOL_SIX
     cacheM.Append(bmSeven.Scaled(yFactorM, yFactorM, antiAliasM));           // SYMBOL_SEVEN
     cacheM.Append(bmEight.Scaled(yFactorM, yFactorM, antiAliasM));           // SYMBOL_EIGHT
     cacheM.Append(bmFormat2160.Scaled(yFactorM, yFactorM, antiAliasM));      // SYMBOL_FORMAT_2160
     cacheM.Append(bmFormat2160i.Scaled(yFactorM, yFactorM, antiAliasM));     // SYMBOL_FORMAT_2160i
     cacheM.Append(bmFormat2160p.Scaled(yFactorM, yFactorM, antiAliasM));     // SYMBOL_FORMAT_2160p
     cacheM.Append(bmFormat1080.Scaled(yFactorM, yFactorM, antiAliasM));      // SYMBOL_FORMAT_1080
     cacheM.Append(bmFormat1080i.Scaled(yFactorM, yFactorM, antiAliasM));     // SYMBOL_FORMAT_1080i
     cacheM.Append(bmFormat1080p.Scaled(yFactorM, yFactorM, antiAliasM));     // SYMBOL_FORMAT_1080p
     cacheM.Append(bmFormat720.Scaled(yFactorM, yFactorM, antiAliasM));       // SYMBOL_FORMAT_720
     cacheM.Append(bmFormat720i.Scaled(yFactorM, yFactorM, antiAliasM));      // SYMBOL_FORMAT_720i
     cacheM.Append(bmFormat720p.Scaled(yFactorM, yFactorM, antiAliasM));      // SYMBOL_FORMAT_720p
     cacheM.Append(bmFormat576.Scaled(yFactorM, yFactorM, antiAliasM));       // SYMBOL_FORMAT_576
     cacheM.Append(bmFormat576i.Scaled(yFactorM, yFactorM, antiAliasM));      // SYMBOL_FORMAT_576i
     cacheM.Append(bmFormat576p.Scaled(yFactorM, yFactorM, antiAliasM));      // SYMBOL_FORMAT_576p
     cacheM.Append(bmFormat480.Scaled(yFactorM, yFactorM, antiAliasM));       // SYMBOL_FORMAT_480
     cacheM.Append(bmFormat480i.Scaled(yFactorM, yFactorM, antiAliasM));      // SYMBOL_FORMAT_480i
     cacheM.Append(bmFormat480p.Scaled(yFactorM, yFactorM, antiAliasM));      // SYMBOL_FORMAT_480p

     return true;
     }

  return false;
}
Ejemplo n.º 13
0
// Analytical solution to quadratic polynomials exists. This function could return the optimal solution to quadratic polynomials with one or two variables.
// Return value: indicator variable for solution status, NOOPT
int PolyNomial::Optimize2(Array<double>* vars, double* optValue)
{
	vars->clear();
	if (1 == numVar_)  // There is only 1 variable in the polynomial.
	{
		double a = 0, b = 0;  // Get parameters for the Gaussian representation.
		for(int i = 0; i < items_.size(); ++i) {
			map<int, double>::const_iterator citer = items_[i].begin();
			if (DoubleEqual(citer->second, 2.0, DOUBLE_ZERO_THRESHOLD)) {
				a = coef_[i];
			}

			if (DoubleEqual(citer->second, 1.0, DOUBLE_ZERO_THRESHOLD)) {
				b = coef_[i];
			}
		}

		// ERROR: The quadratic term is empty.
		if (fabs(a) < DOUBLE_ZERO_THRESHOLD) {
			cout << "The quadratic term is empty" << endl;
			exit(0);
		}

		vars->append(-b/(2*a));
		*optValue = ComputePlValue(*vars);
		return 0;
	}

	// Two-var quadratic polynomial representation: a*x1^2 + b*x2^2 + c*x1*x2 + d*x1 + e*x2.
	double a = 0, b = 0, c = 0, d = 0, e = 0;
	//normalize and assume each polynomial are 2-var poly.
	for(int i = 0; i < items_.size(); ++i) {
		map<int, double>::const_iterator citer = items_[i].begin();
		if (citer->first == 0 && DoubleEqual(citer->second, 2.0, DOUBLE_ZERO_THRESHOLD)) //x1^2
		{
			a = coef_[i];
		}
		if (citer->first == 1 && DoubleEqual(citer->second, 2.0, DOUBLE_ZERO_THRESHOLD)) //x2^2
		{
			b = coef_[i];
		}
		if (citer->first == 0 && DoubleEqual(citer->second, 1.0, DOUBLE_ZERO_THRESHOLD) && items_[i].size() == 2) //x1*x2
		{
			c = coef_[i];
		}
		if (citer->first == 0 && DoubleEqual(citer->second, 1.0, DOUBLE_ZERO_THRESHOLD) && items_[i].size() == 1) //x1
		{
			d = coef_[i];
		}
		if (citer->first == 1 && DoubleEqual(citer->second, 1.0, DOUBLE_ZERO_THRESHOLD) && items_[i].size() == 1)//x2
		{
			e = coef_[i];
		}
		if (citer->first == 1 && DoubleEqual(citer->second, 1.0, DOUBLE_ZERO_THRESHOLD) && items_[i].size() > 1) //wrong
		{
			cout << "shouldn't be here," << endl;
		}
	}

	vars->clear();
	double delta = 4 * a * b - c * c;
	//cout << "delta: " << delta << endl;
	// delta == 0, |a| > 0, |b| > 0
	if (fabs(delta) < DOUBLE_ZERO_THRESHOLD) {
		if (fabs(a)> DOUBLE_ZERO_THRESHOLD) {
			vars->append(-d / 2 * a);
			vars->append(0.0);
		} else if (fabs(a)> DOUBLE_ZERO_THRESHOLD) {
			vars->append(0.0);
			vars->append(-e / 2 * b);
		} else {
			// In this case, there is no appropriate optimum
			PrintTo(cout); cout << endl;
			cout << "delta = 0, no optimums2" << endl;
			exit(0);
		}
		*optValue = ComputePlValue(*vars);
		return NOOPT;
	}

	vars->append((e * c-2 * b * d)/delta);
	vars->append((d * c-2 * a * e)/delta);
	*optValue = ComputePlValue(*vars);
	return 0;
}
Ejemplo n.º 14
0
bool cRecorder::NextFile(void)
{
  if (recordFile && frameDetector->IndependentFrame()) { // every file shall start with an independent frame
#ifdef USE_HARDLINKCUTTER
     if (fileSize > fileName->MaxFileSize() || RunningLowOnDiskSpace()) {
#else
     if (fileSize > MEGABYTE(off_t(Setup.MaxVideoFileSize)) || RunningLowOnDiskSpace()) {
#endif /* HARDLINKCUTTER */
        recordFile = fileName->NextFile();
        fileSize = 0;
        }
     }
  return recordFile != NULL;
}

void cRecorder::Activate(bool On)
{
  if (On)
     Start();
  else
     Cancel(3);
}

void cRecorder::Receive(uchar *Data, int Length)
{
  if (Running()) {
     int p = ringBuffer->Put(Data, Length);
     if (p != Length && Running())
        ringBuffer->ReportOverflow(Length - p);
     }
}

void cRecorder::Action(void)
{
  time_t t = time(NULL);
  bool InfoWritten = false;
  bool FirstIframeSeen = false;
#ifdef USE_LIVEBUFFER
  double fps = DEFAULTFRAMESPERSECOND;
#endif /*USE_LIVEBUFFER*/
  while (Running()) {
        int r;
        uchar *b = ringBuffer->Get(r);
        if (b) {
           int Count = frameDetector->Analyze(b, r);
           if (Count) {
              if (!Running() && frameDetector->IndependentFrame()) // finish the recording before the next independent frame
                 break;
              if (frameDetector->Synced()) {
#ifdef USE_LIVEBUFFER
                 if(index && (frameDetector->FramesPerSecond() != fps)) {
                    fps = frameDetector->FramesPerSecond();
                    index->SetFramesPerSecond(fps);
                 } // if
#endif /*USE_LIVEBUFFER*/
                 if (!InfoWritten) {
                    cRecordingInfo RecordingInfo(recordingName);
                    if (RecordingInfo.Read()) {
                       if (frameDetector->FramesPerSecond() > 0 && DoubleEqual(RecordingInfo.FramesPerSecond(), DEFAULTFRAMESPERSECOND) && !DoubleEqual(RecordingInfo.FramesPerSecond(), frameDetector->FramesPerSecond())) {
                          RecordingInfo.SetFramesPerSecond(frameDetector->FramesPerSecond());
                          RecordingInfo.Write();
                          Recordings.UpdateByName(recordingName);
                          }
                       }
                    InfoWritten = true;
                    }
/*                 if (frameDetector->NewPayload()) { // We're at the first TS packet of a new payload...
                    if (Buffering)
                       esyslog("ERROR: encountered new payload while buffering - dropping some data!");
                    if (!frameDetector->NewFrame()) { // ...but the frame type is yet unknown, so we need to buffer packets until we see the frame type
                       if (!Buffer) {
                          dsyslog("frame type not in first packet of payload - buffering");
                          if (!(Buffer = MALLOC(uchar, BUFFERSIZE))) {
                             esyslog("ERROR: can't allocate frame type buffer");
                             break;
                             }
                          }
                       BufferIndex = 0;
                       Buffering = true;
                       }
                    }
                 else if (frameDetector->NewFrame()) // now we know the frame type, so stop buffering
                    Buffering = false;
                 if (Buffering) {
                    if (BufferIndex + Count <= BUFFERSIZE) {
                       memcpy(Buffer + BufferIndex, b, Count);
                       BufferIndex += Count;
                       }
                    else
                       esyslog("ERROR: too many bytes for frame type buffer (%d > %d) - dropped %d bytes", BufferIndex + Count, int(BUFFERSIZE), Count);
                    }
                 else if (FirstIframeSeen || frameDetector->IndependentFrame()) {
*/
#ifdef USE_LIVEBUFFER
                    if(!FirstIframeSeen) FillInitialData(b, r);
#endif /*USE_LIVEBUFFER*/
                 if (FirstIframeSeen || frameDetector->IndependentFrame()) {
                    FirstIframeSeen = true; // start recording with the first I-frame
                    if (!NextFile())
                       break;
                    if (index && frameDetector->NewFrame())
                       index->Write(frameDetector->IndependentFrame(), fileName->Number(), fileSize);
                    if (frameDetector->IndependentFrame()) {
                       recordFile->Write(patPmtGenerator.GetPat(), TS_SIZE);
                       fileSize += TS_SIZE;
                       int Index = 0;
                       while (uchar *pmt = patPmtGenerator.GetPmt(Index)) {
                             recordFile->Write(pmt, TS_SIZE);
                             fileSize += TS_SIZE;
                             }
                       }
                    if (recordFile->Write(b, Count) < 0) {
                       LOG_ERROR_STR(fileName->Name());
                       break;
                       }
                    fileSize += Count;
                    t = time(NULL);
                    }
                 }
              ringBuffer->Del(Count);
              }
           }
#ifdef USE_LIVEBUFFER
        if (handleError && (time(NULL) - t > MAXBROKENTIMEOUT)) {
#else
        if (time(NULL) - t > MAXBROKENTIMEOUT) {
#endif
#if REELVDR
           Skins.QueueMessage(mtError, tr("can't record - check your configuration"));
#else
           esyslog("ERROR: video data stream broken. Requesting Emergency Exit.");
           ShutdownHandler.RequestEmergencyExit();
#endif /*REELVDR*/
           t = time(NULL);
           }
        }
}