diff --git a/Makefile b/Makefile
index ad7b65a..8e981eb 100644
--- a/Makefile
+++ b/Makefile
@@ -52,7 +52,7 @@
 all: $(SONAME) $(EXE)
 
 $(SONAME): $(OBJECTS)
-	$(CXX) -shared -o $@ $(SO_OBJECTS) -Wl,-h$(SONAME:$(OBJDIR)/%=%) \
+	$(CXX) -shared -o $@ $(OBJECTS) -Wl,-h$(SONAME:$(OBJDIR)/%=%) \
 		$(LINK_FLAGS)
 
 $(EXE): $(OBJECTS) $(MAINOBJ)
diff --git a/input_event_filter.cc b/input_event_filter.cc
index ce5ec52..0fd152c 100644
--- a/input_event_filter.cc
+++ b/input_event_filter.cc
@@ -4,12 +4,16 @@
 
 #include "touch_noise_filter/input_event_filter.h"
 
+#include <linux/input.h>
+#include <stdio.h>
+
 #include <base/basictypes.h>
 
 namespace touch_noise_filter {
 
 InputEventFilter::InputEventFilter(NoiseFilter* next)
-    : current_frame_(0), next_(next), current_slot_(0) {
+    : current_frame_(0), current_touching_(0), prev_touching_(0),
+      next_(next), current_slot_(0) {
   for (size_t i = 0; i < arraysize(frames_); i++) {
     for (size_t j = 0; j < arraysize(frames_[i].fingers_); j++) {
       frames_[i].fingers_[j].slot_ = j;
@@ -17,6 +21,80 @@
   }
 }
 
+namespace {
+#define SETSTR(type_num, code_num) \
+  do { \
+    if ((ev)->type == type_num) { \
+      type_str = #type_num; \
+      if ((ev)->code == code_num) { \
+        code_str = #code_num; \
+      } \
+    } \
+  } while (0)
+
+double TimevalToDouble(const struct timeval& tv) {
+  // printf("%ld usec\n", tv.tv_usec);
+  return static_cast<double>(tv.tv_sec) + static_cast<double>(tv.tv_usec) /
+    1000000.0;
+}
+
+void LogInputEvent(const struct input_event* ev) {
+  const char* type_str = "(unknown)";
+  const char* code_str = "(unknown)";
+
+  SETSTR(EV_KEY, BTN_TOUCH);
+
+  SETSTR(EV_ABS, ABS_X);
+  SETSTR(EV_ABS, ABS_Y);
+  SETSTR(EV_ABS, ABS_Z);
+  SETSTR(EV_ABS, ABS_RX);
+  SETSTR(EV_ABS, ABS_RY);
+  SETSTR(EV_ABS, ABS_RZ);
+  SETSTR(EV_ABS, ABS_THROTTLE);
+  SETSTR(EV_ABS, ABS_RUDDER);
+  SETSTR(EV_ABS, ABS_WHEEL);
+  SETSTR(EV_ABS, ABS_GAS);
+  SETSTR(EV_ABS, ABS_BRAKE);
+  SETSTR(EV_ABS, ABS_HAT0X);
+  SETSTR(EV_ABS, ABS_HAT0Y);
+  SETSTR(EV_ABS, ABS_HAT1X);
+  SETSTR(EV_ABS, ABS_HAT1Y);
+  SETSTR(EV_ABS, ABS_HAT2X);
+  SETSTR(EV_ABS, ABS_HAT2Y);
+  SETSTR(EV_ABS, ABS_HAT3X);
+  SETSTR(EV_ABS, ABS_HAT3Y);
+  SETSTR(EV_ABS, ABS_PRESSURE);
+  SETSTR(EV_ABS, ABS_DISTANCE);
+  SETSTR(EV_ABS, ABS_TILT_X);
+  SETSTR(EV_ABS, ABS_TILT_Y);
+  SETSTR(EV_ABS, ABS_TOOL_WIDTH);
+
+  SETSTR(EV_ABS, ABS_MT_SLOT);
+  SETSTR(EV_ABS, ABS_MT_TOUCH_MAJOR);
+  SETSTR(EV_ABS, ABS_MT_TOUCH_MINOR);
+  SETSTR(EV_ABS, ABS_MT_WIDTH_MAJOR);
+  SETSTR(EV_ABS, ABS_MT_WIDTH_MINOR);
+  SETSTR(EV_ABS, ABS_MT_ORIENTATION);
+  SETSTR(EV_ABS, ABS_MT_POSITION_X);
+  SETSTR(EV_ABS, ABS_MT_POSITION_Y);
+  SETSTR(EV_ABS, ABS_MT_TOOL_TYPE);
+  SETSTR(EV_ABS, ABS_MT_BLOB_ID);
+  SETSTR(EV_ABS, ABS_MT_TRACKING_ID);
+  SETSTR(EV_ABS, ABS_MT_PRESSURE);
+  SETSTR(EV_ABS, ABS_MT_DISTANCE);
+
+  if (ev->type == 0 && ev->code == 0) {
+    TouchNoiseFilterLog("INPUT: %f ---------- SYN_REPORT ----------\n",
+           TimevalToDouble(ev->time));
+  } else {
+    TouchNoiseFilterLog("INPUT: %f %s %s %d\n",
+           TimevalToDouble(ev->time), type_str, code_str, ev->value);
+  }
+}
+
+#undef SETSTR
+}  // namespace {}
+
 void InputEventFilter::HandleInputEvent(const struct input_event* ev) {
   static const __u16 kMinKey = ABS_MT_TOUCH_MAJOR;
   
@@ -42,6 +120,12 @@
         case ABS_MT_SLOT:
           current_slot_ = ev->value;
           break;
+        case ABS_MT_TRACKING_ID:
+          if (ev->value >= 0)
+            current_touching_ |= (1ULL << current_slot_);
+          else
+            current_touching_ &= ~(1ULL << current_slot_);
+          // fallthrough
         default:
           if (ev->code < kMinKey ||
               ev->code >= kMinKey + arraysize(member_map) ||
@@ -49,6 +133,7 @@
             break;
           CurrentFrame()->fingers_[
               current_slot_].*member_map[ev->code - kMinKey] = ev->value;
+          
           break;
       }
       break;
@@ -56,22 +141,28 @@
     case EV_SYN: {
       for (size_t i = 0; i < arraysize(frames_[0].fingers_); i++) {
         Finger* cur_finger = &CurrentFrame()->fingers_[i];
-        Finger* prev_finger = &PrevFrame()->fingers_[i];
         // New fingers should have their cancelled_ bit cleared
-        if (cur_finger->tracking_id_ > -1 && prev_finger->tracking_id_ == -1)
+        if ((current_touching_ & (1ULL << i)) &&
+            !(prev_touching_ & (1ULL << i)))
           cur_finger->cancelled_ = false;
+        cur_finger->timestamp_ = TimevalToDouble(ev->time);
         next_->FilterFinger(cur_finger);
       }
-      current_frame_ ^= 1;
+      prev_touching_ = current_touching_;
       break;
     }
   }
 }
 
 void InputEventFilter::GetCancelledTouches(uint64_t* slots_mask) {
-  for (size_t i = 0; i < arraysize(frames_[0].fingers_); i++)
-    if (PrevFrame()->fingers_[i].cancelled_)
+  for (size_t i = 0; i < arraysize(frames_[0].fingers_); i++) {
+    if (CurrentFrame()->fingers_[i].cancelled_) {
       (*slots_mask) |= 1 << i;
+      // If the finger was released, we can lose the cancel bit
+      if (!(prev_touching_ & (1ULL << i)))
+        CurrentFrame()->fingers_[i].cancelled_ = 0;
+    }
+  }
 }
 
 }  // namespace touch_noise_filter
diff --git a/input_event_filter.h b/input_event_filter.h
index 6f6e320..71d42c4 100644
--- a/input_event_filter.h
+++ b/input_event_filter.h
@@ -37,9 +37,13 @@
   Frame* CurrentFrame() { return &frames_[current_frame_]; }
   Frame* PrevFrame() { return &frames_[current_frame_ ^ 1]; }
 
-  Frame frames_[2];
+  Frame frames_[1];
   size_t current_frame_;
-  
+
+  // bitmasks of which slots have touches
+  uint64_t current_touching_;
+  uint64_t prev_touching_;  
+
   scoped_ptr<NoiseFilter> next_;
   size_t current_slot_;
 };
diff --git a/main.cc b/main.cc
index ecb3d1c..cd29244 100644
--- a/main.cc
+++ b/main.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -35,8 +36,8 @@
 
 struct timeval TimevalFromDouble(double when) {
   long int_part = static_cast<long>(when);
-  long micro_part = static_cast<long>(1000000.0 *
-                                      static_cast<double>(int_part) - when);
+  long micro_part = static_cast<long>(static_cast<double>(1000000.0) *
+                                      fmod(when, 1.0) + 0.5);
   struct timeval tv = { int_part, micro_part };
   return tv;
 }
@@ -68,14 +69,16 @@
     if (cancelled) {
       printf("CANCELLED SLOTS: ");
       for (size_t i = 0; i < 8 * sizeof(cancelled); i++) {
-        if (!(cancelled & (1 << i)))
+        if (!(cancelled & (1ULL << i)))
           continue;
         printf("%zu ", i);
       }
       printf("\n");
     }
   }
-  printf("GOT LINE: %f %x %x %d\n", when, type, code, value);
+  // printf("GOT LINE: %f (%ld . %ld)%x %x %d\n", when * 10000,
+  //        ev.time.tv_sec, ev.time.tv_usec,
+  //        type, code, value);
 }
 
 int main(int argc, char** argv) {
diff --git a/single_frame_tap_filter.cc b/single_frame_tap_filter.cc
index e1a8586..e0a9840 100644
--- a/single_frame_tap_filter.cc
+++ b/single_frame_tap_filter.cc
@@ -7,25 +7,34 @@
 #include <base/basictypes.h>
 
 #include <cstddef>
+#include <cstdio>
 
 namespace touch_noise_filter {
 
 namespace {
-double kMaxTapDuration = 0.015;
+double kMaxTapDuration = 0.1;
 }  // namespace {}
 
 void SingleFrameTapFilter::FilterFinger(Finger* finger) {
   Finger* prev_finger = &prev_fingers_[finger->slot_];
+  Log("got finger at %f in slot %d", finger->timestamp_,
+    finger->slot_);
 
   bool arrived = prev_finger->tracking_id_ == -1 && finger->tracking_id_ > 0;
   bool departing = prev_finger->tracking_id_ >= 0 && finger->tracking_id_ == -1;
-  if (prev_arrived_ && departing &&
-      (prev_finger->timestamp_ - finger->timestamp_ < kMaxTapDuration))
+  if ((prev_arrived_ & (1ULL << finger->slot_)) && departing &&
+      (finger->timestamp_ - prev_finger->timestamp_ < kMaxTapDuration)) {
     finger->cancelled_ = true;
+    TouchNoiseFilterLog("CANCEL AT %f, %d\n",
+                        finger->timestamp_, finger->slot_);
+  }
   
   // Store previous info
   *prev_finger = *finger;
-  prev_arrived_ = arrived;
+  if (arrived)
+    prev_arrived_ |= 1ULL << finger->slot_;
+  else
+    prev_arrived_ &= ~(1ULL << finger->slot_);
 }
 
 }  // namespace touch_noise_filter
diff --git a/touch_noise_filter.cc b/touch_noise_filter.cc
index aa78ce8..00556d9 100644
--- a/touch_noise_filter.cc
+++ b/touch_noise_filter.cc
@@ -19,10 +19,13 @@
 extern "C" {
 
 void* NewXFilter() {
+  Log("In NewXFilter");
   NoiseFilter* filters[] = {
     new SingleFrameTapFilter
   };
-  return new InputEventFilter(new MuxFilter(filters, arraysize(filters)));
+  void* ret = new InputEventFilter(new MuxFilter(filters, arraysize(filters)));
+  Log("Exiting NewXFilter");
+  return ret;
 }
 
 void FreeXFilter(void* x_filter) {