testing

Author: Kontra2B

examples/C/color/rs-color.c

@@ -74,6 +74,9 @@ int main()
         exit(EXIT_FAILURE);
     }
 
+    unsigned long long old_frame_number = -1LL;
+    rs2_time_t old_frame_timestamp = 0;
+
     while (1)  // Until user presses Ctrl+C
     {
         // This call waits until a new composite_frame is available
@@ -86,6 +89,7 @@ int main()
         int num_of_frames = rs2_embedded_frames_count(frames, &e);
         check_error(e);
 
+
         int i;
         for (i = 0; i < num_of_frames; ++i)
         {
@@ -110,17 +114,23 @@ int main()
             rs2_metadata_type frame_metadata_time_of_arrival = rs2_get_frame_metadata(frame, RS2_FRAME_METADATA_TIME_OF_ARRIVAL, &e);
             check_error(e);
 
-            printf("RGB frame arrived.\n");
-            printf("First 10 bytes: ");
-            int i;
-            for(i=0; i < 10; ++i)
-                printf("%02x ", rgb_frame_data[i]);
-
-            printf("\nFrame No: %llu\n", frame_number);
-            printf("Timestamp: %f\n", frame_timestamp);
-            printf("Timestamp domain: %s\n", frame_timestamp_domain_str);
-            printf("Time of arrival: %lld\n\n", frame_metadata_time_of_arrival);
+	    if (!(frame_number%1000)) {
+		    printf("RGB frame arrived.\n");
+		    printf("First 10 bytes: ");
+		    int i;
+		    for(i=0; i < 10; ++i)
+			    printf("%02x ", rgb_frame_data[i]);
+
+		    printf("\nFrame No: %llu/%llu\n", frame_number, old_frame_number);
+		    printf("Timestamp: %f/%f\n", frame_timestamp, old_frame_timestamp);
+		    printf("Timestamp domain: %s\n", frame_timestamp_domain_str);
+		    printf("Time of arrival: %lld\n\n", frame_metadata_time_of_arrival);
+	    }
             rs2_release_frame(frame);
+	    if (old_frame_number == frame_number) exit(1);
+	    if (old_frame_timestamp == frame_timestamp) exit(2);
+	    old_frame_number = frame_number;
+	    old_frame_timestamp = frame_timestamp;
         }
 
         rs2_release_frame(frames);

examples/capture/rs-capture.cpp

@@ -1,43 +1,75 @@
-// License: Apache 2.0. See LICENSE file in root directory.
-// Copyright(c) 2017 RealSense, Inc. All Rights Reserved.
+// License: Apache 2.0. See LICENSE file in root directory.
+// Copyright(c) 2017 Intel Corporation. All Rights Reserved.
 
+#include <chrono>
+#include <iostream>
 #include <librealsense2/rs.hpp> // Include RealSense Cross Platform API
+#include <map>
 #include "example.hpp"          // Include short list of convenience functions for rendering
 
 // Capture Example demonstrates how to
 // capture depth and color video streams and render them to the screen
 int main(int argc, char * argv[]) try
 {
-    rs2::log_to_console(RS2_LOG_SEVERITY_ERROR);
+    std::map<rs2_stream, std::pair<rs2_metadata_type, rs2_metadata_type>> old;
+    rs2::log_to_file(RS2_LOG_SEVERITY_DEBUG, "rs-capture.log");
     // Create a simple OpenGL window for rendering:
-    window app(1280, 720, "RealSense Capture Example");
-
-    // Declare depth colorizer for pretty visualization of depth data
-    rs2::colorizer color_map;
-    // Declare rates printer for showing streaming rates of the enabled streams.
-    rs2::rates_printer printer;
+    // window app(1280, 720, "RealSense Capture Example");
 
     // Declare RealSense pipeline, encapsulating the actual device and sensors
     rs2::pipeline pipe;
-    rs2::config cfg;
-
-    // Enable all camera streams
-    cfg.enable_all_streams();
 
     // Start streaming with default recommended configuration
     // The default video configuration contains Depth and Color streams
     // If a device is capable to stream IMU data, both Gyro and Accelerometer are enabled by default
+    rs2::config cfg;
+    cfg.enable_stream(RS2_STREAM_DEPTH);
+    cfg.enable_stream(RS2_STREAM_COLOR);
+    cfg.enable_stream(RS2_STREAM_INFRARED);
+
+    if (argc > 1) {
+        cfg.enable_device(argv[1]);
+    }
     pipe.start(cfg);
 
-    while (app) // Application still alive?
+    int idx = 1;
+    while (true) // Application still alive?
     {
-        rs2::frameset data = pipe.wait_for_frames().    // Wait for next set of frames from the camera
-                             apply_filter(printer).     // Print each enabled stream frame rate
-                             apply_filter(color_map);   // Find and colorize the depth data
+        //rs2::frameset data = pipe.wait_for_frames().    // Wait for next set of frames from the camera
+        const rs2::frameset& fset = pipe.wait_for_frames();
+        // std::cout << std::endl << "----- CLOCK:" << std::chrono::steady_clock::now().time_since_epoch().count() << "ns" << std::endl;
+	const size_t nf = fset.size();
+	int i = 1;
+        
+        fset.foreach_rs([&idx, &old, &i, nf] (const rs2::frame& f) {
+		static int ne = 0;
+                auto fs = f.get_profile().stream_type();
+                auto fc = f.get_frame_metadata(RS2_FRAME_METADATA_FRAME_COUNTER);
+                auto ft = f.get_frame_metadata(RS2_FRAME_METADATA_FRAME_TIMESTAMP);
+                // auto fr = f.get_frame_metadata(RS2_FRAME_METADATA_CRC);
+                //char path[64];
+                //sprintf(path, "S%d-%d.bin", (int)fs, (int)idx);
+                if (i == 1) std::cout << std::endl << idx << '.';
+                std::cout << '\t' << i++ << '/' << nf << '\t' << fs << ':' << fc << '/' << ft;
+		try {
+			const auto& ofs = old.at(fs);
+			if (!(fc > ofs.first && ft > ofs.second)) {
+			std::cout << std::endl << "!!!/" << ++ne << ":\t\t" << fs << ':' << ofs.first << '/' << ofs.second << std::endl;
+			// for (const auto& rec:old) std::cout << "\t" << rec.first << ":" << rec.second.first << '/' << rec.second.second;
+			if (ne > 10) exit(EXIT_FAILURE);
+			}
+		} catch(...) {}
+		old[fs].first = fc;
+		old[fs].second = ft;
+                //auto fo = fopen(path, "wb+");
+                //fwrite(fd, f.get_data_size(), 1, fo);
+                //fclose(fo);
+        });
+        idx++;
 
         // The show method, when applied on frameset, break it to frames and upload each frame into a gl textures
         // Each texture is displayed on different viewport according to it's stream unique id
-        app.show(data);
+        // app.show(data);
     }
 
     return EXIT_SUCCESS;

scripts/rs-enum.sh

@@ -87,7 +87,7 @@ declare -A camera_names=( [depth]=depth [rgb]=color [ir]=ir [imu]=imu )
 camera_vid=("depth" "depth-md" "color" "color-md" "ir" "ir-md" "imu")
 
 
-mdev=$(${v4l2_util} --list-devices | grep -A1 tegra | grep media)
+mdev=$(${v4l2_util} --list-devices | grep media)
 
 # For Jetson we have `simple` method
 if [ -n "${mdev}" ]; then

src/sensor.cpp

@@ -332,7 +332,6 @@ void log_callback_end( uint32_t fps,
 
         // update additional data
         additional_data.timestamp = timestamp_reader->get_frame_timestamp(fr);
-        additional_data.last_frame_number = last_frame_number;
         additional_data.frame_number = timestamp_reader->get_frame_counter(fr);
         fr->additional_data = additional_data;
 

src/stream.h

@@ -93,10 +93,17 @@ namespace librealsense
         void create_snapshot(std::shared_ptr<stream_profile_interface>& snapshot) const override;
         void enable_recording(std::function<void(const stream_profile_interface&)> record_action) override;
 
+	rs2_metadata_type getLastFrame() { return _last_frame; }
+	void setLastFrame(rs2_metadata_type last_frame ) { _last_frame = last_frame; }
+
+	rs2_metadata_type getLastTimestamp() { return _last_timestamp; }
+	void setLastTimestamp(rs2_metadata_type last_timestamp ) { _last_timestamp = last_timestamp; }
     private:
         int _index = 1;
         int _uid = 0;
         rs2_stream _type = RS2_STREAM_ANY;
+	rs2_metadata_type _last_frame = 0;
+	rs2_metadata_type _last_timestamp = 0;
         rs2_format _format = RS2_FORMAT_ANY;
         uint32_t _framerate = 0;
         int _tag = profile_tag::PROFILE_TAG_ANY;

src/uvc-sensor.cpp

@@ -116,11 +116,9 @@ void uvc_sensor::open( const stream_profiles & requests )
         auto && req_profile_base = std::dynamic_pointer_cast< stream_profile_base >( req_profile );
         try
         {
-            unsigned long long last_frame_number = 0;
-            rs2_time_t last_timestamp = 0;
             _device->probe_and_commit(
                 req_profile_base->get_backend_profile(),
-                [this, req_profile_base, req_profile, last_frame_number, last_timestamp](
+                [this, req_profile_base, req_profile](
                     platform::stream_profile p,
                     platform::frame_object f,
                     std::function< void() > continuation ) mutable
@@ -135,6 +133,9 @@ void uvc_sensor::open( const stream_profiles & requests )
                                      << f.backend_time << " " << system_time );
                         return;
                     }
+		    auto last_frame_number = req_profile_base->getLastFrame();
+		    auto last_timestamp = req_profile_base->getLastTimestamp();
+		    LOG_DEBUG( "[WOJTEK] last_frame_number/" << req_profile_base->get_stream_type() << ": " << last_frame_number);
 
                     auto && fr = generate_frame_from_data( f,
                                                                  system_time,
@@ -160,24 +161,28 @@ void uvc_sensor::open( const stream_profiles & requests )
                             fr->additional_data.frame_number = ++_accel_counter;
                         else if( stream_type == 2 ) // 2 == Gyro
                             fr->additional_data.frame_number = ++_gyro_counter;
+			LOG_DEBUG( "[WOJTEK] overriding frame counter with motion stream data: " << frame_counter << '/' << fr->additional_data.frame_number);
                         frame_counter = fr->additional_data.frame_number;
                     }
 
 
-                    LOG_DEBUG( "FrameAccepted,"
-                               << librealsense::get_string( req_profile_base->get_stream_type() ) << ",Counter,"
-                               << std::dec << fr->additional_data.frame_number << ",Index,"
-                               << req_profile_base->get_stream_index() << ",BackEndTS," << std::fixed << f.backend_time
-                               << ",SystemTime," << std::fixed << system_time << " ,diff_ts[Sys-BE],"
-                               << system_time - f.backend_time << ",TS," << std::fixed << timestamp << ",TS_Domain,"
-                               << rs2_timestamp_domain_to_string( timestamp_domain ) << ",last_frame_number,"
-                               << last_frame_number << ",last_timestamp," << last_timestamp );
+                    LOG_DEBUG( "FrameAccepted:"
+                               << librealsense::get_string( req_profile_base->get_stream_type() )
+			       << ", Counter:" << std::dec << fr->additional_data.frame_number
+			       << ", Index:" << req_profile_base->get_stream_index()
+			       << ", BackEndTS:" << std::fixed << f.backend_time
+                               << ", SystemTime:" << std::fixed << system_time
+			       << ", diff_ts[Sys-BE]:" << system_time - f.backend_time
+			       << ", TS:" << std::fixed << timestamp
+			       << ", TS_Domain:" << rs2_timestamp_domain_to_string( timestamp_domain )
+			       << ", last_frame_number:" << last_frame_number
+			       << ", last_timestamp:" << last_timestamp );
 
                     if( frame_counter <= last_frame_number )
-                        LOG_INFO( "Frame counter reset" );
+                        LOG_INFO( "Frame counter reset: " << last_frame_number << " => " << frame_counter);
 
-                    last_frame_number = frame_counter;
-                    last_timestamp = timestamp;
+                    req_profile_base->setLastFrame(frame_counter);
+                    req_profile_base->setLastTimestamp(timestamp);
 
                     const auto && vsp = As< video_stream_profile, stream_profile_interface >( req_profile );
                     int width = vsp ? vsp->get_width() : 0;