|  |  |  | #pragma once
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #include <unistd.h>
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #include <atomic>
 | 
					
						
							|  |  |  | #include <cassert>
 | 
					
						
							|  |  |  | #include <cerrno>
 | 
					
						
							|  |  |  | #include <condition_variable>
 | 
					
						
							|  |  |  | #include <mutex>
 | 
					
						
							|  |  |  | #include <string>
 | 
					
						
							|  |  |  | #include <thread>
 | 
					
						
							|  |  |  | #include <unordered_map>
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #include "cereal/messaging/messaging.h"
 | 
					
						
							|  |  |  | #include "cereal/services.h"
 | 
					
						
							|  |  |  | #include "cereal/visionipc/visionipc.h"
 | 
					
						
							|  |  |  | #include "cereal/visionipc/visionipc_client.h"
 | 
					
						
							|  |  |  | #include "system/camerad/cameras/camera_common.h"
 | 
					
						
							|  |  |  | #include "common/params.h"
 | 
					
						
							|  |  |  | #include "common/swaglog.h"
 | 
					
						
							|  |  |  | #include "common/timing.h"
 | 
					
						
							|  |  |  | #include "common/util.h"
 | 
					
						
							|  |  |  | #include "system/hardware/hw.h"
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #include "selfdrive/loggerd/encoder/encoder.h"
 | 
					
						
							|  |  |  | #include "selfdrive/loggerd/logger.h"
 | 
					
						
							|  |  |  | #ifdef QCOM2
 | 
					
						
							|  |  |  | #include "selfdrive/loggerd/encoder/v4l_encoder.h"
 | 
					
						
							| 
									
										
											  
											
												loggerd: switch to v4l encoder try 2 (#24380)
* start v4l encoder
* v4l encoder starts
* start and stop
* fill in proper controls
* it dequeued a buffer
* getting bytes
* it made a video
* it does make files
* getting close
* ahh, so that's how dequeue works
* qcam works (no remuxing)
* remuxing works
* we just need to make shutdown and rollover graceful
* graceful destruction
* switch to polling
* should work now
* fix pc build
* refactors, stop properly
* touchups, remove a copy
* add v4l encoder to release
* inlcude file
* move writing to it's own thread
* fix minor memory leak
* block instead of dropping frames
* add counter, fix tests maybe
* better debugging and test print
* print file path in assert
* format string in test
* no more oversized qlogs
* match qcam
* touchups, remove omx encoder
* remove omx include files
* checked ioctl, better debugging, open by name
* unused import
* move linux includes to third_party/linux/include
* simple encoderd
* full packet
* encoderd should be complete
* lagging print
* updates
* name dq thread
* subset idx
* video file writing works
* debug
* potential bugfix
* rotation works
* iframe
* keep writing support
* ci should pass
* loggerd, not encoderd
* remote encoder code
* support remote encoder
* cereal to master, add encoderd
* header no longer required
* put that back there
* realtime
* lower decoder latency
* don't use queue for VisionIpcBufExtra, disable realtime again
* assert all written
* hmm simpler
* only push to to_write if we are writing
* assert timestamp is right
* use at and remove assert
* revert to queue
Co-authored-by: Comma Device <device@comma.ai>
											
										 
											4 years ago
										 |  |  | #define Encoder V4LEncoder
 | 
					
						
							|  |  |  | #else
 | 
					
						
							|  |  |  | #include "selfdrive/loggerd/encoder/ffmpeg_encoder.h"
 | 
					
						
							|  |  |  | #define Encoder FfmpegEncoder
 | 
					
						
							|  |  |  | #endif
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | constexpr int MAIN_FPS = 20;
 | 
					
						
							|  |  |  | const int MAIN_BITRATE = 10000000;
 | 
					
						
							|  |  |  | const int DCAM_BITRATE = MAIN_BITRATE;
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | #define NO_CAMERA_PATIENCE 500 // fall back to time-based rotation if all cameras are dead
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | const bool LOGGERD_TEST = getenv("LOGGERD_TEST");
 | 
					
						
							|  |  |  | const int SEGMENT_LENGTH = LOGGERD_TEST ? atoi(getenv("LOGGERD_SEGMENT_LENGTH")) : 60;
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | struct LogCameraInfo {
 | 
					
						
							|  |  |  |   CameraType type;
 | 
					
						
							|  |  |  |   const char *filename;
 | 
					
						
							|  |  |  |   VisionStreamType stream_type;
 | 
					
						
							|  |  |  |   int frame_width, frame_height;
 | 
					
						
							|  |  |  |   int fps;
 | 
					
						
							|  |  |  |   int bitrate;
 | 
					
						
							|  |  |  |   bool is_h265;
 | 
					
						
							|  |  |  |   bool has_qcamera;
 | 
					
						
							|  |  |  |   bool record;
 | 
					
						
							|  |  |  | };
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | const LogCameraInfo cameras_logged[] = {
 | 
					
						
							|  |  |  |   {
 | 
					
						
							|  |  |  |     .type = RoadCam,
 | 
					
						
							|  |  |  |     .stream_type = VISION_STREAM_ROAD,
 | 
					
						
							|  |  |  |     .filename = "fcamera.hevc",
 | 
					
						
							|  |  |  |     .fps = MAIN_FPS,
 | 
					
						
							|  |  |  |     .bitrate = MAIN_BITRATE,
 | 
					
						
							|  |  |  |     .is_h265 = true,
 | 
					
						
							|  |  |  |     .has_qcamera = true,
 | 
					
						
							|  |  |  |     .record = true,
 | 
					
						
							| 
									
										
											  
											
												loggerd: switch to v4l encoder try 2 (#24380)
* start v4l encoder
* v4l encoder starts
* start and stop
* fill in proper controls
* it dequeued a buffer
* getting bytes
* it made a video
* it does make files
* getting close
* ahh, so that's how dequeue works
* qcam works (no remuxing)
* remuxing works
* we just need to make shutdown and rollover graceful
* graceful destruction
* switch to polling
* should work now
* fix pc build
* refactors, stop properly
* touchups, remove a copy
* add v4l encoder to release
* inlcude file
* move writing to it's own thread
* fix minor memory leak
* block instead of dropping frames
* add counter, fix tests maybe
* better debugging and test print
* print file path in assert
* format string in test
* no more oversized qlogs
* match qcam
* touchups, remove omx encoder
* remove omx include files
* checked ioctl, better debugging, open by name
* unused import
* move linux includes to third_party/linux/include
* simple encoderd
* full packet
* encoderd should be complete
* lagging print
* updates
* name dq thread
* subset idx
* video file writing works
* debug
* potential bugfix
* rotation works
* iframe
* keep writing support
* ci should pass
* loggerd, not encoderd
* remote encoder code
* support remote encoder
* cereal to master, add encoderd
* header no longer required
* put that back there
* realtime
* lower decoder latency
* don't use queue for VisionIpcBufExtra, disable realtime again
* assert all written
* hmm simpler
* only push to to_write if we are writing
* assert timestamp is right
* use at and remove assert
* revert to queue
Co-authored-by: Comma Device <device@comma.ai>
											
										 
											4 years ago
										 |  |  |     .frame_width = 1928,
 | 
					
						
							|  |  |  |     .frame_height = 1208,
 | 
					
						
							|  |  |  |   },
 | 
					
						
							|  |  |  |   {
 | 
					
						
							|  |  |  |     .type = DriverCam,
 | 
					
						
							|  |  |  |     .stream_type = VISION_STREAM_DRIVER,
 | 
					
						
							|  |  |  |     .filename = "dcamera.hevc",
 | 
					
						
							|  |  |  |     .fps = MAIN_FPS,
 | 
					
						
							|  |  |  |     .bitrate = DCAM_BITRATE,
 | 
					
						
							|  |  |  |     .is_h265 = true,
 | 
					
						
							|  |  |  |     .has_qcamera = false,
 | 
					
						
							|  |  |  |     .record = Params().getBool("RecordFront"),
 | 
					
						
							| 
									
										
											  
											
												loggerd: switch to v4l encoder try 2 (#24380)
* start v4l encoder
* v4l encoder starts
* start and stop
* fill in proper controls
* it dequeued a buffer
* getting bytes
* it made a video
* it does make files
* getting close
* ahh, so that's how dequeue works
* qcam works (no remuxing)
* remuxing works
* we just need to make shutdown and rollover graceful
* graceful destruction
* switch to polling
* should work now
* fix pc build
* refactors, stop properly
* touchups, remove a copy
* add v4l encoder to release
* inlcude file
* move writing to it's own thread
* fix minor memory leak
* block instead of dropping frames
* add counter, fix tests maybe
* better debugging and test print
* print file path in assert
* format string in test
* no more oversized qlogs
* match qcam
* touchups, remove omx encoder
* remove omx include files
* checked ioctl, better debugging, open by name
* unused import
* move linux includes to third_party/linux/include
* simple encoderd
* full packet
* encoderd should be complete
* lagging print
* updates
* name dq thread
* subset idx
* video file writing works
* debug
* potential bugfix
* rotation works
* iframe
* keep writing support
* ci should pass
* loggerd, not encoderd
* remote encoder code
* support remote encoder
* cereal to master, add encoderd
* header no longer required
* put that back there
* realtime
* lower decoder latency
* don't use queue for VisionIpcBufExtra, disable realtime again
* assert all written
* hmm simpler
* only push to to_write if we are writing
* assert timestamp is right
* use at and remove assert
* revert to queue
Co-authored-by: Comma Device <device@comma.ai>
											
										 
											4 years ago
										 |  |  |     .frame_width = 1928,
 | 
					
						
							|  |  |  |     .frame_height = 1208,
 | 
					
						
							|  |  |  |   },
 | 
					
						
							|  |  |  |   {
 | 
					
						
							|  |  |  |     .type = WideRoadCam,
 | 
					
						
							|  |  |  |     .stream_type = VISION_STREAM_WIDE_ROAD,
 | 
					
						
							|  |  |  |     .filename = "ecamera.hevc",
 | 
					
						
							|  |  |  |     .fps = MAIN_FPS,
 | 
					
						
							|  |  |  |     .bitrate = MAIN_BITRATE,
 | 
					
						
							|  |  |  |     .is_h265 = true,
 | 
					
						
							|  |  |  |     .has_qcamera = false,
 | 
					
						
							|  |  |  |     .record = true,
 | 
					
						
							| 
									
										
											  
											
												loggerd: switch to v4l encoder try 2 (#24380)
* start v4l encoder
* v4l encoder starts
* start and stop
* fill in proper controls
* it dequeued a buffer
* getting bytes
* it made a video
* it does make files
* getting close
* ahh, so that's how dequeue works
* qcam works (no remuxing)
* remuxing works
* we just need to make shutdown and rollover graceful
* graceful destruction
* switch to polling
* should work now
* fix pc build
* refactors, stop properly
* touchups, remove a copy
* add v4l encoder to release
* inlcude file
* move writing to it's own thread
* fix minor memory leak
* block instead of dropping frames
* add counter, fix tests maybe
* better debugging and test print
* print file path in assert
* format string in test
* no more oversized qlogs
* match qcam
* touchups, remove omx encoder
* remove omx include files
* checked ioctl, better debugging, open by name
* unused import
* move linux includes to third_party/linux/include
* simple encoderd
* full packet
* encoderd should be complete
* lagging print
* updates
* name dq thread
* subset idx
* video file writing works
* debug
* potential bugfix
* rotation works
* iframe
* keep writing support
* ci should pass
* loggerd, not encoderd
* remote encoder code
* support remote encoder
* cereal to master, add encoderd
* header no longer required
* put that back there
* realtime
* lower decoder latency
* don't use queue for VisionIpcBufExtra, disable realtime again
* assert all written
* hmm simpler
* only push to to_write if we are writing
* assert timestamp is right
* use at and remove assert
* revert to queue
Co-authored-by: Comma Device <device@comma.ai>
											
										 
											4 years ago
										 |  |  |     .frame_width = 1928,
 | 
					
						
							|  |  |  |     .frame_height = 1208,
 | 
					
						
							|  |  |  |   },
 | 
					
						
							|  |  |  | };
 | 
					
						
							|  |  |  | const LogCameraInfo qcam_info = {
 | 
					
						
							|  |  |  |   .filename = "qcamera.ts",
 | 
					
						
							|  |  |  |   .fps = MAIN_FPS,
 | 
					
						
							|  |  |  |   .bitrate = 256000,
 | 
					
						
							|  |  |  |   .is_h265 = false,
 | 
					
						
							| 
									
										
											  
											
												loggerd: switch to v4l encoder try 2 (#24380)
* start v4l encoder
* v4l encoder starts
* start and stop
* fill in proper controls
* it dequeued a buffer
* getting bytes
* it made a video
* it does make files
* getting close
* ahh, so that's how dequeue works
* qcam works (no remuxing)
* remuxing works
* we just need to make shutdown and rollover graceful
* graceful destruction
* switch to polling
* should work now
* fix pc build
* refactors, stop properly
* touchups, remove a copy
* add v4l encoder to release
* inlcude file
* move writing to it's own thread
* fix minor memory leak
* block instead of dropping frames
* add counter, fix tests maybe
* better debugging and test print
* print file path in assert
* format string in test
* no more oversized qlogs
* match qcam
* touchups, remove omx encoder
* remove omx include files
* checked ioctl, better debugging, open by name
* unused import
* move linux includes to third_party/linux/include
* simple encoderd
* full packet
* encoderd should be complete
* lagging print
* updates
* name dq thread
* subset idx
* video file writing works
* debug
* potential bugfix
* rotation works
* iframe
* keep writing support
* ci should pass
* loggerd, not encoderd
* remote encoder code
* support remote encoder
* cereal to master, add encoderd
* header no longer required
* put that back there
* realtime
* lower decoder latency
* don't use queue for VisionIpcBufExtra, disable realtime again
* assert all written
* hmm simpler
* only push to to_write if we are writing
* assert timestamp is right
* use at and remove assert
* revert to queue
Co-authored-by: Comma Device <device@comma.ai>
											
										 
											4 years ago
										 |  |  |   .record = true,
 | 
					
						
							|  |  |  |   .frame_width = 526,
 | 
					
						
							|  |  |  |   .frame_height = 330,
 | 
					
						
							|  |  |  | };
 |