diff options
author | Paul Davis <paul@linuxaudiosystems.com> | 2012-12-14 16:18:47 +0000 |
---|---|---|
committer | Paul Davis <paul@linuxaudiosystems.com> | 2012-12-14 16:18:47 +0000 |
commit | c9c94ca1c247adfc1a78fda0eda185a9a7589696 (patch) | |
tree | 52d520020e7ff2455b8abf83fbcc69a4ba02b9ca /libs/libltc/decoder.c | |
parent | fd1414f6668712c641da6c7d51f4b3e2bf6fae5a (diff) |
merge robin gareus' libltc into ardour source tree for convenience
git-svn-id: svn://localhost/ardour2/branches/3.0@13665 d708f5d6-7413-0410-9779-e7cbd77b26cf
Diffstat (limited to 'libs/libltc/decoder.c')
-rw-r--r-- | libs/libltc/decoder.c | 334 |
1 files changed, 334 insertions, 0 deletions
diff --git a/libs/libltc/decoder.c b/libs/libltc/decoder.c new file mode 100644 index 0000000000..29e4a32ef0 --- /dev/null +++ b/libs/libltc/decoder.c @@ -0,0 +1,334 @@ +/* + libltc - en+decode linear timecode + + Copyright (C) 2005 Maarten de Boer <mdeboer@iua.upf.es> + Copyright (C) 2006-2012 Robin Gareus <robin@gareus.org> + Copyright (C) 2008-2009 Jan <jan@geheimwerk.de> + + Binary constant generator macro for endianess conversion + by Tom Torfs - donated to the public domain + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser 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 Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library. + If not, see <http://www.gnu.org/licenses/>. +*/ + +/** turn a numeric literal into a hex constant + * (avoids problems with leading zeroes) + * 8-bit constants max value 0x11111111, always fits in unsigned long + */ +#define HEX__(n) 0x##n##LU + +/** + * 8-bit conversion function + */ +#define B8__(x) ((x&0x0000000FLU)?1:0) \ + +((x&0x000000F0LU)?2:0) \ + +((x&0x00000F00LU)?4:0) \ + +((x&0x0000F000LU)?8:0) \ + +((x&0x000F0000LU)?16:0) \ + +((x&0x00F00000LU)?32:0) \ + +((x&0x0F000000LU)?64:0) \ + +((x&0xF0000000LU)?128:0) + +/** for upto 8-bit binary constants */ +#define B8(d) ((unsigned char)B8__(HEX__(d))) + +/** for upto 16-bit binary constants, MSB first */ +#define B16(dmsb,dlsb) (((unsigned short)B8(dmsb)<<8) + B8(dlsb)) + +/** turn a numeric literal into a hex constant + *(avoids problems with leading zeroes) + * 8-bit constants max value 0x11111111, always fits in unsigned long + */ +#define HEX__(n) 0x##n##LU + +/** 8-bit conversion function */ +#define B8__(x) ((x&0x0000000FLU)?1:0) \ + +((x&0x000000F0LU)?2:0) \ + +((x&0x00000F00LU)?4:0) \ + +((x&0x0000F000LU)?8:0) \ + +((x&0x000F0000LU)?16:0) \ + +((x&0x00F00000LU)?32:0) \ + +((x&0x0F000000LU)?64:0) \ + +((x&0xF0000000LU)?128:0) + + +/** for upto 8-bit binary constants */ +#define B8(d) ((unsigned char)B8__(HEX__(d))) + +/** for upto 16-bit binary constants, MSB first */ +#define B16(dmsb,dlsb) (((unsigned short)B8(dmsb)<<8) + B8(dlsb)) + +/* Example usage: + * B8(01010101) = 85 + * B16(10101010,01010101) = 43605 + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <math.h> + +#include "ltc/decoder.h" + +#define DEBUG_DUMP(msg, f) \ +{ \ + int _ii; \ + printf("%s", msg); \ + for (_ii=0; _ii < (LTC_FRAME_BIT_COUNT >> 3); _ii++) { \ + const unsigned char _bit = ((unsigned char*)(f))[_ii]; \ + printf("%c", (_bit & B8(10000000) ) ? '1' : '0'); \ + printf("%c", (_bit & B8(01000000) ) ? '1' : '0'); \ + printf("%c", (_bit & B8(00100000) ) ? '1' : '0'); \ + printf("%c", (_bit & B8(00010000) ) ? '1' : '0'); \ + printf("%c", (_bit & B8(00001000) ) ? '1' : '0'); \ + printf("%c", (_bit & B8(00000100) ) ? '1' : '0'); \ + printf("%c", (_bit & B8(00000010) ) ? '1' : '0'); \ + printf("%c", (_bit & B8(00000001) ) ? '1' : '0'); \ + printf(" "); \ + }\ + printf("\n"); \ +} + +static double calc_volume_db(LTCDecoder *d) { + if (d->snd_to_biphase_max <= d->snd_to_biphase_min) + return -INFINITY; + return (20.0 * log10((d->snd_to_biphase_max - d->snd_to_biphase_min) / 255.0)); +} + +static void parse_ltc(LTCDecoder *d, unsigned char bit, int offset, ltc_off_t posinfo) { + int bit_num, bit_set, byte_num; + + if (d->bit_cnt == 0) { + memset(&d->ltc_frame, 0, sizeof(LTCFrame)); + + if (d->frame_start_prev < 0) { + d->frame_start_off = posinfo - d->snd_to_biphase_period; + } else { + d->frame_start_off = d->frame_start_prev; + } + } + d->frame_start_prev = offset + posinfo; + + if (d->bit_cnt >= LTC_FRAME_BIT_COUNT) { + /* shift bits backwards */ + int k = 0; + const int byte_num_max = LTC_FRAME_BIT_COUNT >> 3; + + for (k=0; k< byte_num_max; k++) { + const unsigned char bi = ((unsigned char*)&d->ltc_frame)[k]; + unsigned char bo = 0; + bo |= (bi & B8(10000000) ) ? B8(01000000) : 0; + bo |= (bi & B8(01000000) ) ? B8(00100000) : 0; + bo |= (bi & B8(00100000) ) ? B8(00010000) : 0; + bo |= (bi & B8(00010000) ) ? B8(00001000) : 0; + bo |= (bi & B8(00001000) ) ? B8(00000100) : 0; + bo |= (bi & B8(00000100) ) ? B8(00000010) : 0; + bo |= (bi & B8(00000010) ) ? B8(00000001) : 0; + if (k+1 < byte_num_max) { + bo |= ( (((unsigned char*)&d->ltc_frame)[k+1]) & B8(00000001) ) ? B8(10000000): B8(00000000); + } + ((unsigned char*)&d->ltc_frame)[k] = bo; + } + + d->frame_start_off += ceil(d->snd_to_biphase_period); + d->bit_cnt--; + } + + d->decoder_sync_word <<= 1; + if (bit) { + + d->decoder_sync_word |= B16(00000000,00000001); + + if (d->bit_cnt < LTC_FRAME_BIT_COUNT) { + // Isolating the lowest three bits: the location of this bit in the current byte + bit_num = (d->bit_cnt & B8(00000111)); + // Using the bit number to define which of the eight bits to set + bit_set = (B8(00000001) << bit_num); + // Isolating the higher bits: the number of the byte/char the target bit is contained in + byte_num = d->bit_cnt >> 3; + + (((unsigned char*)&d->ltc_frame)[byte_num]) |= bit_set; + } + + } + d->bit_cnt++; + + if (d->decoder_sync_word == B16(00111111,11111101) /*LTC Sync Word 0x3ffd*/) { + if (d->bit_cnt == LTC_FRAME_BIT_COUNT) { + int bc; + + memcpy( &d->queue[d->queue_write_off].ltc, + &d->ltc_frame, + sizeof(LTCFrame)); + + for(bc = 0; bc < LTC_FRAME_BIT_COUNT; ++bc) { + const int btc = (d->biphase_tic + bc ) % LTC_FRAME_BIT_COUNT; + d->queue[d->queue_write_off].biphase_tics[bc] = d->biphase_tics[btc]; + } + + d->queue[d->queue_write_off].off_start = d->frame_start_off; + d->queue[d->queue_write_off].off_end = posinfo + (ltc_off_t) offset - 1LL; + d->queue[d->queue_write_off].reverse = 0; + d->queue[d->queue_write_off].volume = calc_volume_db(d); + d->queue[d->queue_write_off].sample_min = d->snd_to_biphase_min; + d->queue[d->queue_write_off].sample_max = d->snd_to_biphase_max; + + d->queue_write_off++; + + if (d->queue_write_off == d->queue_len) + d->queue_write_off = 0; + } + d->bit_cnt = 0; + } + + if (d->decoder_sync_word == B16(10111111,11111100) /* reverse sync-word*/) { + if (d->bit_cnt == LTC_FRAME_BIT_COUNT) { + /* reverse frame */ + int bc; + int k = 0; + int byte_num_max = LTC_FRAME_BIT_COUNT >> 3; + + /* swap bits */ + for (k=0; k< byte_num_max; k++) { + const unsigned char bi = ((unsigned char*)&d->ltc_frame)[k]; + unsigned char bo = 0; + bo |= (bi & B8(10000000) ) ? B8(00000001) : 0; + bo |= (bi & B8(01000000) ) ? B8(00000010) : 0; + bo |= (bi & B8(00100000) ) ? B8(00000100) : 0; + bo |= (bi & B8(00010000) ) ? B8(00001000) : 0; + bo |= (bi & B8(00001000) ) ? B8(00010000) : 0; + bo |= (bi & B8(00000100) ) ? B8(00100000) : 0; + bo |= (bi & B8(00000010) ) ? B8(01000000) : 0; + bo |= (bi & B8(00000001) ) ? B8(10000000) : 0; + ((unsigned char*)&d->ltc_frame)[k] = bo; + } + + /* swap bytes */ + byte_num_max-=2; // skip sync-word + for (k=0; k< (byte_num_max)/2; k++) { + const unsigned char bi = ((unsigned char*)&d->ltc_frame)[k]; + ((unsigned char*)&d->ltc_frame)[k] = ((unsigned char*)&d->ltc_frame)[byte_num_max-1-k]; + ((unsigned char*)&d->ltc_frame)[byte_num_max-1-k] = bi; + } + + memcpy( &d->queue[d->queue_write_off].ltc, + &d->ltc_frame, + sizeof(LTCFrame)); + + for(bc = 0; bc < LTC_FRAME_BIT_COUNT; ++bc) { + const int btc = (d->biphase_tic + bc ) % LTC_FRAME_BIT_COUNT; + d->queue[d->queue_write_off].biphase_tics[bc] = d->biphase_tics[btc]; + } + + d->queue[d->queue_write_off].off_start = d->frame_start_off - 16 * d->snd_to_biphase_period; + d->queue[d->queue_write_off].off_end = posinfo + (ltc_off_t) offset - 1LL - 16 * d->snd_to_biphase_period; + d->queue[d->queue_write_off].reverse = (LTC_FRAME_BIT_COUNT >> 3) * 8 * d->snd_to_biphase_period; + d->queue[d->queue_write_off].volume = calc_volume_db(d); + d->queue[d->queue_write_off].sample_min = d->snd_to_biphase_min; + d->queue[d->queue_write_off].sample_max = d->snd_to_biphase_max; + + d->queue_write_off++; + + if (d->queue_write_off == d->queue_len) + d->queue_write_off = 0; + } + d->bit_cnt = 0; + } +} + +static inline void biphase_decode2(LTCDecoder *d, int offset, ltc_off_t pos) { + + d->biphase_tics[d->biphase_tic] = d->snd_to_biphase_period; + d->biphase_tic = (d->biphase_tic + 1) % LTC_FRAME_BIT_COUNT; + if (d->snd_to_biphase_cnt <= 2 * d->snd_to_biphase_period) { + pos -= (d->snd_to_biphase_period - d->snd_to_biphase_cnt); + } + + if (d->snd_to_biphase_state == d->biphase_prev) { + d->biphase_state = 1; + parse_ltc(d, 0, offset, pos); + } else { + d->biphase_state = 1 - d->biphase_state; + if (d->biphase_state == 1) { + parse_ltc(d, 1, offset, pos); + } + } + d->biphase_prev = d->snd_to_biphase_state; +} + +void decode_ltc(LTCDecoder *d, ltcsnd_sample_t *sound, size_t size, ltc_off_t posinfo) { + size_t i; + + for (i = 0 ; i < size ; i++) { + ltcsnd_sample_t max_threshold, min_threshold; + + /* track minimum and maximum values */ + d->snd_to_biphase_min = SAMPLE_CENTER - (((SAMPLE_CENTER - d->snd_to_biphase_min) * 15) / 16); + d->snd_to_biphase_max = SAMPLE_CENTER + (((d->snd_to_biphase_max - SAMPLE_CENTER) * 15) / 16); + + if (sound[i] < d->snd_to_biphase_min) + d->snd_to_biphase_min = sound[i]; + if (sound[i] > d->snd_to_biphase_max) + d->snd_to_biphase_max = sound[i]; + + /* set the thresholds for hi/lo state tracking */ + min_threshold = SAMPLE_CENTER - (((SAMPLE_CENTER - d->snd_to_biphase_min) * 8) / 16); + max_threshold = SAMPLE_CENTER + (((d->snd_to_biphase_max - SAMPLE_CENTER) * 8) / 16); + + if ( /* Check for a biphase state change */ + ( d->snd_to_biphase_state && (sound[i] > max_threshold) ) + || ( !d->snd_to_biphase_state && (sound[i] < min_threshold) ) + ) { + + /* If the sample count has risen above the biphase length limit */ + if (d->snd_to_biphase_cnt > d->snd_to_biphase_lmt) { + /* single state change within a biphase priod. decode to a 0 */ + biphase_decode2(d, i, posinfo); + biphase_decode2(d, i, posinfo); + + } else { + /* "short" state change covering half a period + * together with the next or previous state change decode to a 1 + */ + d->snd_to_biphase_cnt *= 2; + biphase_decode2(d, i, posinfo); + + } + + if (d->snd_to_biphase_cnt > (d->snd_to_biphase_period * 4)) { + /* "long" silence in between + * -> reset parser, don't use it for phase-tracking + */ + d->bit_cnt = 0; + } else { + /* track speed variations + * As this is only executed at a state change, + * d->snd_to_biphase_cnt is an accurate representation of the current period length. + */ + d->snd_to_biphase_period = (d->snd_to_biphase_period * 3.0 + d->snd_to_biphase_cnt) / 4.0; + + /* This limit specifies when a state-change is + * considered biphase-clock or 2*biphase-clock. + * The relation with period has been determined + * empirically through trial-and-error */ + d->snd_to_biphase_lmt = (d->snd_to_biphase_period * 3) / 4; + } + + d->snd_to_biphase_cnt = 0; + d->snd_to_biphase_state = !d->snd_to_biphase_state; + } + d->snd_to_biphase_cnt++; + } +} |