apps/camogm2/camogm_mov.c

Go to the documentation of this file.

/*!***************************************************************************
*! FILE NAME  : camogm_mov.c
*! DESCRIPTION: Provides writing to file compatible with Apple Quicktime(R) for camogm
*!TODO: Nothing yet here, will be added ASAP
*! 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_mov.c,v $
*!  Revision 1.5  2008/06/06 10:53:32  spectr_rain
*!  clean
*!
*!  Revision 1.4  2008/06/02 19:49:41  spectr_rain
*!  fixed QuickTime compatibility - need to cleanup
*!
*!  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.4  2008/04/11 23:09:33  elphel
*!  modified to handle kml generation
*!
*!  Revision 1.3  2007/11/19 17:00:20  elphel
*!  removed wrong dependency
*!
*!  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:57  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_mov.h"
#include "camogm.h"

#define QUICKTIME_MIN_HEADER 0x300 // Quicktime header length (w/o index tables) enough to accomodate 
                                   // static data .

//#define D4(x) {x; fflush(debug_file);}
//FILE *debug_file;

const char hexStr[] = "0123456789abcdef";
char qtSourceFileName_video[] = "/etc/qt_video";
char qtSourceFileName_audio[] = "/etc/qt_audio";
//*/
char *qtSourceFileName = NULL;
char comStr[1024];
int     width = 1280;
int height = 1024;
int nframes = 100;
int sample_dur = 80;
int samplesPerChunk = 10;
int     framesize = 80000;
int     timescale = 600;
int * sizes;    // array of frame sizes
int iPos; 
//int oPos; //!position in the string "oFile"
int ofd; // output file descriptor (file opened by the caller)
int iFileLen;
char * q_template = NULL;
long headerSize = 0;
const char *iFile = NULL;

unsigned long audio_rate = 0;
unsigned short audio_channels = 0;
int audio_timescale;
long audio_duration;

int quicktime_template_parser (const char * i_iFile, 
           int i_ofd,   
           int i_width, // width in pixels
           int i_height,
           int i_nframes,
           int i_sample_dur,
           int i_samplesPerChunk,
           int i_framesize,
           int i_timescale,
           int * i_sizes,
           int   data_start // put zero if the header is written before data (no gap)
         );
void putBigEndian(unsigned long d, int l);
int parse_special(void);
int parse (int top);

int camogm_init_mov(void) {
        FILE* qt_header;
        int size;
        qtSourceFileName = qtSourceFileName_video;
        if(ctx_a.audio_present) {
                qtSourceFileName = qtSourceFileName_audio;
        }
        if((qt_header = fopen(qtSourceFileName, "r")) == NULL) {
                D0(fprintf (debug_file,"Error opening Quicktime header template %s for reading\n", qtSourceFileName));
                return -CAMOGM_FRAME_FILE_ERR;
        }
        fseek(qt_header, 0, SEEK_END);
        size = ftell(qt_header);
        if(!((q_template = malloc(size + 1)))) {
                D0(fprintf (debug_file,"Could not allocate %d bytes of memory for Quicktime header template\n", (size+1)));
                fclose(qt_header);
                return -CAMOGM_FRAME_MALLOC ;
        }
        fseek(qt_header, 0, SEEK_SET); //rewind
        if(fread(q_template, size, 1, qt_header) < 1) {
                D0(fprintf(debug_file, "Could not read %d bytes of Quicktime header template from %s\n", (size + 1), qtSourceFileName));
                free(q_template);
                q_template = NULL;
                fclose(qt_header);
                return -CAMOGM_FRAME_FILE_ERR;
        }
        q_template[size] = 0;
        return 0;
}

void camogm_free_mov(void) {
        if(q_template) {
                free(q_template);
                q_template = NULL;
        }
}

int camogm_start_mov(void) {
        state->frames_pos = 0;

        // allocate memory for the frame index table
DA(fprintf(stderr, "max_frames == %d\n", state->max_frames););
        if(!((state->audio_samples_to_chunk = malloc(12 * 3))))
                return -CAMOGM_FRAME_MALLOC;
        state->audio_samples_to_chunk[0] = -1;
        state->audio_samples_to_chunk[1] = -1;
        state->audio_samples_to_chunk[2] = -1;

        if(!((state->frames_len = (unsigned long *)malloc(4 * state->max_frames))))
                return -CAMOGM_FRAME_MALLOC;
        state->offset_current = 0;
        // open file for writing
        sprintf(state->path, "%s%010ld_%06ld.mov", state->path_prefix, state->frame_params.timestamp_sec, state->frame_params.timestamp_usec);
        if(((state->ivf = open(state->path, O_RDWR | O_CREAT, 0777))) < 0){
                D0(fprintf(debug_file, "Error opening %s for writing, returned %d, errno=%d\n", state->path, state->ivf, errno));
                return -CAMOGM_FRAME_FILE_ERR;
        }
        // skip header (plus extra)
        // Quicktime (and else?) - frame data start (0xff 0xd8...) 
        int data_offset = QUICKTIME_MIN_HEADER + 16;
        data_offset += 4 * (state->max_frames); // space for sample size atom - video
        data_offset += 4 * (state->max_frames); // space for chunk offsets atom - video
        if(ctx_a.audio_present) {
                data_offset += 4 * (state->max_frames); // space for chunk offsets atom - audio
                data_offset += 12 * 3; // space for samples size atom - audio
        }
        // add audio tables space
//      state->frame_data_start = QUICKTIME_MIN_HEADER + 16 + 4 * (state->max_frames) + (4 * (state->max_frames)) / (state->frames_per_chunk); // 8 bytes for "skip" tag
        state->frame_data_start = data_offset;
        lseek(state->ivf, state->frame_data_start, SEEK_SET);
        return 0;
}

int camogm_frame_mov(void) {
        int i, j;
        ssize_t iovlen, l;
        struct iovec chunks_iovec[7];
        l = 0;
        for(i = 0; i < state->chunk_index - 1; i++) {
                chunks_iovec[i].iov_base = state->packetchunks[i + 1].chunk;
                chunks_iovec[i].iov_len = state->packetchunks[i + 1].bytes;
                l += chunks_iovec[i].iov_len;
        }
        iovlen = writev(state->ivf, chunks_iovec, state->chunk_index - 1);
        if(iovlen < l) {
                fprintf(stderr, "MOV: fail to save frame...\n");
                j = errno;
                D0(fprintf(debug_file, "writev error %d (returned %d, expected %d)\n", j, iovlen, l));
                close(state->ivf);
                state->ivf = -1;
                return -CAMOGM_FRAME_FILE_ERR;
        }
        state->frames_len[state->frames_pos] = l; // 0x00 mask for video
        state->frames_pos++;

        state->offset_current += l;

        if(state->frames_pos >= state->max_frames - 16)
                return -CAMOGM_FRAME_FILE_ERR;
        // check here space ???
        return 0;
}

int camogm_audio_mov(void *buf, int len, int slen) {
//return;
        int i, j;
        ssize_t wrlen;
        wrlen = write(state->ivf, buf, len);
        if(wrlen < len) {
                j = errno;
                D0(fprintf(debug_file, "writev error %d (returned %d, expected %d)\n", j, wrlen, len));
                close(state->ivf);
                state->ivf = -1;
                return -CAMOGM_FRAME_FILE_ERR;
        }
        unsigned long k;
        k = len;
        k |= 0x80000000;
        state->frames_len[state->frames_pos] = k;
        state->frames_pos++;

        if(state->audio_samples_to_chunk[0] == -1) {
                state->audio_samples_to_chunk[0] = slen;
        } else {
                state->audio_samples_to_chunk[1]= state->audio_samples_to_chunk[2];
                state->audio_samples_to_chunk[2]= slen;
        }
        state->offset_current += wrlen;
        state->audio_frameno++;
        state->audio_samples += slen;
//fprintf(stderr, "push_audio...\n");
        // check here space ???
        return 0;
}

int camogm_end_mov(void){
        off_t l/*,he;
        unsigned char mdat_tag[8];
        unsigned char skip_tag[]="\0\0\0\0skip"*/;
        timescale = 10000; 

        l = lseek(state->ivf, 0, SEEK_CUR) - (state->frame_data_start) + 8; 
//      lseek(state->ivf, state->frame_data_start, SEEK_SET);
        // fill in the header in the beginning of the file
        lseek(state->ivf, 0, SEEK_SET);
fprintf(stderr, "frameno == %d, frames_per_chunk == %d\n", state->frameno, state->frames_per_chunk);
        quicktime_template_parser(q_template, 
                state->ivf,   
                state->width, 
                state->height,
                state->frameno, // frames count...
                state->frame_period / (1000000 / timescale),
                state->frames_per_chunk,
                0, 
                (int) ((float)timescale/(state->timescale)),
//              state->frame_lengths, //! array of frame lengths to build an index
                NULL, 
                state->frame_data_start
                );
        close(state->ivf);
        state->ivf = -1;
        if(state->frames_len) {
                free(state->frames_len);
                state->frames_len = NULL;
        }
        if(state->audio_samples_to_chunk) {
                free(state->audio_samples_to_chunk);
                state->audio_samples_to_chunk = NULL;
        }
        return 0;
}

/*
 starts with the input file pointer just after the opening "{",
 and output file - at the beginning of it's output
 on exit - input pointer - after closing "}", output after it's output
*/

void putBigEndian(unsigned long d, int l) {
        unsigned char od[4];
        od[3] = d;
        od[2] = d >> 8;
        od[1] = d >> 16;
        od[0] = d >> 24;
        if(l)
                write(ofd, &od[4 - l], l);
//    oPos+=l;
}

char * sfgets(char * str, int size, const char * stream, int * pos) {
        int l;
        const char *eol = strchr(&stream[*pos], '\n');
        if(!eol)
                eol = stream + (strlen(stream) - 1); 
        l = (eol - stream) - (*pos);
//      if(l >= size) eol = stream + (*pos + size - 1);
        if(l >= size)
                l = size - 1;
        memcpy(str, &stream[*pos], l);
        str[l] = '\0';
        *pos += l;
        return str;
}

int parse_special(void) {
        time_t ltime;
        int n,j,l;
        unsigned long k;
        char str[256];
        char c;
        int i = 0;
        int gap;
//      while(((c = iFile[iPos++]) != 0x20) && (c != 0x09) && (c != 0x0a) && (c != 0x0d) && (c != 0x0) && (i < 255) && (iPos < iFileLen))
        while(((c = iFile[iPos++]) != ' ') && (c != '\t') && (c != '\n') && (c != '\r') && (c != '\0') && (i < 255) && (iPos < iFileLen))
                str[i++] = c;
        str[i] = 0;
        
        D4(fprintf (debug_file, "parse_special, str=!%s\n",str));

        if(strcmp(str, "mdata") == 0)  { putBigEndian(headerSize, 4);return 0;} // will put zeroes on pass 1
        if(strcmp(str, "height") == 0) { putBigEndian(height,2);return 0;}
        if(strcmp(str, "width") == 0)  { putBigEndian(width,2);return 0;}
        if(strcmp(str, "nframes") == 0)  { putBigEndian(nframes,4);return 0;}
        if(strcmp(str, "timescale") == 0)  { putBigEndian(timescale,4);return 0;}
        if(strcmp(str, "duration") == 0)  { putBigEndian(nframes*sample_dur,4);return 0;}

        if(strcmp(str, "audio_channels") == 0)  { putBigEndian(audio_channels, 2); return 0;}
        if(strcmp(str, "audio_rate") == 0)  { putBigEndian(audio_rate, 4); return 0;}
        if(strcmp(str, "audio_timescale") == 0)  { putBigEndian(audio_timescale, 4); return 0;}
        if(strcmp(str, "audio_duration") == 0)  { putBigEndian(audio_duration, 4); return 0;}
        if(strcmp(str, "audio_frames") == 0)  { putBigEndian(state->audio_frameno, 4); return 0;}
        if(strcmp(str, "audio_samples") == 0)  { putBigEndian(state->audio_samples, 4); return 0;}
        if(strcmp(str, "audio_bytes_per_frame") == 0)  { putBigEndian(state->audio_channels * 2, 4); return 0;}

        if(strcmp(str, "audio_stsz") == 0)  {
                putBigEndian(state->audio_channels * 2, 4);
                putBigEndian(state->audio_samples, 4);
                return 0;
        }
        if(strcmp(str, "audio_stco") == 0)  {   // (4 + 4 * chunk_count) bytes
                long offset = 0;
                n = state->audio_frameno;
//fprintf(stderr, "chunk_offsets; n == %d; nframes == %d; samplesPerChunk == %d\n", n, nframes, samplesPerChunk);
                putBigEndian(n, 4);
                j = 0;
                for(i = 0; i < state->frames_pos; i++) {
                        k = state->frames_len[i];
                        if(k & 0x80000000) {
                                l = offset;
                                putBigEndian(headerSize + l, 4);
                                j++;
                        }
                        offset += k & 0x7FFFFFFF;
                }
                if(j != n)
                        fprintf(stderr, "MOV: wrong records for \"audio_stco\": have write: %d, need to write: %d\n", j, n);
                return 0;
        }
        // TODO!!!
        if(strcmp(str, "audio_stsc") == 0)  {
                n = 0;
                for(i = 0; i < 3; i++) {
                        if(state->audio_samples_to_chunk[i] != -1) {
                                n++;
                        }
                }
                putBigEndian(n, 4);
                putBigEndian(1, 4);
                putBigEndian(state->audio_samples_to_chunk[0], 4);
                putBigEndian(01, 4); // TODO: 02 ???
                n = 2;
                if(state->audio_samples_to_chunk[1] != -1) {
                        putBigEndian(n, 4);
                        putBigEndian(state->audio_samples_to_chunk[1], 4);
                        putBigEndian(01, 4);
                        n = state->audio_frameno;
                }
                if(state->audio_samples_to_chunk[2] != -1) {
                        putBigEndian(n, 4);
                        putBigEndian(state->audio_samples_to_chunk[2], 4);
                        putBigEndian(01, 4);
                }
                return 0;
        }
        if(strcmp(str, "audio_samples_chunk") == 0)  { putBigEndian(1, 4);return 0;} // will put zeroes on pass 1

        if(strcmp(str, "frame_duration") == 0)  { putBigEndian(sample_dur,4);return 0;}
        if(strcmp(str, "samples_chunk") == 0)  { putBigEndian(samplesPerChunk, 4);return 0;} // will put zeroes on pass 1

        if(strcmp(str, "sample_sizes") == 0)  {
                j = 0;
                n = nframes;
                for(i = 0; i < state->frames_pos; i++) {
                        k = state->frames_len[i];
                        if((k & 0x80000000) == 0x0) {
                                l = k;
                                putBigEndian(l, 4);
                                j++;
                        }
                }
                if(j != n)
                        fprintf(stderr, "MOV: wrong records for \"samples_sizes\": have write: %d, need to write: %d\n", j, n);
                return 0;
        }
        if(strcmp(str, "chunk_offsets") == 0)  {
                long offset = 0;
                n = nframes;
                j = 0;
                putBigEndian(n, 4);
                for(i = 0; i < state->frames_pos; i++) {
                        k = state->frames_len[i];
                        if((k & 0x80000000) == 0x0) {
                                l = offset;
                                putBigEndian(headerSize + l, 4);
                                j++;
                        }
                        offset += k & 0x7FFFFFFF;
                }
                if(j != n)
                        fprintf(stderr, "MOV: wrong records for \"samples_sizes\": have write: %d, need to write: %d\n", j, n);
                return 0;
        }

        // a hack - include length'skip if data position (header size is known and there is a gap)
        if(strcmp(str, "data_size") == 0)  {
                gap = headerSize - lseek(ofd, 0, SEEK_CUR) - 8;
                if(gap > 0) { 
                        D4(fprintf (debug_file, "Inserting a skip tag to compensate for a gap (%d bytes) between the header and the frame data\n", gap));
                        if(gap < 8) {
                                D0(fprintf(debug_file, "not enough room to insret 'skip' tag - %d (need 8)\n", gap));
                                return -1; 
                        }
                        D4(fprintf(debug_file, "writing hex %x, %x bytes\n", gap, 4));
                        putBigEndian(gap, 4);
                        D4(fprintf(debug_file, "writing string <%s>\n","skip"));
                        write(ofd, "skip", 4);
                        lseek(ofd, gap - 8, SEEK_CUR); 
                }
                if(sizes != NULL) {
                        l = 0;
                        for(i = 0; i < nframes; i++)
                                l += sizes[i];
                        D4(fprintf(debug_file, "writing hex %x, %x bytes\n", l, 4));
                        putBigEndian(l, 4);
                } else
                        putBigEndian(nframes * framesize, 4);
                return 0;
        }
        if(strcmp(str, "time") == 0)  {
                time(&ltime);
                ltime += 2082801600;    // 1970->1904// 31,557,600 seconds/year
                putBigEndian(ltime, 4);
//fprintf(stderr, "put !time...\n");
                return 0;
        }
        return -1;
}

int parse(int top) {    // if top - will not include length
        long out_start, out_end;
        char c;
        unsigned long d, l;
        char *cp;
        D4(fprintf(debug_file, "parse(%x)\n", top));
        c = iFile[iPos++];
        D5(fprintf(debug_file, "%c", c));
        out_start = lseek(ofd, 0, SEEK_CUR);

        if(!top)
                putBigEndian(0, 4);
        while((iPos < iFileLen ) && (c != '}')) {
                if((c != ' ') && (c != '\t') && (c != '\r') && (c != '\n')) {
                        if(c == '!') {
                                if(parse_special() < 0)
                                        return -1;
                        }
                        // children atoms
                        else {
                                if(c == '{') {
                                        if(parse(0) < 0)
                                                return -1;
                                        // skip comments
                                } else {
                                        if(c == '#') {
                                                sfgets(comStr, sizeof(comStr), iFile, &iPos);
                                        } else {
                                                if(c == '\'') {
                                                        sfgets(comStr, sizeof(comStr), iFile, &iPos);
                                                        if((cp = strchr(comStr, 0x0a)) != NULL) cp[0] = 0;
                                                        if((cp = strchr(comStr, 0x0d)) != NULL) cp[0] = 0;
                                                        if((cp = strchr(comStr, '#')) != NULL) cp[0] = 0;
                                                        cp = comStr + strlen(comStr) - 1;
                                                        while((cp > comStr) && ((cp[0] == 0x20) || (cp[0] == 0x09)))
                                                                cp--;
                                                        cp[1] = 0;
                                                        write(ofd, comStr, strlen(comStr));
                                                        D4(fprintf(debug_file, "writing string <%s>\n", comStr));
                                                } else {
                                                        if(strchr(hexStr, c)) {
                                                                d = 0;
                                                                l = 1;
                                                                do {
                                                                        d = (d << 4) + (strchr(hexStr, c) - hexStr);
                                                                        l++;
                                                                } while((iPos < iFileLen) && (l <= 8) && (strchr(hexStr, (c = iFile[iPos++]))));
                                                                l = (l) >> 1;
                                                                putBigEndian(d, l);
                                                                D4(fprintf(debug_file, "writing hex %lx, %lx bytes\n", d, l));
                                                        } else {
                                                                if(c == '}') {
                                                                        break;
                                                                } else {
                                                                        return -1;
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                c = iFile[iPos++];
        }       
        // fread fseek ftell
        if(!top) {
                out_end = lseek(ofd, 0, SEEK_CUR);
                lseek(ofd, out_start, SEEK_SET);
                putBigEndian((out_end - out_start), 4);
                lseek(state->ivf, out_end, SEEK_SET);
        }
        return 0;
}


int quicktime_template_parser (const char * i_iFile, 
           int i_ofd,   
           int i_width, // width in pixels
           int i_height,
           int i_nframes,
           int i_sample_dur,
           int i_samplesPerChunk,
           int i_framesize,
           int i_timescale,
           int * i_sizes,
           int   data_start // zero if dfata is not written yet (will be no gap)
         ) {
        iFile=           i_iFile;
        width=           i_width;
        height=          i_height;
        nframes=         i_nframes;
        sample_dur=      i_sample_dur;
        samplesPerChunk= i_samplesPerChunk;
        framesize=       i_framesize;
        timescale=       i_timescale;
        sizes=           i_sizes;
        iPos=0; 
        ofd=             i_ofd;
        iFileLen=        strlen(iFile);
        lseek(ofd, 0, SEEK_SET);

        audio_timescale = state->audio_rate;
        audio_rate = audio_timescale;
        audio_rate <<= 16;
        audio_duration = state->audio_samples;//ctx_a.audio_count;
        audio_channels = state->audio_channels;

        if(data_start)
                headerSize = data_start;
        D3(fprintf(debug_file, "PASS I\n"));
        while(iPos < iFileLen)
                parse(1); // pass 1
        if(!headerSize)
                headerSize = lseek(ofd, 0, SEEK_CUR);
        iPos = 0;
        lseek(ofd, 0, SEEK_SET);
        D3(fprintf(debug_file, "PASS II\n"));
        while(iPos < iFileLen)
                parse(1); // pass 2
        return 0;
}

---