Updated the program

Fixed the program (it breaks when the input file perfectly matches (or is a multiple of) the amount of bits each frame contains)

Cleaned up the excessive comments

Author: Emayeah

Dec.py

@@ -1,41 +1,44 @@
-import cv2 #imports opencv, make sure that you have opencv installed
-import numpy as np #imports numpy and makes it callable with np cus lazy
+import cv2
+import numpy as np
 
 def decode_video(video_path, output_file_path, width=1280, height=720, pix=5): #set this exactly like how you set the encoding, otherwise it breaks
-    video_reader = cv2.VideoCapture(video_path) #initialize the video reader
-    binary_data = '' #declares binary_data
-    index = 0 #declares index, it 
-    add = int(width * height / (pix * pix)) #declares add and makes it the amount that needs to be added for each time a frame is completed
-    m = True #declares m to check if the 1st frame has been read, m=True = no, m=False = yes
+    video_reader = cv2.VideoCapture(video_path)
+    binary_data = ''
+    index = 0 #counter of the bits already converted
+    add = int(width * height / (pix * pix))
+    m = 1 #declares m to check if the 1st frame has been read, m=1 = no, m=0 = yes
     with open(output_file_path, 'ab') as output_file: #declares output_file as the output file, and makes every write function append data
-        while True: #loop forever
+        while True:
             ret, frame = video_reader.read() #ret = if the frame exsists or not, frame = the frame data itself
-            if not ret: #if the frame doesn't exsist break
-               print("a") #prints a if the condition is true, so if you see an a the video may be fried of you just reached the end (the latter is 100000000000 times more likely)
-               break #breaks if the condition is true
-            frame = cv2.resize(frame, (int(width / pix), int(height / pix)), interpolation=cv2.INTER_NEAREST) #resize the frame so that each bit is 1 pixel wide
+            if not ret:
+               print("finished") #prints this if it finished going through the video
+               break
+            frame = cv2.resize(frame, (int(width / pix), int(height / pix)), interpolation=cv2.INTER_NEAREST) #resize the frame so that each bit is 1 pixel wide, in the encoder each pixel is much wider to resist compression
             if frame.size == 0: #if the frame is corrupt it breaks
-                break #it breaks if the frame is corrupt
+                break
             intensity = np.mean(frame, axis=(2 if len(frame.shape) == 3 else 0))
-            index += add #adds the amount of bits it has already converted
-            print(index) #prints the amount of bits it has converted in the 1st frame
-            if m == False: #checks if the 1st frame has already been done
+            index += add
+            print(index)
+            if m == 0:
                 binary_data = ''.join(np.where(intensity.flatten() > 127, '1', '0').astype(str)) #writes the data in the frame into a variable
                 binary_array = np.array([int(bit) for bit in binary_data]) #transforms the data into an array
                 bytes_array = np.packbits(binary_array) #transforms the binary array into a bytes array
-                output_file.write(bytes_array) #appends the bytes array (the data itself)
-            if m == True: #checks if the 1st frame has not been done
-                binary_data = ''.join(np.where(intensity.flatten() > 127, '1', '0').astype(str)) #writes the data in the frame into a variable
-                first_one_index = binary_data.find('1') #checks where the 1st 1 is in the 1st frame
-                binary_data = binary_data[first_one_index + 1:] #scraps all the data including the extra 1
-                binary_array = np.array([int(bit) for bit in binary_data]) #transforms the data into an array
-                bytes_array = np.packbits(binary_array) #transforms the binary array into a bytes array
-                output_file.write(bytes_array)#appends the bytes array (the data itself)
-                m = False #sets the 1st frame check to false (1st frame has already been done)
-                print(f"file decoded and written to {output_file}") #tells the user where the file is, useless since it can be found down a few lines from here
+                output_file.write(bytes_array)
+            else:
+                binary_data = ''.join(np.where(intensity.flatten() > 127, '1', '0').astype(str))
+                first_one_index = binary_data.find('1')
+                binary_data = binary_data[first_one_index + 1:] #scraps all the data including the extra 1, all of this is because it needs to scrap the gap left by files that don't perfectly fit into the video without leaving some gaps (the gap is at the beginning for efficiency reasons)
+                if binary_data == "": #scraps the 1st frame if the 1st frame is empty, happens when the file perfectly fits into the video without leaving any gap
+                    m = 0 
+                else:
+                    binary_array = np.array([int(bit) for bit in binary_data]) #transforms the data into an array
+                    bytes_array = np.packbits(binary_array) #transforms the binary array into a bytes array
+                    output_file.write(bytes_array)
+                    m = 0
+                print("file decoded and written to" + output_file_path)
 
 
-if __name__ == "__main__": #checks if the program has already been run
-    video_path = "/home/ema/Desktop/Out1.avi" #input the video file
-    output_file_path = "/home/ema/Desktop/bk foot lettuce2.txt" #input the file output
-    decode_video(video_path, output_file_path) #calls decode video
+if __name__ == "__main__":
+    video_path = "input.avi" #input the video file
+    output_file_path = "output.txt" #input the file output
+    decode_video(video_path, output_file_path)

Enc.py

@@ -1,66 +1,82 @@
-import cv2 #imports opencv, make sure that you have opencv installed
-import numpy as np #imports numpy and makes it be called with np because lazy
-import os #imports os, needed for reading file size
+import cv2
+import numpy as np
+import os
 
-def create_video(output_video_path, inputf, width=1280, height=720, frame_rate=12, pix=5): #change the width and height however you like, width is the width, height is the height and pix is the bit size in pixels (you need to check if your desired height and width can be divided with pix, if not change pix or height and width)
-    with open(inputf, 'rb') as file: #declares file as the input file
+def create_video(output_video_path, inputf, width=1280, height=720, frame_rate=12, pix=5): #change the width and height however you like, pix is the size of each bit in pixels (to resist compression, 5 means each bit is 5x5)
+    with open(inputf, 'rb') as file:
         size = os.path.getsize(inputf) #gets the size of the file
-        print(size) #prints the size
-        chunk = int(width*height/(pix*pix)) #get the chunk, or in better terms how many bits a single frame can contain
+        print(size)
+        chunk = int(width*height/(pix*pix)) #get the chunk, basically how many bits a single frame can contain
         width1 = width #i could just divide height1 and width1 directly, but it breaks compatibility since i need to swap all the var names and im lazy
-        height1 = height #i could just divide height1 and width1 directly, but it breaks compatibility since i need to swap all the var names and im lazy
-        width = int(width / pix) #i could just divide height1 and width1 directly, but it breaks compatibility since i need to swap all the var names and im lazy
-        height = int(height / pix) #i could just divide height1 and width1 directly, but it breaks compatibility since i need to swap all the var names and im lazy
-        add = height * width #declares add so that basically i dont need to multiply height and width over and over when trying to add the elapsed bits
+        height1 = height
+        width = int(width / pix)
+        height = int(height / pix)
+        add = height * width
         total_bits = size * 8 #gets the total bits
-        print(total_bits) #prints the total bits amount
-        if total_bits <= chunk: #if the file fits in one frame or less, then set the bits amount to the chunk
-            total_bits = chunk #sets bit length as the chunk if previous condition is true
-            print(total_bits) #prints bit length if the condition is true, for debugging purposes (kinda useless)
+        print(total_bits)
+        if total_bits < chunk: #if the file fits in less than one frame, set the bits amount to the chunk
+            total_bits = chunk
+            print(total_bits)
         total_frames = int(np.ceil(total_bits / (width * height))) #gets the total frames amount
-        print(total_frames) #prints the total frames
+        if (size*8) % (width*height) == 0: #if the file does NOT leave a gap then it makes an empty 1st frame
+            total_frames += 1
+        print(total_frames)
         fourcc = cv2.VideoWriter_fourcc(*'png ') #codec (fourcc)
-        index = 0 #this number is totally useless except for the fact that it prints how many buts it has converted, updates each frame
-        video_writer = cv2.VideoWriter(output_video_path, fourcc, frame_rate, (width1, height1), isColor=False) #DONT SWAP WIDTH1 AND HEIGHT1, OTHERWISE OPENCV GETS REAL MAD AND IT WILL MURDER YOUR HOPES AND DREAMS BY NOT CREATING THE VIDEO (empty video file) AND TELL YOU NOTHING ABOUT WHY IT HAPPENED 
+        index = 0
+        video_writer = cv2.VideoWriter(output_video_path, fourcc, frame_rate, (width1, height1), isColor=False) #DONT SWAP WIDTH1 AND HEIGHT1, OTHERWISE OPENCV GETS REAL MAD
         m = 1 #just an indicator to check if the first frame has been done, m=1 = no, m=0 = yes
-        for _ in range(total_frames): #do the frames after the 1st
-            if m == 0: #checks if the 1st frame is done, it is important
-                frame = np.zeros((height, width), dtype=np.uint8) #create the frame
+        for _ in range(total_frames):
+            if m == 0:
+                frame = np.zeros((height, width), dtype=np.uint8)
                 content = file.read(int(chunk / 8)) #read the portion of the file needed to fill 1 frame (resulting in less ram usage), the divide by 8 is there since chunk represents of the bits that can fit in one frame, and this converts it into bytes
-                content = ''.join(format(byte, '08b') for byte in content) #converts content into a string otherwise the program will get pretty mad
+                content = ''.join(format(byte, '08b') for byte in content)
                 values = np.array([int(content[bit2]) * 255 for bit2 in range (chunk)]) #basically if it is reading a 1 it will multiply it by 255, resulting in 255 (white), otherwise it'll multiply 0 by 255 resulting in 0 (black)
-                values = values.reshape(-1) #idk what it does honestly, afaik it reshapes values into a 1d array
-                index += add #increments index by the amount of bits it has converted
-                print(f"{index} 1") #prints the bits it has converted in total, if you get the bits amount of the file and compare it with the output you can get a pseudo progress percentage
-                frame.flat = values #writes the bits to the frame right after flattening the frame into a 1d picture
+                values = values.reshape(-1) #vectoring stuff, efficiency reasons
+                index += add
+                print(f"{index} 1")
+                frame.flat = values
                 frame = frame.reshape((height, width)) #converts the frame back into 2d
-                frame = cv2.resize(frame, (width1, height1), interpolation=cv2.INTER_NEAREST) #enlargens the frame back into the original resolution, instead of writing each bit (it will take longer if i do the latter)
-                video_writer.write(frame) #writes the frame instead of caching it in ram, resulting in less ram usage
-            else: #PRETTY SMART STUFF, I SUGGEST TO NOT EDIT (except the one that declares size2, but it still works as it is tho, so maybe dont change it)
-                frame = np.zeros((height, width), dtype=np.uint8) #create the frame
-                size2 = size * 8 #converts the total bytes amount into bits, didnt want to use the other variable because uhh idk feel free to change it i did not test it
-                size3 = size2 % chunk #gets the bits it needs to write
-                temp = chunk - size3 #gets the padding bits it will write at the beginning of the 1st frame, this is basically why i split the stuff that makes the 1st frame from the others
-                print(temp)
-                content = file.read(int(size3 / 8)) #read the bits needed for the 1st frame
-                binary_data = '0' * (temp - 1) #creates the padding 0s (except for the last 0 where it is swapped for a 1, for decoding purposes)
-                binary_data += '1' #puts the 1 at the end of the padding, i made room specifically for that
-                content = ''.join(format(byte, '08b') for byte in content) #converts content into a string otherwise the program will get pretty mad
-                binary_data += content #appends at the end the data itself
-                values = np.array([int(binary_data[bit]) * 255 for bit in range(chunk)]) #basically if it is reading a 1 it will multiply it by 255, resulting in 255 (white), otherwise it'll multiply 0 by 255 resulting in 0 (black)
-                values = values.reshape(-1) #idk what it does honestly, afaik it reshapes values into a 1d array
-                index += add #increments index by the amount of bits it has converted
-                print(f"{index} 0") #prints the bits it has converted in the 1st frame
-                frame.flat = values #writes the bits to the frame right after flattening the frame into a 1d picture
-                frame = frame.reshape((height, width)) #converts the frame back into 2d
-                frame = cv2.resize(frame, (width1, height1), interpolation=cv2.INTER_NEAREST) #enlargens the frame back into the original resolution
-                video_writer.write(frame) #writes the frame instead of caching it in ram, resulting in less ram usage
-                m = 0 #changes the indicator to say that the 1st frame has been done
+                frame = cv2.resize(frame, (width1, height1), interpolation=cv2.INTER_NEAREST) #enlargens the frame back into the original resolution, instead of writing each bit, this is to resist compression
+                video_writer.write(frame)
+            else:
+                if (size*8) % (width*height) == 0: #if the file does NOT leave a gap then i'm making an empty 1st frame
+                    temp = chunk
+                    frame = np.zeros((height, width), dtype=np.uint8)
+                    binary_data = '0' * (temp - 1)
+                    binary_data += '1'
+                    print(temp)
+                    values = np.array([int(binary_data[bit]) * 255 for bit in range(chunk)])
+                    values = values.reshape(-1)
+                    frame.flat = values
+                    frame = frame.reshape((height, width))
+                    frame = cv2.resize(frame, (width1, height1), interpolation=cv2.INTER_NEAREST)
+                    video_writer.write(frame)
+                    m = 0
+                else:
+                    frame = np.zeros((height, width), dtype=np.uint8)
+                    size2 = size * 8
+                    size3 = size2 % chunk #gets the bits it needs to write
+                    temp = chunk - size3 #gets the padding bits it will write at the beginning of the 1st frame
+                    print(temp)
+                    content = file.read(int(size3 / 8)) #read the bits needed for the 1st frame
+                    binary_data = '0' * (temp - 1) #creates the padding 0s (except for the last 0 where it is swapped for a 1, for decoding purposes)
+                    binary_data += '1'
+                    content = ''.join(format(byte, '08b') for byte in content)
+                    binary_data += content
+                    values = np.array([int(binary_data[bit]) * 255 for bit in range(chunk)])
+                    values = values.reshape(-1) #vectoring stuff, efficiency reasons
+                    index += add
+                    print(f"{index} 0")
+                    frame.flat = values #writes the bits to the frame right after flattening the frame into a 1d picture
+                    frame = frame.reshape((height, width)) #converts the frame back into 2d
+                    frame = cv2.resize(frame, (width1, height1), interpolation=cv2.INTER_NEAREST) #enlargens the frame back into the original resolution, it's to resist compression
+                    video_writer.write(frame)
+                    m = 0
         video_writer.release()
 
-if __name__ == "__main__": #checks if the program has already been run
-    input_file_path = "/home/ema/Desktop/bk foot lettuce2.txt" #replace with the path to your input file
-    output_video_path = "/home/ema/Desktop/Out1.avi" #replace with the desired output video path
-    create_video(output_video_path, input_file_path) #calls create_video function
+if __name__ == "__main__":
+    input_file_path = "input.txt" #replace with the path to your input file
+    output_video_path = "output.avi" #replace with the desired output video path
+    create_video(output_video_path, input_file_path)