libs/libltc/ltc.c

   1 /*
   2    libltc - en+decode linear timecode
   3
   4    Copyright (C) 2006-2012 Robin Gareus <robin@gareus.org>
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU Lesser General Public License as
   8    published by the Free Software Foundation, either version 3 of the
   9    License, or (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with this library.
  18    If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <math.h>
  25
  26 #include "ltc/ltc.h"
  27 #include "ltc/decoder.h"
  28 #include "ltc/encoder.h"
  29
  30 /* -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  31  * Decoder
  32  */
  33
  34 LTCDecoder* ltc_decoder_create(int apv, int queue_len) {
  35         LTCDecoder* d = (LTCDecoder*) calloc(1, sizeof(LTCDecoder));
  36         if (!d) return NULL;
  37
  38         d->queue_len = queue_len;
  39         d->queue = (LTCFrameExt*) calloc(d->queue_len, sizeof(LTCFrameExt));
  40         if (!d->queue) {
  41                 free(d);
  42                 return NULL;
  43         }
  44         d->biphase_state = 1;
  45         d->snd_to_biphase_period = apv / 80;
  46         d->snd_to_biphase_lmt = (d->snd_to_biphase_period * 3) / 4;
  47
  48         d->snd_to_biphase_min = SAMPLE_CENTER;
  49         d->snd_to_biphase_max = SAMPLE_CENTER;
  50         d->frame_start_prev = -1;
  51         d->biphase_tic = 0;
  52
  53         return d;
  54 }
  55
  56 int ltc_decoder_free(LTCDecoder *d) {
  57         if (!d) return 1;
  58         if (d->queue) free(d->queue);
  59         free(d);
  60
  61         return 0;
  62 }
  63
  64 void ltc_decoder_write(LTCDecoder *d, ltcsnd_sample_t *buf, size_t size, ltc_off_t posinfo) {
  65         decode_ltc(d, buf, size, posinfo);
  66 }
  67
  68 #define LTCWRITE_TEMPLATE(FN, FORMAT, CONV) \
  69 void ltc_decoder_write_ ## FN (LTCDecoder *d, FORMAT *buf, size_t size, ltc_off_t posinfo) { \
  70         ltcsnd_sample_t tmp[1024]; \
  71         size_t remain = size; \
  72         while (remain > 0) { \
  73                 int c = (remain > 1024) ? 1024 : remain; \
  74                 int i; \
  75                 for (i=0; i<c; i++) { \
  76                         tmp[i] = CONV; \
  77                 } \
  78                 decode_ltc(d, tmp, c, posinfo + (ltc_off_t)c); \
  79                 remain -= c; \
  80         } \
  81 }
  82
  83 LTCWRITE_TEMPLATE(float, float, 128 + (buf[i] * 127.0))
  84 LTCWRITE_TEMPLATE(s16, short, 128 + (buf[i] >> 8))
  85 LTCWRITE_TEMPLATE(u16, short, (buf[i] >> 8))
  86
  87 int ltc_decoder_read(LTCDecoder* d, LTCFrameExt* frame) {
  88         if (!frame) return -1;
  89         if (d->queue_read_off != d->queue_write_off) {
  90                 memcpy(frame, &d->queue[d->queue_read_off], sizeof(LTCFrameExt));
  91                 d->queue_read_off++;
  92                 if (d->queue_read_off == d->queue_len)
  93                         d->queue_read_off = 0;
  94                 return 1;
  95         }
  96         return 0;
  97 }
  98
  99 void ltc_decoder_queue_flush(LTCDecoder* d) {
 100         while (d->queue_read_off != d->queue_write_off) {
 101                 d->queue_read_off++;
 102                 if (d->queue_read_off == d->queue_len)
 103                         d->queue_read_off = 0;
 104         }
 105 }
 106
 107 int ltc_decoder_queue_length(LTCDecoder* d) {
 108         return (d->queue_write_off - d->queue_read_off + d->queue_len) % d->queue_len;
 109 }
 110
 111 /* -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 112  * Encoder
 113  */
 114
 115 LTCEncoder* ltc_encoder_create(double sample_rate, double fps, enum LTC_TV_STANDARD standard, int flags) {
 116         if (sample_rate < 1)
 117                 return NULL;
 118
 119         LTCEncoder* e = (LTCEncoder*) calloc(1, sizeof(LTCEncoder));
 120         if (!e)
 121                 return NULL;
 122
 123         /*-3.0 dBFS default */
 124         e->enc_lo = 38;
 125         e->enc_hi = 218;
 126
 127         e->bufsize = 1 + ceil(sample_rate / fps);
 128         e->buf = (ltcsnd_sample_t*) calloc(e->bufsize, sizeof(ltcsnd_sample_t));
 129         if (!e->buf) {
 130                 free(e);
 131                 return NULL;
 132         }
 133
 134         ltc_frame_reset(&e->f);
 135         ltc_encoder_reinit(e, sample_rate, fps, standard, flags);
 136         return e;
 137 }
 138
 139 void ltc_encoder_free(LTCEncoder *e) {
 140         if (!e) return;
 141         if (e->buf) free(e->buf);
 142         free(e);
 143 }
 144
 145 int ltc_encoder_reinit(LTCEncoder *e, double sample_rate, double fps, enum LTC_TV_STANDARD standard, int flags) {
 146         if (sample_rate < 1)
 147                 return -1;
 148
 149         size_t bufsize = 1 + ceil(sample_rate / fps);
 150         if (bufsize > e->bufsize) {
 151                 return -1;
 152         }
 153
 154         e->state = 0;
 155         e->offset = 0;
 156         e->sample_rate = sample_rate;
 157         ltc_encoder_set_filter(e, 40.0);
 158         e->fps = fps;
 159         e->flags = flags;
 160         e->standard = standard;
 161         e->samples_per_clock = sample_rate / (fps * 80.0);
 162         e->samples_per_clock_2 = e->samples_per_clock / 2.0;
 163         e->sample_remainder = 0.5;
 164
 165         if (flags & LTC_BGF_DONT_TOUCH) {
 166                 e->f.col_frame = 0;
 167                 if (flags&LTC_TC_CLOCK) {
 168                         e->f.binary_group_flag_bit1 = 1;
 169                 } else {
 170                         e->f.binary_group_flag_bit1 = 0;
 171                 }
 172                 switch (standard) {
 173                         case LTC_TV_625_50: /* 25 fps mode */
 174                                 e->f.biphase_mark_phase_correction = 0; // BGF0
 175                                 e->f.binary_group_flag_bit0 = (flags&LTC_USE_DATE)?1:0; // BGF2
 176                                 break;
 177                         default:
 178                                 e->f.binary_group_flag_bit0 = 0;
 179                                 e->f.binary_group_flag_bit2 = (flags&LTC_USE_DATE)?1:0;
 180                                 break;
 181                 }
 182         }
 183         if ((flags&LTC_NO_PARITY) == 0) {
 184                 ltc_frame_set_parity(&e->f, standard);
 185         }
 186
 187         if (rint(fps*100) == 2997)
 188                 e->f.dfbit = 1;
 189         else
 190                 e->f.dfbit = 0;
 191         return 0;
 192 }
 193
 194 void ltc_encoder_reset(LTCEncoder *e) {
 195         e->state = 0;
 196         e->sample_remainder = 0.5;
 197         e->offset = 0;
 198 }
 199
 200 int ltc_encoder_set_volume(LTCEncoder *e, double dBFS) {
 201         if (dBFS > 0)
 202                 return -1;
 203         double pp = rint(127.0 * pow(10, dBFS/20.0));
 204         if (pp < 1 || pp > 127)
 205                 return -1;
 206         ltcsnd_sample_t diff = ((ltcsnd_sample_t) pp)&0x7f;
 207         e->enc_lo = SAMPLE_CENTER - diff;
 208         e->enc_hi = SAMPLE_CENTER + diff;
 209         return 0;
 210 }
 211
 212 void ltc_encoder_set_filter(LTCEncoder *e, double rise_time) {
 213         /* low-pass-filter
 214          * LTC signal should have a rise time of 40 us +/- 10 us.
 215          *
 216          * rise-time means from <10% to >90% of the signal.
 217          * in each call to addvalues() we start at 50% (SAMPLE_CENTER), so
 218          * here we need half-of it.
 219          */
 220
 221         if (rise_time <= 0)
 222                 e->filter_const = 0;
 223         else
 224                 e->filter_const = 1.0 - exp( -1.0 / (e->sample_rate * rise_time / 2000000.0 / exp(1.0)) );
 225 }
 226
 227 int ltc_encoder_set_bufsize(LTCEncoder *e, double sample_rate, double fps) {
 228         free (e->buf);
 229         e->offset = 0;
 230         e->bufsize = 1 + ceil(sample_rate / fps);
 231         e->buf = (ltcsnd_sample_t*) calloc(e->bufsize, sizeof(ltcsnd_sample_t));
 232         if (!e->buf) {
 233                 return -1;
 234         }
 235         return 0;
 236 }
 237
 238 int ltc_encoder_encode_byte(LTCEncoder *e, int byte, double speed) {
 239         return encode_byte(e, byte, speed);
 240 }
 241
 242 void ltc_encoder_encode_frame(LTCEncoder *e) {
 243         int byte;
 244         for (byte = 0 ; byte < 10 ; byte++) {
 245                 encode_byte(e, byte, 1.0);
 246         }
 247 }
 248
 249 void ltc_encoder_get_timecode(LTCEncoder *e, SMPTETimecode *t) {
 250         ltc_frame_to_time(t, &e->f, e->flags);
 251 }
 252
 253 void ltc_encoder_set_timecode(LTCEncoder *e, SMPTETimecode *t) {
 254         ltc_time_to_frame(&e->f, t, e->standard, e->flags);
 255 }
 256
 257 void ltc_encoder_get_frame(LTCEncoder *e, LTCFrame *f) {
 258         memcpy(f, &e->f, sizeof(LTCFrame));
 259 }
 260
 261 void ltc_encoder_set_frame(LTCEncoder *e, LTCFrame *f) {
 262         memcpy(&e->f, f, sizeof(LTCFrame));
 263 }
 264
 265 int ltc_encoder_inc_timecode(LTCEncoder *e) {
 266         return ltc_frame_increment (&e->f, rint(e->fps), e->standard, e->flags);
 267 }
 268
 269 int ltc_encoder_dec_timecode(LTCEncoder *e) {
 270         return ltc_frame_decrement (&e->f, rint(e->fps), e->standard, e->flags);
 271 }
 272
 273 size_t ltc_encoder_get_buffersize(LTCEncoder *e) {
 274         return(e->bufsize);
 275 }
 276
 277 void ltc_encoder_buffer_flush(LTCEncoder *e) {
 278         e->offset = 0;
 279 }
 280
 281 ltcsnd_sample_t *ltc_encoder_get_bufptr(LTCEncoder *e, int *size, int flush) {
 282         if (size) *size = e->offset;
 283         if (flush) e->offset = 0;
 284         return e->buf;
 285 }
 286
 287 int ltc_encoder_get_buffer(LTCEncoder *e, ltcsnd_sample_t *buf) {
 288         const int len = e->offset;
 289         memcpy(buf, e->buf, len * sizeof(ltcsnd_sample_t) );
 290         e->offset = 0;
 291         return(len);
 292 }
 293
 294 void ltc_frame_set_parity(LTCFrame *frame, enum LTC_TV_STANDARD standard) {
 295         int i;
 296         unsigned char p = 0;
 297
 298         if (standard != LTC_TV_625_50) { /* 30fps, 24fps */
 299                 frame->biphase_mark_phase_correction = 0;
 300         } else { /* 25fps */
 301                 frame->binary_group_flag_bit2 = 0;
 302         }
 303
 304         for (i=0; i < LTC_FRAME_BIT_COUNT / 8; ++i){
 305                 p = p ^ (((unsigned char*)frame)[i]);
 306         }
 307 #define PRY(BIT) ((p>>BIT)&1)
 308
 309         if (standard != LTC_TV_625_50) { /* 30fps, 24fps */
 310                 frame->biphase_mark_phase_correction =
 311                         PRY(0)^PRY(1)^PRY(2)^PRY(3)^PRY(4)^PRY(5)^PRY(6)^PRY(7);
 312         } else { /* 25fps */
 313                 frame->binary_group_flag_bit2 =
 314                         PRY(0)^PRY(1)^PRY(2)^PRY(3)^PRY(4)^PRY(5)^PRY(6)^PRY(7);
 315         }
 316 }
 317
 318 ltc_off_t ltc_frame_alignment(double samples_per_frame, enum LTC_TV_STANDARD standard) {
 319         switch (standard) {
 320                 case LTC_TV_525_60:
 321                         return rint(samples_per_frame * 4.0 / 525.0);
 322                 case LTC_TV_625_50:
 323                         return rint(samples_per_frame * 1.0 / 625.0);
 324                 default:
 325                         return 0;
 326         }
 327 }