apps/astreamer/video.cpp

Go to the documentation of this file.

#include "video.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>

#include <asm/elphel/c313a.h>
#include <asm/elphel/hist.h>
#include <asm/elphel/ext353.h>

#include <iostream>
#include "streamer.h"
using namespace std;

//Video *video = NULL;

#define QTABLES_INCLUDE

int fd_stream = 0;
int fd_circbuf = 0;

Video::Video(void) {
        stream_name = "video";
        for(int c = 0; c < 20; c++)
                if((fd_stream = open("/dev/stream", O_RDWR)) < 0)
                        usleep(50000);
                else
                        break;
        if(fd_stream < 0)
                throw("can't open /dev/stream");
        fd_circbuf = open("/dev/circbuf", O_RDONLY);
        if(fd_circbuf < 0)
                throw("can't open /dev/circbuf");
//      fd_ctl = open();
        fd_ctl = fd_circbuf;
//      fd_ctl = open("/dev/circbuf", O_RDWR);
//      if(fd_ctl < 0)
//              throw("can't open /dev/circbuf");
        fd_ioctl = open("/dev/sensorpars", O_RDWR);
        if(fd_ioctl < 0)
                throw("can't open /dev/sensorpars");

        _fd = fd_stream;

        qtables_include = true;

        SSRC = 12;
        _ptype = 26;
        rtp_socket = NULL;
        rtcp_socket = NULL;
        _play = false;
        prev_jpeg_wp = 0;
        buffer_length = 0;
        f_quality = -1;
        
        // create thread...
        init_pthread((void *)this);
}

Video::~Video(void) {
        if(fd_ioctl > 0)
                close(fd_ioctl);
        if(fd_circbuf > 0)
                close(fd_circbuf);
        if(fd_stream > 0)
                close(fd_stream);
}

void Video::Start(string ip, long port) {
        if(_play)
                return;
        // statistic
        v_t_sec = 0;
        v_t_usec = 0;
        v_frames = 0;
        // ----
        if(buffer_length == 0)
                buffer_length = lseek(fd_ctl, 0, 2);
        buffer_ptr = (unsigned long *)mmap(0, buffer_length, PROT_READ, MAP_SHARED, fd_circbuf, 0);
        buffer_ptr_s = (unsigned long *)mmap(buffer_ptr + (buffer_length / 4), buffer_length, PROT_READ, MAP_FIXED | MAP_SHARED, fd_circbuf, 0);
//char b[256];
//sprintf(b, "0x%08X, 0x%08X", buffer_ptr, buffer_ptr_s);
//cerr << b << endl;
        // create udp socket
        f_width = width();
        f_height = height();
        // start compressor...
        int status = ioctl(fd_ioctl, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_SEQ), 0);
//      if(status == CAMSEQ_RUN || status == CAMSEQ_SINGLE)
//              ioctl(fd_ioctl, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_STOP);
        if(status != CAMSEQ_RUN)
                ioctl(fd_ioctl, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_START);
        RTP_Stream::Start(ip, port);
}

void Video::Stop(void) {
        if(!_play)
                return;
        RTP_Stream::Stop();
        // destroy udp socket
        prev_jpeg_wp = 0;
        munmap(buffer_ptr_s, buffer_length);
        munmap(buffer_ptr, buffer_length);
}

int Video::width(void) {
        return ioctl(fd_ioctl, _CCCMD(CCAM_RPARS, P_ACTUAL_WIDTH), 0);
}

int Video::height(void) {
        return ioctl(fd_ioctl, _CCCMD(CCAM_RPARS, P_ACTUAL_HEIGHT), 0);
}

int Video::quality(void) {
        return ioctl(fd_ioctl, _CCCMD(CCAM_RPARS, P_QUALITY), 0);
}

float Video::fps(void) {
        float fps = ioctl(fd_ioctl, _CCCMD(CCAM_RPARS, P_FP100S), 0);
        fps *= 0.01;
        return fps;
}

void Video::fps(float fps) {
        if(fps > 0.01)
                ioctl(fd_stream, _IO(IOC_STREAM_SET_FPS, 0x00), int(fps * 100.0));
}

long Video::capture(void) {
        long frame_len;
        long len;

        int quality;
        unsigned long last_ptr;
        last_ptr = lseek(fd_circbuf, CIRCLSEEK_TOWP, SEEK_END);
        lseek(fd_circbuf, CIRCLSEEK_WAIT, SEEK_END);
        frame_ptr = (char *)((unsigned long)buffer_ptr + last_ptr);
        if(last_ptr < 32)
                last_ptr += buffer_length;
        last_ptr >>= 2;
        frame_len = buffer_ptr[last_ptr - 1];
        // read timestamp
        char *ts_ptr = (char *)((unsigned long)frame_ptr + (long)(((frame_len + CCAM_MMAP_META + 3) & (~0x1f)) + 32 - CCAM_MMAP_META_SEC));
        unsigned long t[2];
        memcpy(&t, (void *)ts_ptr, 8);
        f_tv.tv_sec = t[0];
        f_tv.tv_usec = t[1];
        // read Q value
        char *meta = (char *)frame_ptr;
        meta -= 32;
        if(meta < (char *)buffer_ptr)
                meta += buffer_length;
        struct frame_params_t *fp = (struct frame_params_t *)meta;
        quality = fp->quality;
        if(qtables_include && quality != f_quality) {
                ioctl(fd_stream, _IO(IOC_STREAM_GET_QTABLES, (unsigned char)quality), (void *)&qtable[0]);
//cerr << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> update tables..." << endl;
        }
        f_quality = quality;
        // check statistic
        if(Streamer::instance()->opt_present("d")) {
                if(v_t_sec == 0) {
                        v_frames = 0;
                        v_t_sec = f_tv.tv_sec;
                        v_t_usec = f_tv.tv_usec;
                }
                long t = f_tv.tv_sec - v_t_sec;
                t *= 1000000;
                t += f_tv.tv_usec;
                t -= v_t_usec;
                if(t >= 1000000) {
                        float fps = v_frames * 1000000;
                        fps /= t;
                        char buf[128];
                        float Tframe = 1.0 / fps;
                        Tframe *= 96000000.0;
//                      Tframe *= 48000000.0;
                        sprintf(buf, "fps == %3.6f, frames == %d, time == %d; Tframe == %.1f clk, ts: %d:%d", fps, v_frames, (int) t, Tframe, f_tv.tv_sec, f_tv.tv_usec);
                        cerr << buf; 
                        v_t_sec = 0;
                        unsigned long t[4];
                        ioctl(fd_stream, _IO(IOC_STREAM_GET_TIME, 0x00), (void *)&t[0]);
                        sprintf(buf, "; sys time == %d:%06d; FPGA time == %d:%06d", t[0], t[1], t[2], t[3]);
                        cerr << buf << endl;
                        long long ts, tf, d;
                        ts = t[0];
                        ts <<= 32;
                        ts += t[1];
                        tf = t[2];
                        tf <<= 32;
                        tf += t[3];
                        if(ts > tf)
                                d = ts - tf;
                        else
                                d = tf - ts;
                        unsigned long t_usec = d & 0xFFFFFFFF;
                        d >>= 32;
                        unsigned long t_sec = d & 0xFFFFFFFF;
                        cerr << "delta time: " << t_sec << ":" << t_usec << endl;
                }
                v_frames++;
        }
        return frame_len;       
}

bool Video::process(void) {
        int _plen = 1400;
        int to_send = _plen;
        int _qtables_len = 128 + 4;
        long frame_len = capture();
        if(frame_len <= 0)
                return false;

        int to_send_len = frame_len;
        unsigned char h[20 + 4];
        int packet_len = 0;
        unsigned char *data = (unsigned char *)frame_ptr;

        float f = f_tv.tv_usec;
        f /= 1000000;
        f += (f_tv.tv_sec & 0x7FFF); // use a mask to cut an odd part of seconds to prevent overflow of "float" type
        f *= 90000;
        timestamp = (unsigned long)f;
        unsigned long ts = htonl(timestamp);

        long offset = 0;
        void *v_ptr[4];
        int v_len[4] = {0, 0, 0, 0};
        bool first = true;
        while(to_send_len && _play) {
                unsigned long pnum = htons(packet_num);
                bool last = false;
                to_send = _plen;
                if(qtables_include && first)
                        to_send = _plen - _qtables_len;
                if(to_send_len <= to_send) {
                        packet_len = to_send_len;
                        to_send_len = 0;
                        last = true;
                } else {
                        packet_len = to_send;
                        to_send_len -= to_send;
                }
                // make RTP packet
                h[0] = 0x80;
                if(!last)
                        h[1] = _ptype;
                else
                        h[1] = 0x80 + _ptype;
                memcpy((void *)&h[2], (void *)&pnum, 2);
                memcpy((void *)&h[4], (void *)&ts, 4);
                memcpy((void *)&h[8], (void *)&SSRC, 4);
                // make MJPEG header
                unsigned long off = htonl(offset);
                memcpy((void *)&h[12], (void *)&off, 4);
                h[12] = 0x00;
                h[16] = 0x01;
                unsigned int q = f_quality;
                if(qtables_include)
                        q += 128;
                h[17] = (unsigned char)(q & 0xFF);
                if(f_width <= 2040)
                        h[18] = (f_width / 8) & 0xFF;
                else
                        h[18] = 0;
                if(f_height <= 2040)
                        h[19] = (f_height / 8) & 0xFF;
                else
                        h[19] = 0;
                h[20] = 0;
                h[21] = 0;
                unsigned short l = htons(128);
                memcpy((void *)&h[22], (void *)&l, 2);
                // update RTCP statistic
                rtp_packets++;
                rtp_octets += packet_len + 8; // data + MJPEG header
                // send vector
                if(first) {
                        v_ptr[0] = h;
                        if(qtables_include) {
                                v_len[0] = 24;
                                v_ptr[1] = qtable;
                                v_len[1] = 128;
                                v_ptr[2] = data;
                                v_len[2] = packet_len;
                                rtp_socket->send3v(&v_ptr[0], &v_len[0]);
                        } else {
                                v_len[0] = 20;
                                v_ptr[1] = data;
                                v_len[1] = packet_len;
                                rtp_socket->send2v(&v_ptr[0], &v_len[0]);
                        }
                        first = false;
                } else {
                        v_ptr[0] = h;
                        v_len[0] = 20;
                        v_ptr[1] = data;
                        v_len[1] = packet_len;
                        rtp_socket->send2v(&v_ptr[0], &v_len[0]);
                }
                // --==--
                packet_num++;
                data += packet_len;
                offset += packet_len;
        }
        return true;
}

---