FFMpegExtractor.cpp

Go to the documentation of this file.

#include <FFMpegExtractor.h>
#include <utils.h>
#include <stringtricks.h>
#include <ConfigManager.h>

#include <config.h>

#include <cstring>
#include <cstdio>
#ifdef HAVE_WINDOWS
#define POPEN _popen
#define PCLOSE _pclose
#define POPEN_MODE_WRITE "wb"
#endif
#ifdef HAVE_LINUX
#define POPEN popen
#define PCLOSE pclose
#define POPEN_MODE_WRITE "w"
#endif

#include <iostream>
#include <sstream>

using namespace std;

FFMpegExtractor::FFMpegExtractor(zmq::context_t & _ctx,
                 const PubSubEndpoint & _source,
                 const std::string & _identifier,
                 const std::string & _destination) :
        Extractor(_ctx, _source),
        s_identifier(_identifier),
        destination(_destination),
        width(0),
        height(0),
        bytesPerPixel(0) {
    pix_fmt = string("bayer_bggr8");
}

FFMpegExtractor::~FFMpegExtractor() {

}

std::string FFMpegExtractor::type() {
    return "FFMpeg";
}

std::string FFMpegExtractor::identifier() {
    return s_identifier;
}

std::list<std::string> FFMpegExtractor::parameters() {
    return {destination, keepGoing?"active":"done"};
}

/****** PRIVATE *****/

void FFMpegExtractor::openStream() {
    auto cmd = SSTR(
    "/usr/bin/ffmpeg ",
    "-re ",
    "-f rawvideo ",
    "-sn -an -vcodec rawvideo -pix_fmt ", pix_fmt, " ",
    "-video_size ", width/reduction, "x", height/reduction, " ",
    "-threads 4 ",
    "-i - ",
    "-f flv ",
    destination);
    cout << cmd << endl;
    ffmpeg = POPEN(cmd.c_str(), POPEN_MODE_WRITE);
}

void FFMpegExtractor::closeStream() {
    if(ffmpeg != nullptr) {
        PCLOSE(ffmpeg);
        ffmpeg = nullptr;
    }
}

void FFMpegExtractor::handleSize(unsigned int _width, unsigned int _height, unsigned int _bytesPerPixel) {
    if((width != _width) | (height != _height) | (bytesPerPixel != _bytesPerPixel)) {
        closeStream();
        if(buffer != nullptr) {
            delete buffer;
        }
        width = _width;
        height = _height;
        bytesPerPixel = _bytesPerPixel;
        openStream();
        buffer = new unsigned char[width * height / (reduction * reduction)];
    }
}

template<typename D, unsigned int shift, unsigned int pattern_size>
void collectShift(unsigned char* target, void* source, size_t width, size_t height, unsigned int reduction=1) {
    D* d_source = reinterpret_cast<D*>(source);
    unsigned int k = 0;
    for(size_t i = 0; i < height; i+=reduction*pattern_size) {
        for(size_t ii = 0; ii < pattern_size; ++ii) {
            for(size_t j = 0; j < width; j+=reduction*pattern_size) {
                for(size_t jj = 0; jj < pattern_size; ++jj) {
                    target[k] = d_source[(i+ii)*width+(j+jj)] >> shift;
                    ++k;
                }
            }
        }
    }
}

void FFMpegExtractor::extractImpl(unsigned int _width,
                      unsigned int _height,
                      unsigned int _bytesPerPixel,
                      uint64_t highResTime,
                      uint64_t wallTime,
                      zmq::message_t * sourceImage) {
    handleSize(_width, _height, _bytesPerPixel);
    if(bytesPerPixel == 1) {
        collectShift<uint8_t, 0, 2>(buffer, sourceImage->data(), width, height, reduction);
    } else if(bytesPerPixel == 2) {
        collectShift<uint16_t, 4, 2>(buffer, sourceImage->data(), width, height, reduction);
    } else {
        throw 5;
    }

    fwrite(buffer, width/reduction, height/reduction, ffmpeg); 
    /* minimal implementation MUST delete sourceImage! */
    delete sourceImage;
}

void FFMpegExtractor::extractTeardown() {
    closeStream();
}