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;

#undef VIDEO_DEBUG
//#define VIDEO_DEBUG

#ifdef VIDEO_DEBUG
        #define D(a) a
#else
        #define D(a)
#endif

//Video *video = NULL;

#define QTABLES_INCLUDE

int fd_stream =   0;
int fd_circbuf =  0;
int fd_jpeghead = 0; 
int fd_fparmsall =   0;
int lastDaemonBit= DAEMON_BIT_STREAMER;


struct framepars_all_t   *frameParsAll;
struct framepars_t       *framePars;
unsigned long            *globalPars; 


Video::Video(void) {
D(cerr << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << endl;)
        stream_name = "video";
        fd_fparmsall = open("/dev/frameparsall", O_RDWR);
        if(fd_fparmsall < 0)
           throw("can't open /dev/frameparsall");
        frameParsAll = (struct framepars_all_t *) mmap(0, sizeof (struct framepars_all_t) , PROT_READ, MAP_SHARED, fd_fparmsall, 0);
        if((int)frameParsAll == -1)
          throw("Error in mmap /dev/frameparsall");
        framePars=frameParsAll->framePars;
        globalPars=frameParsAll->globalPars;
        waitDaemonEnabled(-1); 
        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");
        buffer_length = lseek(fd_circbuf, 0, SEEK_END);
        buffer_ptr = (unsigned long *)mmap(0, buffer_length, PROT_READ, MAP_SHARED, fd_circbuf, 0);
        if((int)buffer_ptr == -1)
           throw("Error in mmap /dev/circbuf");
        buffer_ptr_s = (unsigned long *)mmap(buffer_ptr + (buffer_length >>2 ), buffer_length, PROT_READ, MAP_FIXED | MAP_SHARED, fd_circbuf, 0);   
        if((int)buffer_ptr_s == -1)
           throw("Error in second mmap /dev/circbuf");
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << " frame=" <<GLOBALPARS(G_THIS_FRAME)<< " buffer_length=" << buffer_length <<endl;)
        while  (GLOBALPARS(G_THIS_FRAME) < 10) {
          lseek(fd_circbuf,LSEEK_CIRC_TOWP,SEEK_END); 
          lseek(fd_circbuf,LSEEK_CIRC_WAIT,SEEK_END); 
        }
        lseek(fd_circbuf,LSEEK_CIRC_WAIT,SEEK_END);
        lseek(fd_circbuf,LSEEK_CIRC_WAIT,SEEK_END);
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << " frame=" <<GLOBALPARS(G_THIS_FRAME)<< " buffer_length=" << buffer_length <<endl;)
        fd_jpeghead = open("/dev/jpeghead", O_RDWR);
        if(fd_jpeghead < 0)
           throw("can't open /dev/jpeghead");
        _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);
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << endl;)

}

Video::~Video(void) {
        if(fd_circbuf > 0)
                close(fd_circbuf);
        if(fd_stream > 0)
                close(fd_stream);
        if(fd_jpeghead >0)
                close (fd_jpeghead);
        if(fd_fparmsall >0)
                close (fd_fparmsall);

}
#define TURN_COMPRESSOR_ON 0
void Video::Start(string ip, long port) {
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << "_play=" << _play << endl;)

        if(_play) return; 
        // statistic
        v_t_sec = 0;
        v_t_usec = 0;
        v_frames = 0;
        // create udp socket
        f_width = width();
        f_height = height();
#if TURN_COMPRESSOR_ON
        unsigned long write_data[4];
        write_data[0]=FRAMEPARS_SETFRAME;
        write_data[1]=GLOBALPARS(G_THIS_FRAME)+1;
        write_data[2]=P_COMPRESSOR_RUN;
        write_data[3]=COMPRESSOR_RUN_CONT;
        write(fd_fparmsall, write_data, sizeof(write_data));
#endif
        RTP_Stream::Start(ip, port);
}

void Video::Stop(void) {
        if(!_play)
                return;
        RTP_Stream::Stop();
        _play=false;
        // destroy udp socket
        prev_jpeg_wp = 0;
}


unsigned long Video::getGPValue(unsigned long GPNumber) {
   return (GPNumber>=FRAMEPAR_GLOBALS)?
              GLOBALPARS(GPNumber):
              framePars[GLOBALPARS(G_THIS_FRAME) & PARS_FRAMES_MASK].pars[GPNumber];
}

void Video::setGValue(unsigned long  GNumber,   unsigned long value) {
    GLOBALPARS(GNumber)=value;
}

bool  Video::waitDaemonEnabled(int daemonBit) { // <0 - use default
   if ((daemonBit>=0) && (daemonBit<32)) lastDaemonBit=daemonBit;
   unsigned long this_frame=this_frame=GLOBALPARS(G_THIS_FRAME);
  D(cerr << " lseek(fd_circbuf, LSEEK_DAEMON_CIRCBUF+lastDaemonBit, SEEK_END)... " << endl;)
   lseek(fd_circbuf, LSEEK_DAEMON_CIRCBUF+lastDaemonBit, SEEK_END); 
  D(cerr << "...done" << endl;)
   
   if (this_frame==GLOBALPARS(G_THIS_FRAME)) return true;
   return false;
}

bool  Video::isDaemonEnabled(int daemonBit) { // <0 - use default
   if ((daemonBit>=0) && (daemonBit<32)) lastDaemonBit=daemonBit;
   return ((framePars[GLOBALPARS(G_THIS_FRAME) & PARS_FRAMES_MASK].pars[P_DAEMON_EN] & (1 <<lastDaemonBit))!=0);
}


long Video::getFramePars(struct interframe_params_t * frame_pars, long before) {
   long cur_pointer,p;
   long this_pointer=lseek(fd_circbuf,0,SEEK_CUR); 
   char * char_buffer_ptr = (char *) buffer_ptr;
   if (lseek(fd_circbuf,LSEEK_CIRC_VALID,SEEK_END) < 0 ) { 
     this_pointer=lseek(fd_circbuf,LSEEK_CIRC_LAST,SEEK_END);    
   }
   cur_pointer=this_pointer;
   if (!before) lseek(fd_circbuf,LSEEK_CIRC_WAIT,SEEK_END);
   while (before && (((p=lseek(fd_circbuf,LSEEK_CIRC_PREV,SEEK_END)))>=0)) { 
     cur_pointer=p;
     before--;
   }
   while (before>0) {
     lseek(fd_circbuf, this_pointer, SEEK_SET);
     lseek(fd_circbuf,LSEEK_CIRC_WAIT,SEEK_END);
     this_pointer=lseek(fd_circbuf,LSEEK_CIRC_NEXT,SEEK_END);
     before--;
   }
   long metadata_start=cur_pointer-32;
   if (metadata_start<0) metadata_start+=buffer_length;
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << " before=" << before << " metadata_start=" << metadata_start << endl;)

   memcpy (frame_pars, &char_buffer_ptr[metadata_start],32);
   long jpeg_len=frame_pars->frame_length; 
   if (frame_pars->signffff !=0xffff) {
     cerr << "Wrong signature in getFramePars() (broken frame)\n" << endl;
     return -1;
   }
   long timestamp_start=(cur_pointer)+((jpeg_len+CCAM_MMAP_META+3) & (~0x1f)) + 32 - CCAM_MMAP_META_SEC; 
   if (timestamp_start >= buffer_length) timestamp_start-= buffer_length;
   memcpy (&(frame_pars->timestamp_sec), &char_buffer_ptr[timestamp_start],8);
   lseek(fd_circbuf, this_pointer, SEEK_SET); 
//D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << " this_pointer=" << this_pointer << " cur_pointer=" << cur_pointer << endl;)
   return cur_pointer;

}


#define FRAMEPARS_BEFORE 0 
int Video::width(void) {
    struct interframe_params_t frame_pars;
    if (getFramePars(&frame_pars, FRAMEPARS_BEFORE) < 0) return -1; 
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << " frame_pars.width=" << frame_pars.width << endl;)
    used_width=frame_pars.width;
    return frame_pars.width;
}

int Video::height(void) {
    struct interframe_params_t frame_pars;
    if (getFramePars(&frame_pars, FRAMEPARS_BEFORE) < 0) return -1; 
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << " frame_pars.height=" << frame_pars.height << endl;)
    used_height=frame_pars.height;
    return frame_pars.height;
}

int Video::quality(void) {
    struct interframe_params_t frame_pars;
    if (getFramePars(&frame_pars, FRAMEPARS_BEFORE) < 0) return -1; 
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << " frame_pars.quality2=" << frame_pars.quality2 << endl;)
    return frame_pars.quality2;
}

float Video::fps(void) {
    struct interframe_params_t frame_pars,prev_pars;
    if ((getFramePars(&frame_pars, FRAMEPARS_BEFORE) < 0) ||
        (getFramePars(&prev_pars,  FRAMEPARS_BEFORE+1) < 0))  return -1; 



    float fps = ((frame_pars.timestamp_sec-prev_pars.timestamp_sec)*1000000)+frame_pars.timestamp_usec-prev_pars.timestamp_usec;
    fps=1000000/fps;
D(cerr  << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__ << " fps=" << fps << endl;)
    used_fps=fps;
    return fps;
}
//#define FRAMES_AHEAD_FPS 3 /// number of frames ahead of current to frite FPS limit
//#define FRAMES_SKIP_FPS  3 /// number of frames to wait after target so circbuf will have at least 2 frames with new fps for calculation
void Video::fps(float fps) {
    if(fps < 0.01) return;

    unsigned long write_data[6];
    long target_frame=GLOBALPARS(G_THIS_FRAME)+FRAMES_AHEAD_FPS;
    write_data[0]=FRAMEPARS_SETFRAME;
    write_data[1]=target_frame; 
    write_data[2]=P_FP1000SLIM;
    write_data[3]=(unsigned long) fps*1000;
    write_data[4]=P_FPSFLAGS;
    write_data[5]=3;
    long rslt=write(fd_fparmsall, write_data, sizeof(write_data));
    if (rslt==sizeof(write_data)) { 
      lseek(fd_fparmsall,LSEEK_FRAME_WAIT_ABS+target_frame+FRAMES_SKIP_FPS, SEEK_END); 
    }
}
#define USE_REAL_OLD_TIMESTAMP 0
long Video::capture(void) {
        long frame_len;
struct interframe_params_t frame_pars;
//      long len;

        int quality;
        unsigned long latestAvailableFrame_ptr;
        unsigned long frameStartByteIndex;
        int before;
        if ((framePars[GLOBALPARS(G_THIS_FRAME) & PARS_FRAMES_MASK].pars[P_DAEMON_EN] & (1 <<lastDaemonBit))==0) {
            return -DAEMON_DISABLED;  
        }
        frameStartByteIndex = lseek(fd_circbuf, LSEEK_CIRC_TOWP, SEEK_END);  
        latestAvailableFrame_ptr=frameStartByteIndex;
        lseek(fd_circbuf, LSEEK_CIRC_WAIT, SEEK_END);

        frame_ptr = (char *)((unsigned long)buffer_ptr + latestAvailableFrame_ptr);
        if(latestAvailableFrame_ptr < 32)
                latestAvailableFrame_ptr += buffer_length;
        latestAvailableFrame_ptr >>= 2;
        frame_len = buffer_ptr[latestAvailableFrame_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 interframe_params_t *fp = (struct interframe_params_t *)meta;
        if ((fp->width!=used_width) || (fp->height!=used_height)) {
           for (before=1; before <= (int) getGPValue(G_SKIP_DIFF_FRAME);before++) {
               if (((frameStartByteIndex=getFramePars(&frame_pars, before))) &&
                  (frame_pars.width==used_width) && (frame_pars.height==used_height)) {
                  latestAvailableFrame_ptr=frameStartByteIndex;
                  frame_ptr = (char *)((unsigned long)buffer_ptr + latestAvailableFrame_ptr);
                  if(latestAvailableFrame_ptr < 32)
                  latestAvailableFrame_ptr += buffer_length;
                  latestAvailableFrame_ptr >>= 2;
                  frame_len = buffer_ptr[latestAvailableFrame_ptr - 1];
#if USE_REAL_OLD_TIMESTAMP
                  ts_ptr = (char *)((unsigned long)frame_ptr + (long)(((frame_len + CCAM_MMAP_META + 3) & (~0x1f)) + 32 - CCAM_MMAP_META_SEC));
                  memcpy(&t, (void *)ts_ptr, 8);
                  f_tv.tv_sec = t[0];
                  f_tv.tv_usec = t[1];
#endif
                  char *meta = (char *)frame_ptr;
                  meta -= 32;
                  if(meta < (char *)buffer_ptr) meta += buffer_length;
                  fp = (struct interframe_params_t *)meta;
                  break;
               }
           }
           if (before > (int) getGPValue(G_SKIP_DIFF_FRAME)) {
D(      cerr << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__<< " Killing stream because of frame size change " << endl;)
             return -SIZE_CHANGE; 
           }
D(      cerr << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__<< " Waiting for the original frame size to be restored , using " << before << " frames ago" << endl;)
        }
        quality = fp->quality2;
        if(qtables_include && quality != f_quality) {
D(      cerr << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__<< " Updating quality tables, new quality is " << quality << endl;)
          lseek(fd_jpeghead, frameStartByteIndex | 2, SEEK_END); 
          read (fd_jpeghead, (void *)&qtable[0], 128);
        }
        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, (int)f_tv.tv_sec, (int)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 == %ld:%06ld; FPGA time == %ld:%06ld", 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;       
}

long Video::process(void) {
//D(        cerr << "< ";)
        int _plen = 1400;
        int to_send = _plen;
        int _qtables_len = 128 + 4;
        long frame_len = capture();
        if(frame_len == 0) {
//D(           cerr << "[";)
//              return false;
                return 0; 
        } else  if(frame_len <0) {
D(      cerr << __FILE__<< ":"<< __FUNCTION__ << ":" <<__LINE__<< "capture returned negative" << frame_len << endl;)
//              return false;
                return frame_len; 
        }

        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;
        }
//D(        cerr << "]";)
//      return true;
        return 1;
}

---