apps/camogm2/camogm_ogm.c

Go to the documentation of this file.

/*!***************************************************************************
*! FILE NAME  : camogm_ogm.c
*! DESCRIPTION: Provides writing to ogm files for camogm
*! Copyright (C) 2007 Elphel, Inc.
*! -----------------------------------------------------------------------------**
*!  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/>.
*! -----------------------------------------------------------------------------**
*!
*!  $Log: camogm_ogm.c,v $
*!  Revision 1.2  2008/05/23 13:09:49  spectr_rain
*!  QuickTime support
*!
*!  Revision 1.1  2008/05/02 12:45:58  spectr_rain
*!  initial revision with the sound support
*!
*!  Revision 1.2  2007/11/19 03:23:21  elphel
*!  7.1.5.5 Added support for *.mov files in camogm.
*!
*!  Revision 1.1  2007/11/16 08:49:58  elphel
*!  Initial release of camogm - program to record video/image to the camera hard drive (or other storage)
*!
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/uio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
//#include <ctype.h>
//#include <getopt.h>
#include <time.h>
#include <string.h>

#include <netinet/in.h> /*little <-> big endian ?*/
#include <sys/mman.h>           /* mmap */
#include <sys/ioctl.h>

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


#include <ogg/ogg.h> // has to be before ogmstreams.h
#include "ogmstreams.h" // move it to <>?

#include "camogm_ogm.h"
#include "camogm.h"

struct ogm_stream_t {
        ogg_stream_state os;
        ogg_page og;
        ogg_packet op;
        elph_ogg_packet eop;
        ogg_int64_t packetno;
        ogg_int64_t granulepos;
};

struct ogm_stream_t svideo;
struct ogm_stream_t saudio;

int ogm_flush_to_file(struct ogm_stream_t *stream) {
        int i, j;
        while(ogg_stream_flush(&(stream->os), &(stream->og))) {
//              if((((i = fwrite(stream->og.header, 1, stream->og.header_len, state->vf))) != stream->og.header_len) || (stream->og.body_len && (((i = fwrite(stream->og.body, 1, stream->og.body_len, state->vf))) != stream->og.body_len))) {
                if((((i = write(state->vf, stream->og.header, stream->og.header_len))) != stream->og.header_len) || (stream->og.body_len && (((i = write(state->vf, stream->og.body, stream->og.body_len))) != stream->og.body_len))) {
                        j = errno;
                        D2(fprintf(debug_file, "\nogm_flush_to_file() fail: %d %ld %ld\n", i, stream->og.header_len, stream->og.body_len));
                        return -CAMOGM_FRAME_FILE_ERR;
                }
        }
        return 0;
}

// audio
int camogm_audio_init(void);
int camogm_audio_end(void);

int camogm_init_ogm(void) {
        return 0;
}

void camogm_free_ogm(void) {
}

int camogm_start_ogm(void) {
        char vendor[]= "CamOGM";
        int pos;
        int rez = 0;
        stream_header sh;
        char hdbuf[sizeof(stream_header) + 1];
        ogg_packet ogg_header;
        sprintf(state->path, "%s%010ld_%06ld.ogm", state->path_prefix, state->frame_params.timestamp_sec, state->frame_params.timestamp_usec);
/*
        if(!((state->vf = fopen(state->path, "w+")))) {
                D0(fprintf(debug_file, "Error opening %s for writing\n", state->path));
                return -CAMOGM_FRAME_FILE_ERR;
        }
*/
        if(!((state->vf = open(state->path, O_RDWR | O_CREAT)))) {
                D0(fprintf(debug_file, "Error opening %s for writing\n", state->path));
                return -CAMOGM_FRAME_FILE_ERR;
        }
        ogg_stream_init(&(svideo.os), state->serialno);
        svideo.packetno = 0;
        // make video header
        memset(&sh, 0, sizeof(sh));
        memcpy(sh.streamtype, "video", 5);
        memcpy(sh.subtype, "MJPG", 4);
        put_uint32(&sh.size, sizeof(stream_header));
//      put_uint64(&sh.time_unit, (ogg_int64_t) 10*state->frame_period);
        put_uint64(&sh.time_unit, state->time_unit);
//fprintf(stderr, "time_unit == %d\n", state->time_unit);
//      put_uint64(&sh.samples_per_unit, 1);
//state->timescale = 1;
        put_uint64(&sh.samples_per_unit, (ogg_int64_t)state->timescale);
//      put_uint64(&sh.samples_per_unit, (ogg_int64_t)1);
//fprintf(stderr, "__samples_per_unit == %d\n", (int)state->timescale);
        put_uint32(&sh.default_len, 1);
        put_uint32(&sh.buffersize, state->width * state->height);
//   put_uint16(&sh.bits_per_sample, 24); //?
        put_uint16(&sh.bits_per_sample, 0); //?
        put_uint32(&sh.sh.video.width, state->width);
        put_uint32(&sh.sh.video.height, state->height);
        memcpy(&hdbuf[1], &sh, sizeof(sh));
        hdbuf[0] = 1;
        ogg_header.packet = hdbuf;
        ogg_header.bytes = sizeof(sh) + 1;
        ogg_header.b_o_s = 1;
        ogg_header.e_o_s = 0;
        ogg_header.packetno = svideo.packetno++;;
        ogg_header.granulepos = 0;
        ogg_stream_packetin(&svideo.os, &ogg_header);

        if((rez = ogm_flush_to_file(&svideo)) != 0)
                return rez;

        memset(hdbuf, 0, sizeof(hdbuf));
        hdbuf[0] = PACKET_TYPE_COMMENT;
        memcpy(&hdbuf[1], "vorbis", 6);
        pos = 7;
        put_uint32(&hdbuf[pos], strlen(vendor));
        pos += 4;
        strcpy(&hdbuf[pos], vendor);
        pos += strlen(vendor);
        put_uint32(&hdbuf[pos], 0);
        pos += 4;
        hdbuf[pos++] = 1;
        ogg_header.packet = hdbuf;
        ogg_header.bytes = pos;
        ogg_header.b_o_s = 0;
        ogg_header.e_o_s = 0;
        ogg_header.packetno = svideo.packetno++;;
        ogg_header.granulepos = 0;
        ogg_stream_packetin(&svideo.os, &ogg_header);
//      state->granulepos = (ogg_int64_t)((((double) state->frame_params.timestamp_usec) +
        svideo.granulepos = (ogg_int64_t)((((double) state->frame_params.timestamp_usec) +
                                    (((double) 1000000) * ((double)state->frame_params.timestamp_sec))) *
                                    ((double) 10) /
                                    ((double) state->time_unit) *
                                    ((double) state->timescale));
//   state->frame_period=(state->this_frame_params.timestamp_usec - state->frame_params.timestamp_usec)+
//               1000000*(state->this_frame_params.timestamp_sec  - state->frame_params.timestamp_sec);
//  put_uint64(&sh.time_unit, (ogg_int64_t)((double)10000000.0 / (double)fps));

        svideo.granulepos = 0;

        rez = 0;
        if(state->audio_enable)
                rez = camogm_audio_init();
        return rez;
}

int camogm_frame_ogm(void){
        int indx;
        int rez;

        elph_ogg_packet elp_packet;
        elp_packet.bytes = 0;
        for(indx = 0; indx < state->chunk_index; indx++)
                elp_packet.bytes += state->packetchunks[indx].bytes;
        elp_packet.packet = state->packetchunks;
/*D(fprintf (debug_file,"0:0x%lx: %p\n" \
                             "1:0x%lx: %p\n" \
                             "2:0x%lx: %p\n" \
                             "3:0x%lx: %p\n" \
                             "4:0x%lx: %p\n" \
                             "5:0x%lx: %p\n" \
                             "6:0x%lx: %p\n", \
                              elp_packet.packet[0].bytes,  elp_packet.packet[0].chunk,
                              elp_packet.packet[1].bytes,  elp_packet.packet[1].chunk,
                              elp_packet.packet[2].bytes,  elp_packet.packet[2].chunk,
                              elp_packet.packet[3].bytes,  elp_packet.packet[3].chunk,
                              elp_packet.packet[4].bytes,  elp_packet.packet[4].chunk,
                              elp_packet.packet[5].bytes,  elp_packet.packet[5].chunk,
                              elp_packet.packet[6].bytes,  elp_packet.packet[6].chunk));
*/
        elp_packet.b_o_s = 0;
        elp_packet.e_o_s = 0;
        elp_packet.packetno = svideo.packetno++;;
//      tts[0]=state->frame_params.timestamp_usec;
//      tts[1]=state->frame_params.timestamp_sec;
//      elp_packet.granulepos = state->granulepos;
        elp_packet.granulepos = svideo.granulepos;
//      state->granulepos += (ogg_int64_t)state->timescale;
        svideo.granulepos += (ogg_int64_t)state->timescale;

        ogg_stream_packetin_elph(&svideo.os, &elp_packet);
        if((rez = ogm_flush_to_file(&svideo)) != 0)
                return rez;
//      fflush(state->vf);
        if(state->allow_sync)
                sync();
        return 0;
}

int camogm_end_ogm(void){
        int rez = 0;
        ogg_packet ogg_header;
        char buf[1] = {0x00};

        ogg_header.packet = buf;
        ogg_header.bytes = 1;
        ogg_header.b_o_s = 0;
        ogg_header.e_o_s = 1;
        ogg_header.packetno = svideo.packetno++;
        ogg_header.granulepos = ++(svideo.granulepos);
        ogg_stream_packetin(&svideo.os, &ogg_header);

        if((rez = ogm_flush_to_file(&svideo)) != 0)
                return rez;
        rez = 0;
        if(state->audio_enable)
                rez = camogm_audio_end();
        return rez;
}

int camogm_audio_init(void) {
        char vendor[]= "CamOGM";
        char hdbuf[sizeof(stream_header) + 1];
        int pos;
        int rez;

        stream_header sh_audio;
        ogg_packet ogg_header;

        saudio.packetno = 0;
        saudio.granulepos = 0;
        // make audio header
        ogg_stream_init(&saudio.os, 0x28);
        saudio.packetno = 0;
        memset(&sh_audio, 0, sizeof(stream_header));
        memcpy(sh_audio.streamtype, "audio", 5);
        memcpy(sh_audio.subtype, "0001", 4);
        put_uint32(&sh_audio.size, sizeof(stream_header));
        put_uint64(&sh_audio.time_unit, 1000);
        put_uint64(&sh_audio.samples_per_unit, (ogg_int64_t)state->audio_rate);
        put_uint32(&sh_audio.default_len, 0);
        put_uint32(&sh_audio.buffersize, 0);
        put_uint16(&sh_audio.bits_per_sample, 16);
        put_uint32(&sh_audio.sh.audio.channels, state->audio_channels);
        put_uint32(&sh_audio.sh.audio.blockalign, 1);
        put_uint32(&sh_audio.sh.audio.avgbytespersec, state->audio_channels * state->audio_rate * 2);   // 16 bits
        memcpy(&hdbuf[1], &sh_audio, sizeof(sh_audio));
        hdbuf[0] = 1;

        ogg_header.packet = hdbuf;
        ogg_header.bytes = sizeof(sh_audio) + 1;
        ogg_header.b_o_s = 1;
        ogg_header.e_o_s = 0;
        ogg_header.packetno = saudio.packetno++;
        ogg_header.granulepos = 0;
        ogg_stream_packetin(&saudio.os, &ogg_header);

        if((rez = ogm_flush_to_file(&saudio)) != 0)
                return rez;
        memset(hdbuf, 0, sizeof(hdbuf));
        hdbuf[0] = PACKET_TYPE_COMMENT;
        memcpy(&hdbuf[1], "vorbis", 6);
        pos=7;
        put_uint32(&hdbuf[pos], strlen(vendor));
        pos += 4;
        strcpy(&hdbuf[pos], vendor);
        pos += strlen(vendor);
        put_uint32(&hdbuf[pos], 0);
        pos += 4;
        hdbuf[pos++] = 1;
        ogg_header.packet = hdbuf;
        ogg_header.bytes = pos;
        ogg_header.b_o_s = 0;
        ogg_header.e_o_s = 0;
        ogg_header.packetno = saudio.packetno++;;
        ogg_header.granulepos = 0;
        ogg_stream_packetin(&saudio.os, &ogg_header);

        if((rez = ogm_flush_to_file(&saudio)) != 0)
                return rez;
        return 0;
}

int camogm_audio_end(void) {
        ogg_packet ogg_header;
        int rez;
        char buf[1] = {0x00};

        ogg_header.packet = buf;
        ogg_header.bytes = 1;
        ogg_header.b_o_s = 0;
        ogg_header.e_o_s = 1;
        ogg_header.packetno = saudio.packetno++;
        ogg_header.granulepos = saudio.granulepos;
        ogg_stream_packetin(&saudio.os, &ogg_header);
        if((rez = ogm_flush_to_file(&saudio)) != 0)
                return rez;
        return 0;
}

void camogm_audio_ogm_push(void *buf, int len, long granules_shift, int prefix) {
        u_int16_t samp_in_subpacket = granules_shift;
        unsigned char *h = (unsigned char *)buf - (1 + sizeof(samp_in_subpacket));
        int j;
        int rez;
        
        h[0] = 0x00;
        h[0] = ((sizeof(samp_in_subpacket) & 3) << 6) + ((sizeof(samp_in_subpacket) & 4) >> 1);
        h[0] |= PACKET_IS_SYNCPOINT;
        for(j = 0; j < sizeof(samp_in_subpacket); j++) {
                h[j + 1] = (unsigned char)(samp_in_subpacket & 0xFF);
                samp_in_subpacket = samp_in_subpacket >> 8;
        }
        ogg_packet packet;
        packet.bytes = len + 1 + sizeof(samp_in_subpacket);
        packet.packet = (char *)h;
        packet.b_o_s = 0;
        packet.e_o_s = 0;
        packet.packetno = saudio.packetno++;;
        packet.granulepos = saudio.granulepos;
        saudio.granulepos += (ogg_int64_t)granules_shift;
        ogg_stream_packetin(&saudio.os, &packet);
        rez = ogm_flush_to_file(&saudio);
}

---