apps/streamer/str.c

Go to the documentation of this file.

/*
 * The main function of the streamer for Elphel 313 cameras
 * (C) Elphel, Inc
 * 2004 Alexander Melichenko <alexlp@freemail.ru>
 * 2007 Mykhailo Malyshko aka Spectr
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <getopt.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <limits.h>
#include <math.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sched.h>
#include <errno.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netpacket/packet.h>
#include <net/ethernet.h>

#include "str.h"
#include "net_udp.h"
#include "rtp.h"
#include <asm/elphel/c313a.h>
#include <asm/elphel/hist.h>
#include "event.h"
#include "rtsp.h"

#define RTP_PAYLOAD_SIZE        1460    /* MTU - IP - UDP - RTP  ---> 1500 - 20 - 8 - 12 */
#define JPEG_RTP_HDR_SIZE       8

#define MMAP_METHOD             1
#define READ_METHOD             2

#define SDP_FILE                "/var/html/session.sdp"
#define SESSION_DESCR           "Elphel camera 353"

#define PROGR_PARAM             1
#define DEFAULT_DEST_IP         "232.1.1.1"
#define DEFAULT_DEST_PORT       20020
#define DEFAULT_RTSP_PORT       554
#define DEFAULT_TTL             2
#define DEFAULT_REFRESH_INTERVAL 5

#define RTSP_ON_TAG             10
#define RTSP_OFF_TAG            11
#define RTSP_LISTEN_PORT_TAG    12
#define RTSP_USE_OPT_ADDR_TAG   13
#define RTSP_USE_OPT_PORT_TAG   14
#define RTSP_QT_COMPAT_TAG      15

#define FRESH_FILE              "/var/html/fresh.jpeg"
#define HDR_SIZE                623
#define TMP_BUF_OFFS            0xfe000
#define YUV420                  1
#define MAX_JPEG_BUF            2000000
#define HZ                      10000

#define NO_IOCTLS_IN_CIRCBUF y
int8_t version[] = "1.7";

static int8_t *header =
    "RTP/JPEG streamer for Elphel 333/353 camera\n"
    "Version %s\n"
        " (C) Elphel, Inc\n"
        " 2004 Alexander Melichenko <alexlp@freemail.ru>\n"
        " 2007 Mykhailo Malyshko aka Spectr\n"
        "\n";


const uint64_t TimestampTicks = 1000000;
int32_t fd;
int32_t ioctl_fd;


inline uint64_t GetTimestamp(uint32_t tv_sec, uint32_t tv_usec) {
        return ((uint64_t) tv_sec * TimestampTicks) + tv_usec;
}

inline uint32_t ts2rtp(struct param * p, uint64_t t) {
        if(p->start_timestamp) {
                return (uint32_t) (((t - p->start_timestamp) * p->vbitrt) / TimestampTicks);
        }
        p->start_timestamp = t;
        return 0;
}

/* write_sdp()
 * Form a SDP content and save it to an array and/or a file
 *      sdp  - array
 *      save - if 1 then create sdp file
 */
int8_t write_sdp(struct param * p, int save, int8_t *sdp) {
    FILE *f = NULL;
    struct timeval tv;
    uint64_t session_id, version;
    int8_t var[256];
    int32_t count;
    int32_t port;
    int8_t  *dst, dst_d[]="0.0.0.0";
    double fps = 0;
        int w, h;
    
        /* get and skip first frame... */
    fps = 0.01 * ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, P_FP100S), 0);
        w = ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, P_ACTUAL_WIDTH), 0);
        h = ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, P_ACTUAL_HEIGHT), 0);
    
    if(save){
        f = fopen(SDP_FILE, "w");
        if (!f) {
            fprintf(stderr, "SDP file creating error!");
            return -1;
        }
    }
    
    count = 0;
    memset(var, 0, 256);
    sprintf(var, "v=0\n");
    strcpy(sdp+count, var);
    count += strlen(var);
    
    gettimeofday(&tv, NULL);
    session_id = (uint64_t) tv.tv_sec * 1000000 + tv.tv_usec;
    gettimeofday(&tv, NULL);
    version = (uint64_t) tv.tv_sec * 1000000 + tv.tv_usec;

    memset(var, 0, 256);
    sprintf(var, "o=- %lld %lld IN IP4 %s\n", session_id, version, p->src);
    strcpy(sdp+count, var);
    count += strlen(var);
    
    if(p->rtsp && !p->rtsp_use_cmd_port && str_count < 1){
        port = 0;
    } else {
        port = p->dport;
    }
    
    if(p->rtsp && !p->rtsp_use_cmd_addr && str_count < 1){
        dst = dst_d;
    } else {
                dst = p->dst;
    }
    
    memset(var, 0, 256);
    sprintf(var, "s=%s\n"
                 "m=video %d RTP/AVP %d\n"
                 "c=IN IP4 %s", SESSION_DESCR, port, 
                                JPEG_PAYLOAD_NUM, dst);
    strcpy(sdp+count, var);
    count += strlen(var);

    if (ismulticast(p) && (p->rtsp && p->rtsp_use_cmd_addr)){
        memset(var, 0, 256);
        sprintf(var, "/%d", p->ttl);
        strcpy(sdp+count, var);
        count += strlen(var);
    }

    memset(var, 0, 256);
    sprintf(var, "\n");
    strcpy(sdp+count, var);
    count += strlen(var);

    if(p->rtsp){
        memset(var, 0, 256);
        sprintf(var, "a=control:rtsp://%s:%d\na=control:track1\n", 
            p->src, p->rtsp_port);
        strcpy(sdp+count, var);
        count += strlen(var);
    }
    
    if((p->fps_soft > 0) && (p->fps_soft <= p->fps)){
        fps = (double) p->fps_soft;
    }

    memset(var, 0, 256);
    sprintf(var, "a=x-framerate:%.2f\n", fps);
    strcpy(sdp+count, var);
    count += strlen(var);
    
    memset(var, 0, 256);
    sprintf(var, "a=framerate:%.2f\n", fps);
    strcpy(sdp+count, var);
    count += strlen(var);

        /* add width... */
//      if(w > 2040) {
                memset(var, 0, 256);
                sprintf(var, "a=x-width:%d\n", w);
                strcpy(sdp+count, var);
                count += strlen(var);
                memset(var, 0, 256);
                sprintf(var, "a=width:%d\n", w);
                strcpy(sdp+count, var);
                count += strlen(var);
//      }
        /* add height... */
//      if(h > 2040) {
                memset(var, 0, 256);
                sprintf(var, "a=x-height:%d\n", h);
                strcpy(sdp+count, var);
                count += strlen(var);
                memset(var, 0, 256);
                sprintf(var, "a=height:%d\n", h);
                strcpy(sdp+count, var);
                count += strlen(var);

                memset(var, 0, 256);
                sprintf(var, "a=x-dimensions:%d,%d\n", w, h);
                strcpy(sdp+count, var);
                count += strlen(var);
//      }

    sdp[count] = 0;
    
    if(save){
        fprintf(f, "%s", sdp);
        fclose(f);
        fflush(NULL);
    }

    return 0;
}

void session_finish(struct param *p) {
        rtp_done(p);
        fprintf(stderr, "\nSession %#x finished...\n", p->my_ssrc);
}

int32_t jpeg_session_start(struct param *p) {
    int32_t q = ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, P_QUALITY), 0);
    int32_t ism = 0;
    int32_t res;

        p->payload_num = JPEG_PAYLOAD_NUM;
        p->start_timestamp = 0;

        res = rtp_init(p);
        if(res != 0) {
                fprintf(stderr, "Couldn't start rtp session\n");
                return -1;
        }

        ism = ismulticast(p);
        fprintf(stderr, header, version);
        if(p->rtsp) {
                fprintf(stderr, "\tRTSP server is listening on the port %d.\n", p->rtsp_port);
                if(!p->rtsp_use_cmd_addr) {
                        fprintf(stderr, "\tDestination address will got from rtsp request.\n");
                }
                if(!p->rtsp_use_cmd_port) {
                        fprintf(stderr, "\tDestination port will got from rtsp request.\n");
                } 
                fprintf(stderr, "\n\tStream is accessible by uri rtsp://%s:%d\n", p->src, p->rtsp_port);
        }

        fprintf(stderr, "\nSession %#x started...\n", p->my_ssrc);

        if(p->web > 0) {
                fprintf(stderr, "\tWeb camera mode enabled. Refresh time - %d second\n", p->web);
        }
        if(p->meth == READ_METHOD) {
                fprintf(stderr, "\tAccess method READ\n");
        } else {
                fprintf(stderr, "\tAccess method MMAP\n");
        }
        if(p->zero) {
                fprintf(stderr, "\tVideo streaming disabled\n");
                fprintf(stderr,
                        "\twidth     = %d\n"
                        "\theight    = %d\n"
                        "\tquality   = %d\n"
                        "\tFPS       = %.2f\n", p->width, p->height, q, p->fps);
                return 0;
        }
        fprintf(stderr, "\tmode       = ");
        if(ism)
                fprintf(stderr, "multicast  ");
        else
                fprintf(stderr, "unicast    ");
        if(p->raw)
                fprintf(stderr, "by-passing UDP/IP stack\n");
        else
                fprintf(stderr, "using UDP/IP stack\n");
        fprintf(stderr, "\tdest_addr  = %s\n", p->dst);
        if(ism)
                fprintf(stderr, "\tttl        = %d\n", p->ttl);
                fprintf(stderr,
                        "\tdest_port  = %d\n"
                        "\twidth      = %d\n"
                        "\theight     = %d\n"
                        "\tquality    = %d\n"
                        "\tSystem FPS = %.2f\n"
                        "\tSoft FPS   = %d\n",
                        p->dport, p->width, p->height, q, p->fps, p->fps_soft);


        if(p->raw) {
                if(p->fd_raw == 0)
                        p->fd_raw = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));

                struct sockaddr_in s_in;

                memset(&p->s_ll, 0, sizeof(p->s_ll));
        
                p->s_ll.sll_family   = AF_PACKET;
                p->s_ll.sll_protocol = htons(ETH_P_IP);
                p->s_ll.sll_ifindex  = p->eth_index;
                p->s_ll.sll_halen    = ETH_ALEN;   // MAC

                if(ismulticast(p)){
                        // Generate multicast ethernet address
                        memcpy(p->s_ll.sll_addr, "\x01\x00\x5e", 3);
                        unsigned char a[3];
                        unsigned int _a;
                        _a = inet_addr(p->dst);
                        a[0] = (_a >> 8) & 0x7F;
                        a[1] = (_a >> 16) & 0xFF;
                        a[2] = (_a >> 24) & 0xFF;
                        memcpy(p->s_ll.sll_addr + 3, a, 3);
                        // set multicast option for socket
                        struct ip_mreqn multiaddr;
                        multiaddr.imr_multiaddr.s_addr = inet_addr(p->dst);
                        multiaddr.imr_address.s_addr = htonl(INADDR_ANY);
                        multiaddr.imr_ifindex = 0;
                        setsockopt(p->fd_raw, IPPROTO_IP, IP_ADD_MEMBERSHIP, &multiaddr, sizeof(struct sockaddr_in));
                } else {
                        memcpy(p->s_ll.sll_addr, p->dst_mac, 6);
                }

                p->msg.msg_control = 0;
                p->msg.msg_flags = 0;
                p->msg.msg_name = (void *)&p->s_ll;
                p->msg.msg_namelen = sizeof(p->s_ll);
//unsigned char *ptr = (unsigned char *)(&p->s_ll.sll_addr);
//fprintf(stderr, "MAC: %02X%02X%02X%02X%02X%02X \n", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);

        } else {
                if(p->fd_udp == 0)
                        p->fd_udp = socket(PF_INET, SOCK_DGRAM, 0);
                struct sockaddr_in addr;
                addr.sin_addr.s_addr = inet_addr(p->dst);
                addr.sin_port = htons(p->dport);;
                addr.sin_family = AF_INET;

                connect(p->fd_udp, (struct sockaddr *)&addr, sizeof(struct sockaddr));
        }

    return 0;
}

int32_t send_jpeg(struct param *p, uint8_t * _data, uint32_t sz,
              uint32_t max_size, uint8_t type, uint8_t q, uint32_t t_sec, uint32_t t_usec)
{
    uint32_t size = sz + 2;
    uint32_t offset = 0;
//    uint32_t rtpTimestamp = ts2rtp(p, GetTimestamp());
    uint8_t *dt = _data;
    int32_t ret;
        uint32_t rtpTimestamp = ts2rtp(p, GetTimestamp(t_sec, t_usec));
/*
        static uint32_t prev_sec = 0;
        static uint32_t prev_usec = 0;
        unsigned long d = t_usec;
        if(prev_sec != t_sec)
                d += 1000000;
        fprintf(stderr, "; delta == %d\n", d - prev_usec);
        prev_sec = t_sec;
        prev_usec = t_usec;
*/
    if(max_size > RTP_PAYLOAD_SIZE) {
                fprintf(stderr, "Max rtp size couldn't be more then %d\n", RTP_PAYLOAD_SIZE);
                return -1;
    }

        uint8_t h[128];
        int h_offset = 96;

        dt += 8 + 12;
        if(p->raw)
                dt += 28;

        h[h_offset + 0] = 0;
        h[h_offset + 1] = 0;
        h[h_offset + 2] = 0;
        h[h_offset + 3] = 0;
        h[h_offset + 4] = type;
        h[h_offset + 5] = q;
        if(p->width <= 2040)
                h[h_offset + 6] = p->width / 8;
        else
                h[h_offset + 6] = 0;
        if(p->height <= 2040)
                h[h_offset + 7] = p->height / 8;
        else
                h[h_offset + 7] = 0;
        max_size -= JPEG_RTP_HDR_SIZE;
        max_size -= 32;

        uint32_t payloadLength = max_size;
        int32_t lastPacket = 0;
    while(size) {
                if(size <= max_size) {
                    payloadLength = size;
                    lastPacket = 1;
                }
/*

                if(size <= max_size) {
                    payloadLength = size;
                    lastPacket = 1;
                } else {
                    payloadLength = max_size;
                lastPacket = 0;
                }
*/
                ret = rtp_send_data(p, rtpTimestamp, p->payload_num, lastPacket, dt, payloadLength, (unsigned char *)h, h_offset, 8);

                dt += payloadLength;

                offset += payloadLength;
                size -= payloadLength;
                h[h_offset + 0] = 0;
                h[h_offset + 1] = offset >> 16;
                h[h_offset + 2] = offset >> 8;
                h[h_offset + 3] = offset;
                h[h_offset + 4] = type;
                h[h_offset + 5] = q;
                if(p->width <= 2040)
                        h[h_offset + 6] = p->width / 8;
                else
                        h[h_offset + 6] = 0;
                if(p->height <= 2040)
                        h[h_offset + 7] = p->height / 8;
                else
                        h[h_offset + 7] = 0;
//              h[h_offset + 6] = p->width / 8;
//              h[h_offset + 7] = p->height / 8;
    }

    return 0;
}


void usage(struct param *p, int32_t ret)
{
    static int8_t *usage =
        "Usage: %s [options]\n"
        "Options:\n"
        "\t-a --addr xx.xx.xx.xx - multicast destination address\n"
        "\t               by default == %s\n"
        "\t               (must be from 224.0.0.0 to 239.255.255.255)\n"
        "\t-p --port xx - port, destination for multicast, and source for unicast/multicast\n"
        "\t               by default == %d\n"
        "\t-t --ttl  xx - TTL (Time-To-Live for multicast, default %d)\n"
        "\t-s --silent  - \"silent\" mode for multicast - wait client over RTSP for streaming\n"
        "\t               (w/o this option - send multicast stream all time - by default)\n"
        "\t-m --mcast   - send stream over multicast\n"
        "\t-u --ucast   - send stream over unicast (used by default)\n"
        "\t               in unicast mode supported only one active RTSP client\n"
        "\t-f --fps  xx.xx - use fixed FPS for stream\n"
        "\n";
/*
        "Usage: %s [options]\n"
        "Options:\n"
        "\t-v --verbose\tPrint statistical information \n"
        "\t-q --quiet\tNo print additional information (default)\n"
        "\t-a --addr IP\tDestination UNICAST or MULTICAST IP address\n"
        "\t\t\t(default MULTICAST %s) (if --rtsp-off \n"
        "\t\t\tis not present and --rtsp-use-opt-addr is not present,\n"
        "\t\t\tthen destination address will got from rtsp request)\n"
        "\t-p --port PORT\tDestination port (default %d) (if --rtsp-off\n"
        "\t\t\tis not present and --rtsp-use-opt-port is not present,\n"
        "\t\t\tthen destination port will got from rtsp request)\n"
        "\t-t --ttl TTL\tTime-To-Live (default %d)\n"
        "\t-n --nostack\tFast networking (no use tcp/ip stack)(default)\n"
        "\t-s --stack\tUse UDP/IP stack\n"
        "\t-r --read\tUse access method READ\n"
        "\t-m --mmap\tUse access method MMAP (default)\n"
        "\t-f --fps\tIf system FPS is too much you can decrease it by\n"
        "\t\t\tseting this value. In this case some portion of video\n"
        "\t\t\tframes will passed. For example, if system FPS=600 but\n"
        "\t\t\tyou need only 20 you can set --fps=20\n"
        "\t-w --web SEC\tWeb camera mode. Every SEC second will be generate\n"
        "\t\t\tfresh image file which accessible by url\n"
        "\t\t\thttp://camera_address/var/fresh.jpg\n"
        "\t\t\tThis is useful for organize web camera but it can \n"
        "\t\t\tslow down video streaming (if streaming enabled)\n"
        "\t\t\tCurrently it work only with --read options\n"
        "\t-z --zero\tVideo streaming disabled. Only webcam mode enabled.\n"
        "\t\t\tIf no -w option present then -w=%d\n"
        "\t\t\tIn this mode a data access method will be READ\n"
        "\t-h --help\tShow this help\n"
        "\n"
        "\t--rtsp-on\t\tSimple RTSP server enabled (default)\n"
        "\t\t\t\tSupport OPTIONS, DESCRIBE, SETUP, PLAY, PAUSE,\n"
        "\t\t\t\tTEARDOWN rtsp requests.\n"
        "\t\t\t\tIf -z is present rtsp server will be disabled\n"
        "\t\t\t\t(because it has no video streaming)\n"
        "\t--rtsp-off\t\tDisable RTSP server\n"
        "\t--rtsp-port PORT\tRTSP server listen for incomming connections\n"
        "\t\t\t\ton this port. (default %d)\n"
        "\t\t\t\tYou can connect to the server by URI:\n"
        "\t\t\t\trtsp://camera_address:PORT\n"
        "\t--rtsp-use-opt-addr\tIf this option enabled the destination IP\n"
        "\t\t\t\taddress will got from the command option -a\n"
        "\t\t\t\t(or --addr). Otherwise it will got from the\n"
        "\t\t\t\trtsp request.\n"
        "\t--rtsp-use-opt-port\tIf this option enabled the destination port\n"
        "\t\t\t\twill got from the command option -a (or --addr).\n"
        "\t\t\t\tOtherwise it will got from the rtsp request.\n"
        "\t\t\t\tTwo last options can be useful if you want send\n"
        "\t\t\t\ta stream to multicast.\n"
        "\t--rtsp-qt-compat\tQuickTime compatible mode enable.\n"
        "\t\t\t\tQuickTime has some features in rtsp realisation.\n"
        "\t\t\t\tIf you want use the QuickTime player you MUST\n"
        "\t\t\t\tenter in the command line this option. In this\n"
        "\t\t\t\tcase you MUST use also --rtsp-use-opt-addr\n"
        "\t\t\t\toption. Saddanly it has no way use\n"
        "\t\t\t\tIP-From-RTSP-Request method with QT (I don't\n"
        "\t\t\t\tknow how do it)\n";
*/      
    fprintf(stderr, header, version);
    fprintf(stderr, usage, p->program_name, DEFAULT_DEST_IP,
            DEFAULT_DEST_PORT, DEFAULT_TTL);
//    fprintf(stderr, usage, p->program_name, DEFAULT_DEST_IP,
//          DEFAULT_DEST_PORT, DEFAULT_TTL, DEFAULT_REFRESH_INTERVAL, DEFAULT_RTSP_PORT);
    exit(ret);
}

void opt_parse(int32_t argc, char *const argv[], struct param *p)
{
    uint32_t var;
    int32_t next;
    const struct option long_opt[] = {
                {"addr",    1, NULL, 'a'},
                {"port",    1, NULL, 'p'},
                {"ttl",     1, NULL, 't'},
                {"silent",  0, NULL, 's'},
                {"mcast",   0, NULL, 'm'},
                {"ucast",   0, NULL, 'u'},
                {"fps",     1, NULL, 'f'},
                {NULL,      0, NULL,  0 }
    };
    const int8_t *const short_opt = "a:p:t:smuf:";
/*
    const struct option long_opt[] = {
        {"addr",    1, NULL, 'a'},
        {"port",    1, NULL, 'p'},
        {"ttl",     1, NULL, 't'},
        {"raw",     0, NULL, 'r'},
        {"stack",   0, NULL, 's'},
        {"nostack", 0, NULL, 'n'},
        {"mmap",    0, NULL, 'm'},
        {"fps",     1, NULL, 'f'},
        {"help",    0, NULL, 'h'},
        {"verbose", 0, NULL, 'v'},
        {"quiet",   0, NULL, 'q'},
        {"web",     1, NULL, 'w'},
        {"zero",    0, NULL, 'z'},
        {"rtsp-on",           0, NULL, RTSP_ON_TAG          },
        {"rtsp-off",          0, NULL, RTSP_OFF_TAG         },
        {"rtsp-port",         1, NULL, RTSP_LISTEN_PORT_TAG },
        {"rtsp-use-opt-addr", 0, NULL, RTSP_USE_OPT_ADDR_TAG},
        {"rtsp-use-opt-port", 0, NULL, RTSP_USE_OPT_PORT_TAG},
        {"rtsp-qt-compat",    0, NULL, RTSP_QT_COMPAT_TAG   },
        {NULL,                0, NULL, 0                    }
    };
    const int8_t *const short_opt = "a:f:hmnp:qrst:vw:z";
*/
        int mcast = 0;
        int silent = 0;
        float fps = 0;

        p->program_name = strdup(argv[0]);

        if(argc < PROGR_PARAM)
                usage(p, 0);

        do {
                next = getopt_long(argc, argv, short_opt, long_opt, NULL);
                switch(next) {
                case '?':
                case 'h':
                        usage(p, 0);
                        break;
                case 'a':
                        p->dst = optarg;
                        mcast = 1;
                        break;
                case 'p':
                        var = strtoul(optarg, (char **)NULL, 10);
                        if((var > 65535) || (var <= 0)) {
                                fprintf(stderr, "ERROR: destination RTP port is not correct\n\n");
                                goto error;
                        }
                        p->dport = (uint16_t)var;
                        if(p->dport % 2) {
                                fprintf(stderr, "\nERROR: destination RTP port cann't be odd\n\n");
                                goto error;
                        }
                        break;
                case 't':
                        var = strtoul(optarg, (char **) NULL, 10);
                        if((var > 255) || (var <= 0)) {
                                fprintf(stderr, "ERROR: TTL is not correct\n\n");
                                goto error;
                        }
                        p->ttl = (uint16_t) var;
                        break;
                case 'f':
                        fps = atof(optarg);
                        if(fps < 0)
                                fps = 0;
                        if(fps > 250)
                                fps = 250;
                        p->hw_fps = 100 * fps;
                        break;
                case 's':
                        silent = 1;
                        break;
                case 'u':
                        mcast = 0;
                        break;
                case 'm':
                        mcast = 1;
                        break;
                case -1:
                        break;
                default:
                        usage(p, 1);
                        break;
                }
        } while(next != -1);

        if(mcast) {
                p->rtsp_use_cmd_addr = 1;
                p->rtsp_use_cmd_port = 1;
                p->rtsp_qt_compat = 1;
        }
//      if(silent) {
//      }
        next = optind;

        return;
error:
        exit(-1);
/*
        do {
                next = getopt_long(argc, argv, short_opt, long_opt, NULL);
                switch(next) {
                case '?':
                case 'h':
                        usage(p, 0);
                        break;
                case 'p':
                        var = strtoul(optarg, (char **)NULL, 10);
                        if((var > 65535) || (var <= 0)) {
                                fprintf(stderr, "ERROR: destination video port is not correct\n\n");
                                usage(p, 0);
                        }
                        p->dport = (uint16_t)var;
                        if(p->dport % 2) {
                                fprintf(stderr, "\nERROR: destination video port cann't be odd\n\n");
                                usage(p, 0);
                        }
                        mcast = 1;
                        break;
                case 'a':
                        p->dst = optarg;
                        mcast = 1;
                        break;
                case 'v':
                        p->verbose = 1;
                        break;
                case 'q':
                        p->verbose = 0;
                        break;
                case 's':
                        p->raw = 0;
                        break;
                case 'z':
                        p->zero = 1;
                        break;
                case 'n':
                        p->raw = 1;
                        break;
                case 'w':
                        var = strtoul(optarg, (char **) NULL, 10);
                        if(var < 0) {
                                fprintf(stderr, "ERROR: WEB time is not correct\n\n");
                                usage(p, 0);
                        }
                        p->web = (uint32_t)var;
                        break;
                case 'r':
                        p->meth = READ_METHOD;
                        break;
                case 'm':
                        p->meth = MMAP_METHOD;
                        break;
                case 't':
                        var = strtoul(optarg, (char **) NULL, 10);
                        if((var > 255) || (var <= 0)) {
                                fprintf(stderr, "ERROR: TTL is not correct\n\n");
                                usage(p, 0);
                        }
                        p->ttl = (uint16_t) var;
                        break;
                case 'f':
                        var = strtoul(optarg, NULL, 10);
                        if((var > 1000) || (var < 0)) {
                                fprintf(stderr, "ERROR: Software FPS is not correct\n\n");
                                usage(p, 0);
                        }
                        p->fps_soft = var;
                        break;
                case RTSP_ON_TAG:
                        p->rtsp = 1;
                        break;
                case RTSP_OFF_TAG:
                        p->rtsp = 0;
                        break;
                case RTSP_LISTEN_PORT_TAG:
                        var = strtoul(optarg, (char **) NULL, 10);
                        if((var > 65535) || (var <= 0)) {
                                fprintf(stderr, "ERROR: RTSP server port is not correct\n\n");
                                usage(p, 0);
                        }
                        p->rtsp_port = (uint16_t) var;
                        break;      
                case RTSP_USE_OPT_ADDR_TAG:
                        p->rtsp_use_cmd_addr = 1;
                        break;
                case RTSP_USE_OPT_PORT_TAG:
                        p->rtsp_use_cmd_port = 1;
                        break;
                case RTSP_QT_COMPAT_TAG:
                        p->rtsp_qt_compat = 1;
                        break;
                case -1:
                        break;
                default:
                        usage(p, 1);
                        break;
                }
        } while(next != -1);
*/

        if(mcast) {
                p->rtsp_use_cmd_addr = 1;
                p->rtsp_use_cmd_port = 1;
                p->rtsp_qt_compat = 1;
        }
        next = optind;
}

int32_t buf_size;
int32_t str_setup;
int32_t str_play;
int32_t str_teardown;
int32_t str_stop;
int32_t str_count;
int8_t  *wbuf;
unsigned long *start, *ccam_dma_buf;

int32_t grab_and_send(struct param *p)
{
    int32_t status = 0, res, res_buf;
    int32_t offs;
    int32_t alen, jpeg_wp, old_jpeg_wp = 0, frame;
    int32_t ret, count, fr_fd = -1;
    int32_t all_buf_sz;
    int32_t stack_offs = 0, cnt = 0, buf_len = 0;
    uint8_t q = 0;
    uint8_t jpeg_type = YUV420;
    uint32_t frame_avg = 0;
    uint32_t fps_dlt = 0, dlt;
    double _fps, bw, tm;
    struct timeval st, ft, fps_st, fps_fn;
    time_t cur_time;
    static time_t old_time = 0;
    int8_t *buf, sdp[8192];
    static int32_t run_flag = 0;

        struct timeval tv;

        if(run_flag && p->rtsp && p->rtsp_qt_compat) {
                goto run_flag1;
        }
        run_flag = 1;

        if(p->fps_soft > 0) {
                fps_dlt = 1000000 / p->fps_soft;
        }

        status = ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_SEQ), 0);
        if((status == CAMSEQ_RUN || status == CAMSEQ_SINGLE) && p->meth == READ_METHOD) {
                ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_STOP);
        }

        if(status != CAMSEQ_RUN && p->meth == MMAP_METHOD) {
                ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_START);
                fprintf(stderr, "+++++++++++++++ Compressor start\n");
        }

        if(p->meth == READ_METHOD) {
                ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_CATCHUP);
                ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_FORGET);
                ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_ACQUIRE);
        }

run_flag1:

        p->width = ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, P_ACTUAL_WIDTH), 0);
        p->height = ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, P_ACTUAL_HEIGHT), 0);
        p->fps = 0.01 * ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, P_FP100S), 0);
        p->vbitrt = 90000;

        res = jpeg_session_start(p);
        if(res != 0) {
                fprintf(stderr, "Start session error!\n");
                return -1;
        }
    
        memset(sdp, 0, 8192);
        res = write_sdp(p, 1, sdp);

        if(p->raw)
                stack_offs += IP_UDP_SIZE;

        while(!str_play && !str_stop && !str_teardown)
                sched_yield();
//              usleep(10);
    
        gettimeofday(&st, NULL);
        gettimeofday(&fps_st, NULL);
        while (!str_stop && !str_teardown) {
                while(!str_play && !str_stop && !str_teardown)
                        sched_yield();
//                      usleep(10);
                if(str_stop || str_teardown)
                        break;
                if(p->fps_soft > 0){
                        while(1) {
                                gettimeofday(&fps_fn, NULL);
                                dlt = (fps_fn.tv_sec*1000000+fps_fn.tv_usec) - (fps_st.tv_sec*1000000+fps_st.tv_usec);
                                if(dlt < fps_dlt){
                                        if(fps_dlt-dlt > HZ*2) {
                                                usleep(HZ);
                                        }
                                        continue;
                                }
                                gettimeofday(&fps_st, NULL);
                                break;
                        }
                }
        
                offs = sizeof(rtp_packet) + JPEG_RTP_HDR_SIZE + stack_offs;
                if(p->meth == READ_METHOD) {
                while((lseek(fd, 0, SEEK_END) == 0));
                    ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_ACQUIRE);
                    lseek(fd, 0, SEEK_SET);
                buf_len = 0;
                    res_buf = 0;
                    while((res_buf = read(fd, wbuf + offs, MAX_JPEG_BUF - 100 - res_buf)) > 0) {
                                offs += res_buf;
                                buf_len += res_buf;
                    }
                buf = wbuf + HDR_SIZE;
                } else {
                    jpeg_wp = ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, G_CIRCBUFWP), 0)>>2;
                if(jpeg_wp == old_jpeg_wp)
                                continue;
                    old_jpeg_wp = jpeg_wp;
                /* MUST be multiple by 32 */
                    if(jpeg_wp & 0x7)
                                continue;
                alen = jpeg_wp - 9;
                    if(alen < 0)
                                alen += (buf_size >> 2);
                /* MUST be 0xff in old length's byte */
                        if((ccam_dma_buf[alen] & 0xff000000) != 0xff000000) {
                                fprintf(stderr, "skip frame with signature: 0x%08X\n", (unsigned int)ccam_dma_buf[alen]);
                                continue;
                        }
                    buf_len = ccam_dma_buf[alen] & 0x00ffffff;
                        tv.tv_sec = ccam_dma_buf[alen - 2];
                        tv.tv_usec = ccam_dma_buf[alen - 1];
                    /* Size is not correct */
                    if(buf_len > buf_size)
                                continue;

//              all_buf_sz = ((((buf_len + 3) >> 2) + 9) >> 3) << 3;
                    all_buf_sz = ((((buf_len + 3) >> 2) + 11) >> 3) << 3;
                    frame = alen + 1 - all_buf_sz;
                if(frame < 0) {
                                frame += buf_size >> 2;
                                {
                                int8_t *ptr;
                                int32_t end_part, start_part = 0;
                                    end_part = (frame << 2) + buf_len - buf_size;
                                    if(end_part >= 0)
                                                start_part = buf_len - end_part;
                                ptr = ((int8_t *) (start + (TMP_BUF_OFFS >> 2))) - start_part;
                                    memcpy(ptr, &ccam_dma_buf[frame], start_part);
                                    buf = (int8_t *) (start + (TMP_BUF_OFFS >> 2) - (offs >> 2)) - start_part;
                                }
                    } else {
                                buf = (int8_t *) (start + (TMP_BUF_OFFS >> 2) + frame - (offs >> 2));
                    }
                }

                if(p->web > 0) {
                    cur_time = time(NULL);
                if(cur_time - old_time >= p->web) {
                                old_time = cur_time;
                                fr_fd = open(FRESH_FILE, O_WRONLY | O_CREAT | O_TRUNC, 0644);
                                if(fr_fd < 0) {
                                    fprintf(stderr, "Fresh JPEG file is not created!\n");
                                    fprintf(stderr, "You can't use WEB CAMERA mode.\n");
                                    p->web = 0;
                                    goto noweb;
                                }

                                count = 0;
                                while(count != buf_len) {
                                        offs = sizeof(rtp_packet) + JPEG_RTP_HDR_SIZE + stack_offs;
                                        ret  = write(fr_fd, wbuf + offs + count, buf_len - count);
                                        if(ret < 0) {
                                                fprintf(stderr, "Fresh JPEG file is not created!\n");
                                                fprintf(stderr, "You can't use WEB CAMERA mode.\n");
                                                close(fr_fd);
                                                p->web = 0;
                                                goto noweb;
                                        }
                                        count += ret;
                                }
                        }
                        close(fr_fd);
                }
noweb:
                frame_avg += buf_len;
        
                cnt++;
                if(!p->zero) {
                        if(tv.tv_sec == 0 && tv.tv_usec == 0)
                                gettimeofday(&tv, NULL);
                        q = ioctl(ioctl_fd, _CCCMD(CCAM_RPARS, P_QUALITY), 0);
                        send_jpeg(p, buf, buf_len, RTP_PAYLOAD_SIZE, jpeg_type, q, tv.tv_sec, tv.tv_usec);
                }

                if(cnt == 100 && p->verbose && !p->zero) {
                        gettimeofday(&ft, NULL);
                        tm = (((double)((ft.tv_sec * 1000000 + ft.tv_usec) - (st.tv_sec * 1000000 + st.tv_usec))) / 1000000);
                        _fps = 100 / tm;
                        bw = frame_avg * 8 / tm / 1000000;
                        frame_avg = frame_avg / 100;
                        gettimeofday(&st, NULL);
                        fprintf(stderr, "fps=%.2f  avg_size=%d   BW=%.1f Mb/s\n", _fps, frame_avg, bw);
                        fflush(NULL);
                        cnt = 0;
                        frame_avg = 0;
                }

                if(p->meth == READ_METHOD) {
                        ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_FORGET);
                }
        }

        if(run_flag && p->rtsp && p->rtsp_qt_compat) {
                goto run_flag2;
        }

        if(status == CAMSEQ_RUN || status == CAMSEQ_SINGLE) {
                status = ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_MONITOR_SEQ), 0);
                if(status != CAMSEQ_RUN && status != CAMSEQ_SINGLE) {
                        ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_START);
                }
        } else {
                ioctl(ioctl_fd, _IO(CMOSCAM_IOCTYPE, IO_CCAM_JPEG), JPEG_CMD_STOP);
        }

run_flag2:

        session_finish(p);
        return 0;
}


void *rtsp_loop(void* var){
    struct param *p = (struct param *)var;

    rtsp_listen(p);
    event_loop(0);    
    str_stop = 1;
    sleep(2);
    pthread_exit(0);
    return 0;
}

int main(int argc, char **argv) {
        int32_t res;
        int8_t *ccam_file = "/dev/ccam_dma.raw";
        int8_t *circ_file = "/dev/circbuf";

        int8_t *res_file;
        struct param p;
        pthread_t pid;

        int _fd, c;
        for(c = 0; c < 20; c++)
                if(_fd = open("/dev/stream", O_RDONLY) < 0)
                        usleep(50000);
                else
                        break;
//      int _fd = open("/dev/stream", O_RDONLY);
        if(_fd < 0) {
                fprintf(stderr, "streamer already running, exit\n");
                return -1;
        }

        p.dport                 = DEFAULT_DEST_PORT;
        p.ttl           = DEFAULT_TTL;
        p.meth          = MMAP_METHOD;
        p.dst           = DEFAULT_DEST_IP;
        p.raw           = 1;
        p.verbose       = 0;
        p.web           = 0;
        p.zero          = 0;
        p.rtsp          = 1;
        p.rtsp_port             = DEFAULT_RTSP_PORT;
        p.rtsp_use_cmd_port = 0;
        p.rtsp_use_cmd_addr = 0;
        p.fps_soft          = 0;
        p.rtsp_qt_compat        = 0;
        p.fd_udp = 0;
        p.fd_raw = 0;
        p.hw_fps = 0;
        memset(&p.msg, 0, sizeof(struct msghdr));

        opt_parse(argc, argv, &p);

        if(p.hw_fps != 0)
                ioctl(_fd, _IO(IOC_STREAM_SET_FPS, 0x00), p.hw_fps);
        if(p.zero) {
                p.meth = READ_METHOD;
                if(p.web <= 0)
                        p.web = DEFAULT_REFRESH_INTERVAL;
                p.rtsp = 0;
        }
        if(p.meth == MMAP_METHOD && p.web) {
                fprintf(stderr, "\nWARNING!!! Webcam mode can be activated only with READ method (option -r)\n\n");
                p.web = 0;
        }
        if(p.rtsp && p.rtsp_qt_compat && !p.rtsp_use_cmd_addr) {
                fprintf(stderr, "\nERROR!!! You MUST use --rtsp-use-opt-addr with --rtsp-qt-compat\n\n");
                usage(&p, 1);
        }

        if(get_src_addr(&p) != 0) {
                return -1;
        }
#ifdef NO_IOCTLS_IN_CIRCBUF
        if((ioctl_fd = open(ccam_file, O_RDWR)) < 0) {
                fprintf(stderr, "Can't open device %s\n",ccam_file);
                return -1;
        }

        if(p.meth == READ_METHOD)
                fd=ioctl_fd ; 
        else { // separate file for ioctls
                if((fd = open(circ_file, O_RDWR)) < 0) {
                        fprintf(stderr, "Can't open device %s\n",circ_file);
                        return -1;
                }
        }
#else
        if(p.meth == READ_METHOD)
                res_file = ccam_file;
        else
                res_file = circ_file;
        if((fd = open(res_file, O_RDWR)) < 0) {
                fprintf(stderr, "Cann't open device!\n");
                return -1;
        }
        ioctl_fd=fd; 
#endif
        if(p.meth == READ_METHOD) {
                wbuf = (int8_t *) malloc(MAX_JPEG_BUF);
        } else {
                start = (unsigned long *) valloc(0x100000);
                buf_size = lseek(fd, 0, 2);
                ccam_dma_buf = (unsigned long *) mmap(start + (TMP_BUF_OFFS >> 2), buf_size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_SHARED, fd, 0);
                if((int) ccam_dma_buf == -1) {
                        fprintf(stderr, "mmap error!\n");
                        return -1;
                }
        }
    
        if(p.rtsp) {
                fprintf(stderr, "\n\tRTSP server is listening on the port %d.\n", p.rtsp_port);
                if(!p.rtsp_use_cmd_addr) {
                        fprintf(stderr, "\tDestination address will got from rtsp request.\n");
                } 
                if(!p.rtsp_use_cmd_port) {
                        fprintf(stderr, "\tDestination port will got from rtsp request.\n");
                }
                fprintf(stderr, "\n\tStream is accessible by uri rtsp://%s:%d\n\n",     p.src, p.rtsp_port);
        }

        str_stop     = 0;
        str_teardown = 0;
        str_count    = 0;

        if(p.rtsp){
                str_setup = 0;
                str_play  = 0; 
                if(pthread_create(&pid, NULL, rtsp_loop, &p) != 0) {
                        fprintf(stderr, "thread create error!\n");
                        return -1;
                }
        } else {
                str_setup = 1;
                str_play  = 1; 
        }

        if(p.rtsp_qt_compat) {
                str_setup = 1;
                str_play  = 1; 
        }
    
        while(1) {
                if(!str_setup && !str_stop && !str_teardown) {
                        sched_yield();
//                      usleep(10);
                        continue;
                }
        
                if(str_setup) {
                        str_setup = 0;
                }
        
                if(str_teardown) {
                        str_teardown = 0;
//                      usleep(10);
                        sched_yield();
                        continue;
                }
                if(str_stop)
                        break;
                res = grab_and_send(&p);
                str_play  = 0;
                str_setup = 0;
                if(p.rtsp_qt_compat) {
                        str_setup = 1;
                        str_play  = 1; 
                }
                if(res != 0)
                        return -1;
                if(str_stop)
                        break;
        }

        if(p.meth == MMAP_METHOD) {
                munmap(start + TMP_BUF_OFFS, buf_size);
        }

        if(p.meth == READ_METHOD) {
                free(wbuf);
        }

        return 0;
}

---