ltcgen.c

/* Linear Time Code encoder
 * Copyright (C) 2012, 2013 Robin Gareus <robin@gareus.org>
 *
 * 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 2 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 <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <signal.h>
#include <libgen.h>
#include <getopt.h>
#include <pthread.h>
#include <time.h>
#include <sys/time.h>
#include <ltc.h>
#include <sndfile.h>

#include "timecode.h"
#include "common_ltcgen.h"
#include "myclock.h"

LTCEncoder * encoder = NULL;
ltcsnd_sample_t * enc_buf = NULL;

/* options */
static int samplerate = 48000;
int fps_num = 25;
int fps_den = 1;
int fps_drop = 0;
enum LTC_TV_STANDARD ltc_tv = LTC_TV_625_50;

static int reverse = 0;
static int sync_now =1; // set to 1 to start timecode at date('now')
float volume_dbfs = -18.0;
unsigned char user_bit_array[MAX_USER_BITS];

static double duration = 60000.0; // ms
static volatile int active = 0;

SNDFILE* sf = NULL;
int sf_format = SF_FORMAT_PCM_16;

void main_loop_reverse(void) {
  LTCFrame f;
  const long long int end = ceil(duration * samplerate / 1000.0);
  long long int written = 0;
  active=1;
  short *snd = NULL;
  const short smult = rint(pow(10, volume_dbfs/20.0) * 32767.0);

  while(active==1 && (duration <= 0 || end >= written)) {
      int byteCnt;
      for (byteCnt = 9; byteCnt >= 0; byteCnt--) {
	int i;
	ltc_encoder_encode_byte(encoder, byteCnt, -1.0);
	const int len = ltc_encoder_get_buffer(encoder, enc_buf);
	if (!snd) snd = malloc(len * sizeof(short));
	for (i=0;i<len;i++) {
	  const short val = ( (int)(enc_buf[i] - 128) * smult / 90 );
	  snd[i] = val;
	}
	sf_writef_short(sf, snd, len);
	written += len;
	if (end < written) break;
      } /* end byteCnt - one video frames's worth of LTC */

      ltc_encoder_get_frame(encoder, &f);
      ltc_frame_decrement(&f, ceil(fps_num/fps_den),
	  fps_num/(double)fps_den == 25.0? LTC_TV_625_50 : LTC_TV_525_60,
	  LTC_USE_DATE);
      ltc_encoder_set_frame(encoder, &f);
  }
  free(snd);
  printf("wrote %lld audio-samples\n", written);
}

void main_loop(void) {
  const long long int end = ceil(duration * samplerate / 1000.0);
  long long int written = 0;
  active=1;
  short *snd = NULL;
  const short smult = rint(pow(10, volume_dbfs/20.0) * 32767.0);

  while(active==1 && (duration <= 0 || end >= written)) {
      int byteCnt;
      for (byteCnt = 0; byteCnt < 10; byteCnt++) {
	int i;
	ltc_encoder_encode_byte(encoder, byteCnt, 1.0);
	const int len = ltc_encoder_get_buffer(encoder, enc_buf);
	if (!snd) snd = malloc(len * sizeof(short));
	for (i=0;i<len;i++) {
	  const short val = ( (int)(enc_buf[i] - 128) * smult / 90 );
	  snd[i] = val;
	}
	sf_writef_short(sf, snd, len);
	written += len;
	if (end < written) break;
      } /* end byteCnt - one video frames's worth of LTC */
      ltc_encoder_inc_timecode(encoder);
  }
  free(snd);
  printf("wrote %lld audio-samples\n", written);
}

/**************************
 * main application code
 */

char *program_name;

static struct option const long_options[] =
{
  {"help", no_argument, 0, 'h'},
  {"version", no_argument, 0, 'V'},
  {"fps", required_argument, 0, 'f'},
  {"date", required_argument, 0, 'd'},
  {"volume", required_argument, 0, 'g'},
  {"reverse", no_argument, 0, 'r'},
  {"timezone", required_argument, 0, 'z'},
  {"duration", required_argument, 0, 'l'},
  {"minuteswest", required_argument, 0, 'm'},
  {"timecode", required_argument, 0, 't'},
  {"samplerate", required_argument, 0, 's'},
  {"userbits", required_argument, 0, 'u'},
  {NULL, 0, NULL, 0}
};

static void usage (int status) {
  printf ("ltcgen - generate linear time code audio-file.\n");
  printf ("Usage: %s [OPTION] <output-file>\n", basename(program_name));
  printf ("\n"
"Options:\n"
" -d, --date datestring      set date, format is either DDMMYY or MM/DD/YY\n"
" -f, --fps fps              set frame-rate NUM[/DEN][ndf|df] default: 25/1ndf \n"
" -g, --volume float         set output level in dBFS default -18db\n"
" -h, --help                 display this help and exit\n"
" -l, --duration time        set duration of file to encode [[[HH:]MM:]SS:]FF.\n"
" -m, --timezone tz          set timezone in minutes-west of UTC\n"
" -r, --reverse              encode backwards from start-time\n"
" -s, --samplerate sr        specify samplerate (default 48000)\n"
" -t, --timecode time        specify start-time/timecode [[[HH:]MM:]SS:]FF\n"
" -u, --userbits bcd         specify fixed BCD user bits (max. 8 BCD digits)\n"
"                            CAUTION: This ignores any date/timezone settings!\n"
" -V, --version              print version information and exit\n"
" -z, --timezone tz          set timezone +HHMM\n"
"\n"
"Unless a timecode (-t) is given, the current time/date are used.\n"
"Date (-d) and timezone (-z, -m) are only used if a timecode is given.\n"
"The timezome may be specified either as HHMM zone, or in minutes-west of UTC.\n"
"\n"
"If the duration is <=0, ltcgen write until it receives SIGINT.\n"
"\n"
"The output file-format is WAV, signed 16 bit, mono.\n"
"\n"
"Report bugs to <robin@gareus.org>.\n"
"Website and manual: <https://github.com/x42/ltc-tools>\n"
"\n");
  exit (status);
}

void endnow(int sig) {
  active=2;
}

int main (int argc, char **argv) {
  int c;

  program_name = argv[0];
  long long int msec = 0;// start timecode in ms from 00:00:00.00
  long int date = 0;// bcd: 201012 = 20 Oct 2012
  long int tzoff = 0;// time-zone in minuteswest
  int custom_user_bits = 0;

  while ((c = getopt_long (argc, argv,
	   "h"	/* help */
	   "f:"	/* fps */
	   "d:"	/* date */
	   "g:"	/* gain^wvolume */
	   "l:"	/* duration */
	   "r"	/* reverse */
	   "s:"	/* samplerate */
	   "t:"	/* timecode */
	   "z:"	/* timezone */
	   "m:"	/* timezone */
	   "u:" /* free format user bits */
	   "V",	/* version */
	   long_options, (int *) 0)) != EOF)
  {
      switch (c) {
	case 'V':
	  printf ("%s %s\n\n",basename(argv[0]), VERSION);
	  printf (
		  "Copyright (C) 2012 Robin Gareus <robin@gareus.org>\n"
		  "This is free software; see the source for copying conditions.  There is NO\n"
		  "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
		  );
	  exit (0);

	case 'h':
	  usage (0);

	case 'f':
	  parse_fps(optarg);
	  break;

	case 'd':
	  {
	    date=atoi(optarg);
	    char *tmp = optarg;
	    if (tmp && (tmp = strchr(tmp, '/'))) date=date*100+(atoi(++tmp)*10000);
	    if (tmp) {
	      if ((tmp = strchr(tmp, '/'))) date+=atoi(++tmp);
	      else date+=12;// 2012
	    }
	  }
	  break;

	case 'g':
	  volume_dbfs = atof(optarg);
	  if (volume_dbfs > 0) volume_dbfs=0;
	  if (volume_dbfs < -96.0) volume_dbfs=-96.0;
	  printf("Output volume %.2f dBfs\n", volume_dbfs);
	  break;

	case 'm':
	  tzoff=atoi(optarg); //minuteswest
	  break;

	case 'r':
	  reverse = 1;
	  break;

	case 's':
	  samplerate=atoi(optarg);
	  break;

	case 'z':
	  {
	    int hh = atoi(optarg)/100;
	    tzoff= 60*hh + ((atoi(optarg)-(100*hh))%60); // HHMM
	  }
	  break;

	case 'l':
	  {
	    int bcd[SMPTE_LAST];
	    parse_string(rint(fps_num/(double)fps_den), bcd, optarg);
	    duration = bcdarray_to_framecnt(bcd) * 1000.0 / (((double)fps_num)/(double)fps_den);
	  }
	  break;

	case 't':
	  {
	    sync_now=0;
	    int bcd[SMPTE_LAST];
	    parse_string(rint(fps_num/(double)fps_den), bcd, optarg);
	    msec = bcdarray_to_framecnt(bcd) * 1000.0 / (((double)fps_num)/(double)fps_den);
	  }
	  break;

	case 'u':
	  {
	    custom_user_bits = 1;
	    parse_user_bits(user_bit_array, optarg);
	    /* Free format user bits, so reset any date/timezone settings. */
	    date = 0;
	    tzoff = 0;
	  }
	  break;

	default:
	  usage (EXIT_FAILURE);
      }
  }

  if (optind >= argc) {
    usage (EXIT_FAILURE);
  }

  fps_sanity_checks();

  {
    SF_INFO sfnfo;
    memset(&sfnfo, 0, sizeof(SF_INFO));
    sfnfo.samplerate = samplerate;
    sfnfo.channels = 1;
    sfnfo.format = SF_FORMAT_WAV | sf_format;
    sf = sf_open(argv[optind], SFM_WRITE, &sfnfo);
    if (!sf) {
      fprintf(stderr, "cannot open output file '%s'\n", argv[optind]);
      return 1;
    }
  }
  printf("writing to '%s'\n", argv[optind]);
  printf("samplerate: %d, duration %.1f ms\n", samplerate, duration);

  encoder_setup(fps_num, fps_den, ltc_tv, samplerate,
      ((date != 0) ? LTC_USE_DATE : 0) | ((sync_now) ? (LTC_USE_DATE|LTC_TC_CLOCK) : 0)
      );

  if (sync_now==0) {
#if 0 // DEBUG
    printf("date: %06ld (DDMMYY)\n", date);
    printf("time: %lldms\n", msec);
    printf("zone: %c%02d%02d = %ld minutes west\n", tzoff<0?'-':'+', abs(tzoff/60),abs(tzoff%60), tzoff);
#endif
    set_encoder_time(1000.0*msec, date, tzoff, fps_num, fps_den, 1);
  } else {
    struct timespec t;
    long int sync_msec;
    my_clock_gettime(&t);
    sync_msec = (t.tv_sec%86400)*1000 + (t.tv_nsec/1000000);

    time_t now = t.tv_sec;
    struct tm gm;
    long int sync_date = 0;
    if (gmtime_r(&now, &gm))
      sync_date = gm.tm_mday*10000 + (gm.tm_mon + 1)*100 + (gm.tm_year % 100);
    sync_msec += 1000.0 * ltc_frame_alignment(samplerate * fps_den / (double) fps_num, ltc_tv) / samplerate;
    set_encoder_time(1000.0*sync_msec, custom_user_bits ? 0 : sync_date, 0, fps_num, fps_den, 1);
  }

  if (custom_user_bits)
    set_user_bits(user_bit_array);

  signal(SIGINT, endnow);

  if (reverse)
    main_loop_reverse();
  else
    main_loop();

  if (sf) sf_close(sf);
  if (enc_buf) free(enc_buf);
  if (encoder) ltc_encoder_free(encoder);
  return(0);
}

/* vi:set ts=8 sts=2 sw=2: */