His Divine Shadow fucked around with this message at 08:48 on Aug 29, 2023

LimaBiker fucked around with this message at 17:04 on Aug 29, 2023

One Legged Ninja fucked around with this message at 18:17 on Aug 29, 2023

RabbitWizard fucked around with this message at 20:41 on Aug 29, 2023

ryanrs fucked around with this message at 19:20 on Aug 29, 2023

ryanrs fucked around with this message at 04:46 on Aug 30, 2023

His Divine Shadow fucked around with this message at 05:18 on Aug 30, 2023

  // First we check if prevFrameBuffer is valid. 
  // This if statement should only trigger starting the second pass
  if(prevFrameBuffer) { 

 uint8_t difference = abs(frameBuffer->buf[i] - prevFrameBuffer[i]);

// This is assuming C++11 for `auto`, `constexpr`, and `nullptr`

//-------------------------------------------
// Constants
//
// constexpr := "This is a compile time constant"
// static := "This symbol is only for this .cpp file"
//-------------------------------------------
static const constexpr int FRAME_SIZE = 96 * 96;
static const constexpr int DIFFERENCE_THRESHOLD = 128;

//-------------------------------------------
// Global data
//
// (I like to put stuff in structs to qualify 
//  names.  This is making one instance of a struct with
//  these fields that is static [only accessible from this .cpp])
//-------------------------------------------
static struct 
{
  // Previous frame we got from the camera.  
  // null if we haven't ever gotten one
  camera_fb_t* previousFrame = nullptr;

  // FRAME_SIZE long array of 0/1 values, representing whether that pixel
  // was different enough, allocated in PSRAM
  //
  // (You could also do this without a heap via the appropriate linker
  // instruction to tell it to place a plain `uint8_t differenceBuffer[FRAME_SIZE]`,
  // or better `std::array<uint8_t, FRAME_SIZE>` (if you have C++11) in PSRAM)
  //
  // But a heap allocation is fine too.
  uint8_t* differenceBuffer = nullptr;
} globals;

//-------------------------------------------
// Set everything up
//-------------------------------------------
void setup() 
{
  Serial.begin(115200);
  Serial.setDebugOutput(true);
  Serial.println();

  // Allocate space for differences in PSRAM & zero it.  The zeroing is to make it have
  // non-trash values before we have two good camera frames and write it normally
  globals.differenceBuffer = (uint8_t*)ps_malloc(FRAME_SIZE * sizeof(uint8_t));
  std::memset(globals.differenceBuffer, 0, FRAME_SIZE * sizeof(uint8_t));

  // Starting camera
  //
  // Make sure config->fb_cnt is >1 so we can have 2+ buffers outstanding
  init_camera();
}

//-------------------------------------------
// Every loop
//-------------------------------------------
void loop() 
{
  // Acquire a new frame
  camera_fb_t* newFrame = esp_camera_fb_get();
  if (newFrame == nullptr)
  {
    // esp32-camera returns nullptr when camera access times out.
    // Or if there were no more buffers left, but that shouldn't happen
    Serial.println("Camera capture failed");
    return;
  }

  // If we don't have a previous frame, there's no differences to compute.
  // This frame becomes our previous frame and we're done
  if (globals.previousFrame == nullptr)
  {
    globals.previousFrame = newFrame;
    return;
  }

  // Compute the difference
  for (auto pxNum = 0; pxNum < FRAME_SIZE; ++pxNum)
  {
    // Doing this in wider signed math probably isn't any slower than doing it 
    // with conditionals
    const auto newPx = (int)newFrame[pxNum];
    const auto oldPx = (int)globals.previousFrame[pxNum];
    const auto delta = newPx - oldPx;
    const auto absDelta = std::abs(delta);
    globals.differenceBuffer[pxNum] = (uint8_t)((absDelta > DIFFERENCE_THRESHOLD) ? 1u : 0u)
  }

  // Old frame -> return to camera
  // New frame -> old frame
  //
  // We're only shuffling pointers around, not copying array content
  esp_camera_fb_return(globals.previousFrame);
  globals.previousFrame = newFrame;

  DoSomethingWithTheDifferencesPresumably();
}

Foxfire_ fucked around with this message at 07:30 on Aug 31, 2023