apps/astreamer/audio.cpp

Go to the documentation of this file.

#include "audio.h"
#include "helper.h"

#include <iostream>

#include <sys/ioctl.h>
#include <arpa/inet.h>
#include <asm/elphel/hist.h>

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

using namespace std;

//Audio *audio = NULL;

Audio::Audio(bool enable, int sample_rate, int channels) {
        snd_pcm_hw_params_t *hw_params;
        _present = false;
        rtc_fd = 0;
        stream_name = "audio";

        // normalize audio settings
        if(sample_rate == 0)
                sample_rate = SAMPLE_RATE;
        if(sample_rate > 48000)
                sample_rate = 48000;
        if(sample_rate < 11025)
                sample_rate = 11025;
        if(channels == 0)
                channels = SAMPLE_CHANNELS;
        if(channels < 1)
                channels = 1;
        if(channels > 2)
                channels = 2;
        
        SSRC = 10;
        _sample_rate = sample_rate;
        _channels = channels;
//      _sample_rate = SAMPLE_RATE;
//      _channels = SAMPLE_CHANNELS;
//      long sample_time = 100;
        long sample_time = 20;
        sbuffer_len = _sample_rate * 2 * _channels * sample_time;
        sbuffer_len /= 1000;
        sbuffer_len -= sbuffer_len % 2;
cerr << "sbuffer_len == " << sbuffer_len << endl;
        _ptype = 97;

        if(enable) {
            // open ALSA for capturing
                int err;
                sbuffer = (short *)malloc(sbuffer_len * sizeof(short) * 8);
                if((err = snd_pcm_open(&capture_handle, "default", SND_PCM_STREAM_CAPTURE, 0)) < 0)
                        return;
                if((err = snd_pcm_hw_params_malloc(&hw_params)) < 0)
                        return;
                if((err = snd_pcm_hw_params_any(capture_handle, hw_params)) < 0)
                        return;
                if((err = snd_pcm_hw_params_set_access(capture_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
                        return;
                if((err = snd_pcm_hw_params_set_format(capture_handle, hw_params, SND_PCM_FORMAT_S16_BE)) < 0)
                        return;
                unsigned int t = _sample_rate;
                if((err = snd_pcm_hw_params_set_rate_near(capture_handle, hw_params, &t, 0)) < 0)
                        return;
                _sample_rate = t;
                if((err = snd_pcm_hw_params_set_channels(capture_handle, hw_params, _channels)) < 0)
                        return;
                if((err = snd_pcm_hw_params(capture_handle, hw_params)) < 0)
                        return;
                snd_pcm_hw_params_free (hw_params);
                if((err = snd_pcm_prepare(capture_handle)) < 0)
                        return;

                cerr << endl << "Audio init: ok; with sample rate: " << _sample_rate << "; and channels: " << _channels << endl;
                _present = true;
//              _present = false;

                _play = false;
                rtc_fd = open(DEV_HIST_NAME, O_RDWR);
                // create thread...
                init_pthread((void *)this);
        }
}

Audio::~Audio(void) {
        if(_present)
                snd_pcm_close(capture_handle);
        if(rtc_fd)
                close(rtc_fd);
}

void Audio::Start(string ip, long port) {
        if(!_present)
                return;
cerr << "Audio ---> Start !!!" << endl;
        // create udp socket
/*
        f_tv.tv_sec = 0;
        f_tv.tv_usec = 0;
*/
        unsigned long rtc[4];
        ioctl(fd_stream, _IO(IOC_STREAM_GET_TIME, 0x00), (void *)&rtc[0]);
        f_tv.tv_sec = rtc[2];
        f_tv.tv_usec = rtc[3];
        RTP_Stream::Start(ip, port);
}

void Audio::Stop(void) {
        if(!_present)
                return;
cerr << "Audio ---> Stop !!!" << endl;
        RTP_Stream::Stop();
        f_tv.tv_sec = 0;
        f_tv.tv_usec = 0;
        // destroy udp socket
}

long Audio::capture(void) {
//cerr << "audio: capture()" << endl;
        long slen = sbuffer_len;
//      void *sb = (void *)sbuffer;
        if((slen = snd_pcm_readi(capture_handle, sbuffer, sbuffer_len)) <= 0)
//      if((slen = snd_pcm_readn(capture_handle, &sb, sbuffer_len)) <= 0)
                snd_pcm_prepare(capture_handle);
        else {// update timestamp, and 
                if(f_tv.tv_sec == 0) {
                        unsigned long rtc[4];
//                      rtc[0] = 0;
//                      rtc[1] = 0;
//                      struct timeval tv;
//                      gettimeofday(&tv, NULL);
//                      rtc[0] = tv.tv_sec;
//                      rtc[1] = tv.tv_usec;
//                      rtc[0] = 1;
//                      rtc[1] = 1;
//cerr << "rtc_fd == " << rtc_fd << endl;
//                      ioctl(_fd, _IO(IOC_HIST_RTC_GET, 0x00), &rtc);
/*                      
char buf[32];
sprintf(buf, "audio: %d:%06d\n", rtc[0], rtc[1]);
cerr << buf << endl;
*/
//                      f_tv = time_sys();
/*
                        f_tv.tv_sec = rtc[0];
                        f_tv.tv_usec = rtc[1];
                        struct timeval m;
                        m.tv_sec = 0;
                        m.tv_usec = (1000000 * slen) / _sample_rate;
                        f_tv = time_minus(f_tv, m);
*/
/*
                        ioctl(fd_stream, _IO(IOC_STREAM_GET_TIME, 0x00), (void *)&rtc[0]);
                        f_tv.tv_sec = rtc[2];
                        f_tv.tv_usec = rtc[3];
*/
                }
        }
//cerr << "audio: capture() - end" << endl;
        return slen;
}

bool Audio::process(void) {
//cerr << "audio: process()" << endl;
        long sample_len;
        if((sample_len = capture()) <= 0) {
                cerr << "nothing to send" << endl;
                return false;
        }
        
//cerr << "audio: process()...1" << endl;
        static unsigned short packet_num = 0;
        unsigned short pnum;
//      unsigned long SSRC;
//      unsigned long timestamp;
//      static unsigned long old_ts = 0;

//      m.t_usec = (1000000 * slen) / sample_rate;
        struct timeval t;
        t.tv_sec = 0;
        long long usec = sample_len;
        usec *= 1000000;
        usec /= _sample_rate;
//usec *= 4;
//usec /= 4;
        t.tv_usec = usec;
        f_tv = time_plus(f_tv, t);
//cerr << "usec == " << usec;
//cerr << "sample_len... " << sample_len;
//fprintf(stderr, "0x%08X\n", t.tv_usec);
//cerr << "audio time: " << f_tv.tv_sec << ":" << f_tv.tv_usec << endl;

//cerr << "audio: process()...2" << endl;
        unsigned long ts;
        float f = f_tv.tv_usec;
        f /= 1000000;
        f += f_tv.tv_sec;
        f *= _sample_rate;
        timestamp = (unsigned long)f;
//cerr << "....>>>> audio ts == " << timestamp << endl;
        ts = htonl(timestamp);
/*
        timestamp = sample_len;
        timestamp += old_ts;
        old_ts = timestamp;
        timestamp = htonl(timestamp);
*/
        void *m = (void *)sbuffer;
//cerr << "audio: process()...3" << endl;

        int i;
        long offset = 0;
        #define LEN 1200
        unsigned char d[LEN + 20];
        int chunk = LEN;
        int to_send = sample_len * 2 * _channels;
        int size = to_send;
        long count = 0;
        for(;;) {
                if(to_send == 0)
                        break;
                if(to_send > chunk) {
                        i = chunk;
                        to_send -= i;
                } else {
                        i = to_send;
                        to_send = 0;
                }
                packet_num++;
                pnum = htons(packet_num);
                count += i;
                // fill RTP header
                d[0] = 0x80;
                if(count >= size)
                        d[1] = _ptype + 0x80;
                else
                        d[1] = _ptype;
                memcpy((void *)&d[2], (void *)&pnum, 2);
                memcpy((void *)&d[4], (void *)&ts, 4);
                memcpy((void *)&d[8], (void *)&SSRC, 4);
        // fill data
                memcpy((void *)&d[12], (void *)((char *)m + offset), i);
                offset += i;
                // send packet
                rtp_packets++;
                rtp_octets += i; // data + MJPEG header
                rtp_socket->send((void *)d, i + 12);
    }
//cerr << "audio: process()...4" << endl;
        return true;
}

---