VideoEncoder.cpp

#include "VideoEncoder.hpp"
#include "main.hpp"
#include "Logger.hpp"
#include "Huffman.hpp"

#include <cassert>

dc::VideoEncoder::VideoEncoder(const std::string &source_file, const std::string &dest_file,
                               const uint16_t &width, const uint16_t &height, const bool &use_rle,
                               MatrixReader<> &m, const uint16_t &gop, const uint16_t &merange)
    : VideoProcessor(source_file, dest_file, width, height, use_rle, m, gop, merange)
{
    assert(this->width  % dc::BlockSize == 0);
    assert(this->height % dc::BlockSize == 0);
    assert(this->reader->get_size() % size_t(this->frame_buffer_size + this->frame_garbage_size) == 0);
}

dc::VideoEncoder::~VideoEncoder(void) {
    dc::MacroBlock::DestroyMERLUT();
}

bool dc::VideoEncoder::process(void) {
    bool success = true;

    util::Logger::WriteLn("[VideoEncoder] Processing video...");

    // Pre-process video
    success = VideoProcessor::process(this->reader->get_buffer());

    // Write setting header
    util::Logger::WriteLn("[VideoEncoder] Creating settings header...");
    size_t output_length;

    // TODO
    const uint8_t quant_bit_len = this->quant_m.getMaxBitLength();
    output_length = dc::ImageProcessor::RLE_BITS       // Bit for RLE setting
                  + dc::ImageProcessor::DIM_BITS * 2u  // 2 times bits for video dimension
                  + dc::MatrixReader<>::SIZE_LEN_BITS  // Bits to signify size of quant_matrix contents
                  + (quant_bit_len                     // Size of quantmatrix
                     * dc::BlockSize * dc::BlockSize)
                  + dc::ImageProcessor::DIM_BITS       // Amount of frames
                  + dc::ImageProcessor::DIM_BITS       // gop
                  + dc::ImageProcessor::DIM_BITS       // merange
                  ;

    util::Logger::WriteLn(std::string_format("[VideoEncoder] Settings header length: %.1f bytes.",
                                             float(output_length) / 8.f));

    output_length += this->frames->size() * this->frames->front()->streamSize();

    #ifndef ENABLE_HUFFMAN
        output_length++;    // Add one bit to signal Huffman is not enabled.
    #endif

    output_length = util::round_to_byte(output_length);  // Padding to next whole byte


    this->writer = util::allocVar<util::BitStreamWriter>(output_length);

    #ifndef ENABLE_HUFFMAN
        this->writer->put_bit(0); // '0': No Huffman sequence present.
    #endif

    // Write matrix data first
    this->quant_m.write(*this->writer);

    // Write other settings
    this->writer->put(dc::ImageProcessor::RLE_BITS, uint32_t(this->use_rle));
    this->writer->put(dc::ImageProcessor::DIM_BITS, this->width);
    this->writer->put(dc::ImageProcessor::DIM_BITS, this->height);
    this->writer->put(dc::ImageProcessor::DIM_BITS, uint32_t(this->frame_count));
    this->writer->put(dc::ImageProcessor::DIM_BITS, uint32_t(this->gop));
    this->writer->put(dc::ImageProcessor::DIM_BITS, uint32_t(this->merange));

    dc::MacroBlock::CreateMERLUT(this->merange);

    const size_t frame_count = this->frames->size();
    size_t frameid = 0u;

    util::Logger::WriteLn("[VideoEncoder] Processing Frames...");
    util::Logger::WriteProgress(0, frame_count);

    for (dc::Frame* f : *this->frames) {
        util::Logger::Pause();

        f->process();
        f->streamEncoded(*this->writer);

        util::Logger::Resume();
        util::Logger::WriteProgress(++frameid, frame_count);
    }

    util::Logger::WriteLn("", false);

    #ifdef ENABLE_HUFFMAN
        util::BitStreamReader hm_input(this->writer->get_buffer(),
                                       this->writer->get_last_byte_position());

        algo::Huffman<> hm;
        util::BitStreamWriter *hm_output = hm.encode(hm_input);

        if (hm_output != nullptr) {
            util::deallocVar(this->writer);
            this->writer = hm_output;
        }

        util::Logger::WriteLn("", false);
    #endif

    return success;
}

void dc::VideoEncoder::saveResult(void) const {
    VideoProcessor::saveResult(true);
}