just use camera code included in the ardunio libs

README.md

@@ -1,10 +1,8 @@
 # Micro-RTSP
 
 This is a small library which can be used to serve up RTSP streams from
-resource constrained MCUs.
-
-Note: This is still a WIP but it is working pretty good on my little ESP32.
-I should have an initial version out by about Feb 5th...  That version will include more documentation.
+resource constrained MCUs.  It lets you trivially make a $10 open source
+RTSP video stream camera.
 
 # Usage
 
@@ -16,9 +14,66 @@ This library will work standalone, but it is _super_ easy to use if your app is
 Just "pio lib install Micro-RTSP" to pull the latest version from their library server.  If you want to use the OV2640
 camera support you'll need to be targeting the espressif32 platform in your project.
 
+<<<<<<< HEAD
+=======
+See the (example platform.io app)[/examples].  It should build and run on virtually any of the $10
+ESP32-CAM boards (such as M5CAM).  The relevant bit of the code is included below.  In short:
+1. Listen for a TCP connection on the RTSP port with accept()
+2. When a connection comes in, create a CRtspSession and OV2640Streamer camera streamer objects.
+3. While the connection remains, call session->handleRequests(0) to handle any incoming client requests.
+4. Every 100ms or so call session->broadcastCurrentFrame() to send new frames to any clients.
+
+```
+void loop()
+{
+    uint32_t msecPerFrame = 100;
+    static uint32_t lastimage = millis();
+
+    // If we have an active client connection, just service that until gone
+    // (FIXME - support multiple simultaneous clients)
+    if(session) {
+        session->handleRequests(0); // we don't use a timeout here,
+        // instead we send only if we have new enough frames
+
+        uint32_t now = millis();
+        if(now > lastimage + msecPerFrame || now < lastimage) { // handle clock rollover
+            session->broadcastCurrentFrame(now);
+            lastimage = now;
+
+            // check if we are overrunning our max frame rate
+            now = millis();
+            if(now > lastimage + msecPerFrame)
+                printf("warning exceeding max frame rate of %d ms\n", now - lastimage);
+        }
+
+        if(session->m_stopped) {
+            delete session;
+            delete streamer;
+            session = NULL;
+            streamer = NULL;
+        }
+    }
+    else {
+        client = rtspServer.accept();
+
+        if(client) {
+            //streamer = new SimStreamer(&client, true);             // our streamer for UDP/TCP based RTP transport
+            streamer = new OV2640Streamer(&client, cam);             // our streamer for UDP/TCP based RTP transport
+
+            session = new CRtspSession(&client, streamer); // our threads RTSP session and state
+        }
+    }
+}
+```
+>>>>>>> just use camera code included in the ardunio libs
 ## Example posix/linux usage
 
-There is a small standalone example [here](/test/RTSPTestServer.cpp).  You can build it by following [these](/test/README.md) directions.
+There is a small standalone example [here](/test/RTSPTestServer.cpp).  You can build it by following [these](/test/README.md) directions.  The usage of the two key classes (CRtspSession and SimStreamer) are very similar to to the ESP32 usage.
+
+## Supporting new camera devices
+
+Supporting new camera devices is quite simple.  See OV2640Streamer for an example and implement streamImage()
+by reading a frame from your camera.
 
 # Structure and design notes
 

TODO.md

@@ -1,5 +1,4 @@
-* add documentation
-* publish example app
+* add instructions for example app
 * push RTSP streams to other servers ( https://github.com/ant-media/Ant-Media-Server/wiki/Getting-Started )
 * make stack larger so that the various scratch buffers (currently in bss) can be shared
 * cleanup code to a less ugly unified coding standard