updating files

client.py

@@ -0,0 +1,104 @@
+# import cv2
+# import socket
+# import io
+# import struct
+
+# # Define connection details (replace with your actual values)
+# HOST = '144.126.254.143'  # IP address of the receiving device
+# PORT = 5555       # Port number for communication
+
+# # Create a socket connection
+# connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+# connection.connect((HOST, PORT))
+
+# print("Starting camera using OpenCV...")
+
+# # Initialize video capture using OpenCV
+# cap = cv2.VideoCapture(0)  # Change 0 to the video source index if needed
+
+# while True:
+#     # Capture frame-by-frame
+#     ret, frame = cap.read()
+
+#     # Check if frame capture is successful
+#     if not ret:
+#         print("Error: Frame not captured")
+#         break
+
+#     # Encode frame as JPEG
+#     _, jpeg_buffer = cv2.imencode('.jpg', frame)
+
+#     # Create a stream-like object from the JPEG buffer
+#     stream = io.BytesIO(jpeg_buffer.tobytes())
+
+#     # Get the stream's current position (similar to stream.tell())
+#     stream_length = stream.tell()
+
+#     # Send frame size (4 bytes) in little-endian format
+#     connection.sendall(struct.pack('<L', stream_length))
+
+#     # Reset the stream position (similar to stream.seek(0))
+#     stream.seek(0)
+
+#     # Send the entire JPEG frame
+#     connection.sendall(stream.read())
+
+#     # Reset the stream for the next frame
+#     stream.seek(0)
+#     stream.truncate()
+
+#     # Display the frame for preview (optional)
+#     cv2.imshow('Frame', frame)
+
+#     # Exit on 'q' key press
+#     if cv2.waitKey(1) == ord('q'):
+#         break
+
+# # Release resources
+# cap.release()
+# connection.close()
+# cv2.destroyAllWindows()
+
+# print("Camera and connection closed")
+import struct
+import time
+import socket
+import cv2
+
+SERVER_PORT=5555
+SERVER_IP='192.168.137.1'
+
+# Define the codec using VideoWriter_fourcc and create a VideoWriter object
+fourcc = cv2.VideoWriter_fourcc(*'H264')
+out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (640, 480))
+
+cap=cv2.VideoCapture(0)
+client_socket=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+client_socket.connect((SERVER_IP,SERVER_PORT))
+count=0
+while True:
+    time.sleep(0.05)
+    count += 1
+    print('sending frame', count)
+    ret, frame = cap.read()
+    if ret:
+        # Write the frame into the file 'output.mp4'
+        out.write(frame)
+
+        # Convert the frame to bytes
+        frame_encoded = cv2.imencode('.jpg', frame)[1].tostring()
+
+        # Send the size of the frame
+        client_socket.sendall(len(frame_encoded).to_bytes(4, 'big'))
+
+        # Send the frame
+        client_socket.sendall(frame_encoded)
+    else:
+        break
+
+
+    if cv2.waitKey(1)==ord('q'):
+      break
+cap.release()
+client_socket.close()
+cv2.destroyAllWindows( )

flaskServer.py

@@ -0,0 +1,39 @@
+import cv2
+import numpy
+from flask import Flask, render_template, Response, stream_with_context, request
+app=Flask('__name__')
+
+video=cv2.VideoCapture(0)
+global fps
+fps=0
+while True:
+	
+	ret,frame=video.read()
+	if not ret:
+		break
+	fps=fps+1
+	output_filePath=f'/home/kali/liveStream/demo{fps}.jpg'
+	#try:
+	#	cv2.imwrite(output_filePath,frame)
+	#	print('done')
+	#except Exception as e:
+	#	print('error',e)
+	if not ret:
+		print('not ret')
+		break
+	else:
+            ret,buffer=cv2.imencode('.jpeg',frame)
+            frame=buffer.tobytes()
+            yield (b' --frame\r\n' b'Content-type: imgae/jpeg\r\n\r\n' + frame +b'\r\n')	
+
+@app.route('/camera')
+def camera():
+	return render_template('camera.html')
+
+@app.route('video_feed')
+def video_feed():
+	return Response(video_stream(),mimetype='multipart.x-mixed-replace; boundary=frame$')
+
+app.run(host='0.0.0.0',port='5000', debug=False)
+
+#	cv2.imshow('video',frame)

harshServer.py

@@ -0,0 +1,65 @@
+import socket
+import cv2
+import struct
+import numpy as np
+
+# Import library for H.265 decoding (choose one)
+# Option 1: Using OpenCV with FFmpeg backend (if FFmpeg is installed)
+# cv2.h264decode is a wrapper for FFmpeg's H.265 decoder
+# Make sure FFmpeg is installed and the environment variable (e.g., PATH) is set correctly
+
+# Option 2: Using a dedicated H.265 decoder library (e.g., gstreamer)
+# You'll need to install and configure the chosen library following its documentation
+
+# Port to listen on
+SERVER_PORT = 5555
+
+# Create a TCP socket
+server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+server_socket.bind(("", SERVER_PORT))
+server_socket.listen(1)
+
+# Accept client connection
+client_socket, client_address = server_socket.accept()
+print(f"Connected to client {client_address}")
+count = 0
+
+while True:
+  print('Receiving')
+  # Receive frame size (4 bytes integer)
+  data = client_socket.recv(4)
+  if not data:
+    break
+  frame_size = int.from_bytes(data, byteorder='big')
+
+  # Receive the frame data (based on size)
+  data = b''
+  while len(data) < frame_size:
+    packet = client_socket.recv(4096)
+    if not packet:
+      break
+    data += packet
+
+  # Decode the received H.265 data
+  # Option 1: Using OpenCV with FFmpeg backend
+  frame = cv2.imdecode(np.frombuffer(data, dtype=np.uint8), cv2.IMREAD_COLOR)
+
+  # Option 2: Using a dedicated H.265 decoder library
+  # Replace this with the appropriate decoding function from your chosen library
+  # frame = ... (decode the data using your library)
+
+  # Process the frame here (optional)
+  # You can display the frame, save it, or perform further analysis
+
+  # Display the frame (optional)
+  cv2.imshow('Received Frame', frame)
+  cv2.imwrite(f'./imagesMQZ/frame{count}.jpeg', frame)
+  if cv2.waitKey(1) & 0xFF == ord('q'):
+    break
+
+  # Check for client disconnect
+  if not frame:
+    break
+
+server_socket.close()
+cv2.destroyAllWindows()

imageMCQServer.py

@@ -0,0 +1,40 @@
+# import the necessary packages
+from imutils import build_montages
+from datetime import datetime
+import numpy as np
+import imagezmq
+import argparse
+import imutils
+import cv2
+mW=1
+
+
+mH=1
+
+# initialize the ImageHub object
+imageHub= imagezmq.ImageHub()
+frameDict = {}
+print("[INFO] connecting to server...")
+count=0
+while True:
+    count+=1
+    try:
+
+        (rpiName, frame) = imageHub.recv_image()
+        imageHub.send_reply(b'OK')
+        frame=imutils.resize(frame,width=400)
+        (H,W)=frame.shape[:2]
+    
+        #save the frame locally
+        cv2.imwrite(f'./imagesMQZ/frame{count}.jpeg',frame)
+        #read frame from local storage
+        cv2.imshow('Frame', frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+        
+        
+
+    except Exception as e:
+        print('error',e)
+        continue
+cv2.destroyAllWindows()