video.h

#ifndef VIDEO_HEADER
#define VIDEO_HEADER

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <iomanip>
#include <string>
#include <stdexcept>
#include <set>
#include <algorithm>
#include <thread>
#include <sstream>

struct Frame {
  std::vector < unsigned char > pixels;
};

struct Video {
  int64_t numFrames;
  unsigned char channels;
  unsigned char height;
  unsigned char width;
  std::vector < Frame > frames;
  std::unique_ptr < std::ifstream > inputFile;
  std::unique_ptr < std::ofstream > outputFile;

  void checkBounds(const Frame &frame,
  const int x,
  const int y,
  const int channel) {
    if (x < 0 || x >= width ||
        y < 0 || y >= height ||
        channel < 0 || channel >= channels) {
      throw std::out_of_range("Pixel coordinates or channel out of bounds.");
    }
    if (frame.pixels.size() != static_cast<size_t>(width * height * channels)) {
      throw std::runtime_error("Frame pixel size mismatch.");
    }
  }

  unsigned char getPixelValue(
    const Frame &frame,
    const int x,
    const int y,
    const int channel) {
    checkBounds(frame, x, y, channel);
    return frame.pixels[((y * width) + x) + ((height * width) * channel)];
  }

  int64_t getPixelPosition(
    const Frame &frame,
    const int x,
    const int y,
    const int channel) {
    checkBounds(frame, x, y, channel);
    return ((y * width) + x) + ((height * width) * channel);
  }

  void writePixel(
    const unsigned char value,
    Frame &frame,
    const int x,
    const int y,
    const int channel) {
    checkBounds(frame, x, y, channel);
    frame.pixels[((y * width) + x) + ((height * width) * channel)] = value;
  }

  size_t getFrameSize() {
    return (height) * width * channels;
  }

  size_t getHeaderOffset() {
    return
    (sizeof(numFrames) + sizeof(channels) + sizeof(height) + sizeof(width));
  }
};

// Video Decoder Functions
bool readVideoFromFile(
  Video & video,
  const std::string & inputFilePath,
  const std::string & optimisationFlag);
Frame readFrameFromFile(
  Video & video,
  const int64_t & frameIndex);

// Video Encoder Functions
bool setUpOutputStream(Video & video, const std::string & outputFilePath);
bool writeVideoToFile(Video & video);
bool writeHeaderToFile(Video & video);
bool writeFrameToFile(Video & video, const Frame & frame);

#endif