# 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>
old-commit-hash: 0baa4c3e2ad9ee6f8daba8267db44c2cd44caa62
											 
										 
										
											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>
old-commit-hash: 0baa4c3e2ad9ee6f8daba8267db44c2cd44caa62
											 
										 
										
											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>
old-commit-hash: 0baa4c3e2ad9ee6f8daba8267db44c2cd44caa62
											 
										 
										
											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>
old-commit-hash: 0baa4c3e2ad9ee6f8daba8267db44c2cd44caa62
											 
										 
										
											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>
old-commit-hash: 0baa4c3e2ad9ee6f8daba8267db44c2cd44caa62
											 
										 
										
											4 years ago 
										
									 
								 
							 
							
								
									
										 
								
							 
							
								 
							
							
								  . record  =  true , 
  
						 
					
						
							
								
							 
							
								
									
										 
								
							 
							
								 
							
							
								  . frame_width  =  526 , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								  . frame_height  =  330 , 
  
						 
					
						
							
								
							 
							
								
							 
							
								 
							
							
								} ;