+ * | 1 | Caption 1 |
+ * "Primary synchronous caption service [English]" |
+ * | 2 | Caption 2 |
+ * "Special non-synchronous data that is intended to
+ * augment information carried in the program" |
+ * | 3 | Caption 3 |
+ * "Secondary synchronous caption service, usually
+ * second language [Spanish, French]" |
+ * | 4 | Caption 4 |
+ * "Special non-synchronous data similar to Caption 2" |
+ * | 5 | Text 1 |
+ * "First text service, data usually not program related" |
+ * | 6 | Text 2 |
+ * "Second text service, additional data usually not program related
+ * [ITV data]" |
+ * | 7 | Text 3 |
+ * "Additional text channel" |
+ * | 8 | Text 4 |
+ * "Additional text channel" |
+ *
+ */
+/* XXX unsigned? */
+typedef int vbi_pgno;
+
+/**
+ * @ingroup HiDec
+ *
+ * This is the subpage number only applicable to Teletext pages,
+ * a packed bcd number in range 0x00 ... 0x99. On special 'clock' pages
+ * (for example listing the current time in different time zones)
+ * it can assume values between 0x0000 ... 0x2359 expressing
+ * local time. These are not actually subpages.
+ */
+typedef int vbi_subno;
+
+/**
+ * @ingroup HiDec
+ */
+#define VBI_ANY_SUBNO 0x3F7F
+/**
+ * @ingroup HiDec
+ */
+#define VBI_NO_SUBNO 0x3F7F
+
+/**
+ * @ingroup BCD
+ * @param dec Decimal number.
+ *
+ * Converts a two's complement binary between 0 ... 999 to a
+ * packed bcd number in range 0x000 ... 0x999. Extra digits in
+ * the input will be discarded.
+ *
+ * @return
+ * BCD number.
+ */
+_vbi_inline unsigned int
+vbi_dec2bcd(unsigned int dec)
+{
+ return (dec % 10) + ((dec / 10) % 10) * 16 + ((dec / 100) % 10) * 256;
+}
+
+/**
+ * @ingroup BCD
+ * @since 0.2.28
+ */
+#define vbi_bin2bcd(n) vbi_dec2bcd(n)
+
+/**
+ * @ingroup BCD
+ * @param bcd BCD number.
+ *
+ * Converts a packed bcd number between 0x000 ... 0xFFF to a two's
+ * complement binary in range 0 ... 999. Extra digits in the input
+ * will be discarded.
+ *
+ * @return
+ * Decimal number. The result is undefined when the bcd number contains
+ * hex digits 0xA ... 0xF.
+ **/
+_vbi_inline unsigned int
+vbi_bcd2dec(unsigned int bcd)
+{
+ return (bcd & 15) + ((bcd >> 4) & 15) * 10 + ((bcd >> 8) & 15) * 100;
+}
+
+/**
+ * @ingroup BCD
+ * @since 0.2.28
+ */
+#define vbi_bcd2bin(n) vbi_bcd2dec(n)
+
+/**
+ * @ingroup BCD
+ * @param a BCD number.
+ * @param b BCD number.
+ *
+ * Adds two packed bcd numbers, returning a packed bcd sum. Arguments
+ * and result are in range 0xF000 0000 ... 0x0999 9999, that
+ * is -10**7 ... +10**7 - 1 in decimal notation. To subtract you can
+ * add the 10's complement, e. g. -1 = 0xF999 9999.
+ *
+ * @return
+ * Packed bcd number. The result is undefined when any of the arguments
+ * contain hex digits 0xA ... 0xF.
+ */
+_vbi_inline unsigned int
+vbi_add_bcd(unsigned int a, unsigned int b)
+{
+ unsigned int t;
+
+ a += 0x06666666;
+ t = a + b;
+ b ^= a ^ t;
+ b = (~b & 0x11111110) >> 3;
+ b |= b * 2;
+
+ return t - b;
+}
+
+/**
+ * @ingroup BCD
+ * @param bcd BCD number.
+ *
+ * Tests if @a bcd forms a valid BCD number. The argument must be
+ * in range 0x0000 0000 ... 0x0999 9999.
+ *
+ * @return
+ * @c FALSE if @a bcd contains hex digits 0xA ... 0xF.
+ */
+_vbi_inline vbi_bool
+vbi_is_bcd(unsigned int bcd)
+{
+ static const unsigned int x = 0x06666666;
+
+ return (((bcd + x) ^ (bcd ^ x)) & 0x11111110) == 0;
+}
+
+/**
+ * @ingroup BCD
+ * @param bcd Unsigned BCD number.
+ * @param maximum Unsigned maximum value.
+ *
+ * Compares an unsigned packed bcd number digit-wise against a maximum
+ * value, for example 0x295959. @a maximum can contain digits 0x0
+ * ... 0xF.
+ *
+ * @return
+ * @c TRUE if any digit of @a bcd is greater than the
+ * corresponding digit of @a maximum.
+ *
+ * @since 0.2.28
+ */
+_vbi_inline vbi_bool
+vbi_bcd_digits_greater (unsigned int bcd,
+ unsigned int maximum)
+{
+ maximum ^= ~0;
+
+ return 0 != (((bcd + maximum) ^ bcd ^ maximum) & 0x11111110);
+}
+
+/* Private */
+
+#endif /* BCD_H */
+
+/*
+Local variables:
+c-set-style: K&R
+c-basic-offset: 8
+End:
+*/
diff --git a/ext/closedcaption/bit_slicer.c b/ext/closedcaption/bit_slicer.c
new file mode 100644
index 0000000000..3bb870241b
--- /dev/null
+++ b/ext/closedcaption/bit_slicer.c
@@ -0,0 +1,1017 @@
+/*
+ * libzvbi - Bit slicer
+ *
+ * Copyright (C) 2000-2007 Michael H. Schimek
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ */
+
+/* $Id: bit_slicer.c,v 1.16 2008-02-19 00:35:14 mschimek Exp $ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "misc.h"
+#include "bit_slicer.h"
+
+# define VBI_PIXFMT_Y8 VBI_PIXFMT_YUV420
+# define VBI_PIXFMT_RGB24_LE VBI_PIXFMT_RGB24
+# define VBI_PIXFMT_BGR24_LE VBI_PIXFMT_BGR24
+# define VBI_PIXFMT_RGBA24_LE VBI_PIXFMT_RGBA32_LE
+# define VBI_PIXFMT_BGRA24_LE VBI_PIXFMT_BGRA32_LE
+# define VBI_PIXFMT_RGBA24_BE VBI_PIXFMT_RGBA32_BE
+# define VBI_PIXFMT_BGRA24_BE VBI_PIXFMT_BGRA32_BE
+# define VBI_PIXFMT_RGB8 101
+# define vbi_pixfmt_bytes_per_pixel VBI_PIXFMT_BPP
+
+/**
+ * $addtogroup BitSlicer Bit Slicer
+ * $ingroup Raw
+ * $brief Converting a single scan line of raw VBI
+ * data to sliced VBI data.
+ *
+ * These are low level functions most useful if you want to decode
+ * data services not covered by libzvbi. Usually you will want to
+ * use the raw VBI decoder, converting several lines of different
+ * data services at once.
+ */
+
+/* This is time critical, tinker with care.
+
+ What about all these macros? They are templates to avoid a
+ pixel format switch within time critical loops. Instead we
+ compile bit slicer functions for different pixel formats.
+
+ I would use inline functions for proper type checking, but
+ there's no guarantee the compiler really will inline. */
+
+/* Read a green sample, e.g. rrrrrggg gggbbbbb. endian is const. */
+#define GREEN2(raw, endian) \
+ (((raw)[0 + endian] + (raw)[1 - endian] * 256) & bs->green_mask)
+
+/* Read a sample with pixfmt conversion. pixfmt is const. */
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+#define GREEN(raw) \
+ ((VBI_PIXFMT_RGB8 == pixfmt) ? \
+ *(const uint8_t *)(raw) & bs->green_mask : \
+ ((VBI_PIXFMT_RGB16_LE == pixfmt) ? \
+ *(const uint16_t *)(raw) & bs->green_mask : \
+ ((VBI_PIXFMT_RGB16_BE == pixfmt) ? \
+ GREEN2 (raw, 1) : \
+ (raw)[0])))
+#elif G_BYTE_ORDER == G_BIG_ENDIAN
+#define GREEN(raw) \
+ ((VBI_PIXFMT_RGB8 == pixfmt) ? \
+ *(const uint8_t *)(raw) & bs->green_mask : \
+ ((VBI_PIXFMT_RGB16_LE == pixfmt) ? \
+ GREEN2 (raw, 0) : \
+ ((VBI_PIXFMT_RGB16_BE == pixfmt) ? \
+ *(const uint16_t *)(raw) & bs->green_mask : \
+ (raw)[0])))
+#else
+#define GREEN(raw) \
+ ((VBI_PIXFMT_RGB8 == pixfmt) ? \
+ *(const uint8_t *)(raw) & bs->green_mask : \
+ ((VBI_PIXFMT_RGB16_LE == pixfmt) ? \
+ GREEN2 (raw, 0) : \
+ ((VBI_PIXFMT_RGB16_BE == pixfmt) ? \
+ GREEN2 (raw, 1) : \
+ (raw)[0])))
+#endif
+
+/* raw0 = raw[index >> 8], linear interpolated. */
+#define SAMPLE(_kind) \
+do { \
+ const uint8_t *r; \
+ \
+ r = raw + (i >> 8) * bpp; \
+ raw0 = GREEN (r); \
+ raw1 = GREEN (r + bpp); \
+ raw0 = (int)(raw1 - raw0) * (i & 255) + (raw0 << 8); \
+ if (collect_points) { \
+ points->kind = _kind; \
+ points->index = (raw - raw_start) * 256 + i; \
+ points->level = raw0; \
+ points->thresh = tr; \
+ ++points; \
+ } \
+} while (0)
+
+#define PAYLOAD() \
+do { \
+ i = bs->phase_shift; /* current bit position << 8 */ \
+ tr *= 256; \
+ c = 0; \
+ \
+ for (j = bs->frc_bits; j > 0; --j) { \
+ SAMPLE (VBI3_FRC_BIT); \
+ c = c * 2 + (raw0 >= tr); \
+ i += bs->step; /* next bit */ \
+ } \
+ \
+ if (c != bs->frc) \
+ return FALSE; \
+ \
+ switch (bs->endian) { \
+ case 3: /* bitwise, lsb first */ \
+ for (j = 0; j < bs->payload; ++j) { \
+ SAMPLE (VBI3_PAYLOAD_BIT); \
+ c = (c >> 1) + ((raw0 >= tr) << 7); \
+ i += bs->step; \
+ if ((j & 7) == 7) \
+ *buffer++ = c; \
+ } \
+ *buffer = c >> ((8 - bs->payload) & 7); \
+ break; \
+ \
+ case 2: /* bitwise, msb first */ \
+ for (j = 0; j < bs->payload; ++j) { \
+ SAMPLE (VBI3_PAYLOAD_BIT); \
+ c = c * 2 + (raw0 >= tr); \
+ i += bs->step; \
+ if ((j & 7) == 7) \
+ *buffer++ = c; \
+ } \
+ *buffer = c & ((1 << (bs->payload & 7)) - 1); \
+ break; \
+ \
+ case 1: /* octets, lsb first */ \
+ for (j = bs->payload; j > 0; --j) { \
+ for (k = 0, c = 0; k < 8; ++k) { \
+ SAMPLE (VBI3_PAYLOAD_BIT); \
+ c += (raw0 >= tr) << k; \
+ i += bs->step; \
+ } \
+ *buffer++ = c; \
+ } \
+ break; \
+ \
+ default: /* octets, msb first */ \
+ for (j = bs->payload; j > 0; --j) { \
+ for (k = 0; k < 8; ++k) { \
+ SAMPLE (VBI3_PAYLOAD_BIT); \
+ c = c * 2 + (raw0 >= tr); \
+ i += bs->step; \
+ } \
+ *buffer++ = c; \
+ } \
+ break; \
+ } \
+} while (0)
+
+#define CRI() \
+do { \
+ unsigned int tavg; \
+ unsigned char b; /* current bit */ \
+ \
+ tavg = (t + (oversampling / 2)) / oversampling; \
+ b = (tavg >= tr); \
+ \
+ if (unlikely (b ^ b1)) { \
+ cl = bs->oversampling_rate >> 1; \
+ } else { \
+ cl += bs->cri_rate; \
+ \
+ if (cl >= bs->oversampling_rate) { \
+ if (collect_points) { \
+ points->kind = VBI3_CRI_BIT; \
+ points->index = (raw - raw_start) << 8; \
+ points->level = tavg << 8; \
+ points->thresh = tr << 8; \
+ ++points; \
+ } \
+ \
+ cl -= bs->oversampling_rate; \
+ c = c * 2 + b; \
+ if ((c & bs->cri_mask) == bs->cri) { \
+ PAYLOAD (); \
+ if (collect_points) { \
+ *n_points = points \
+ - points_start; \
+ } \
+ return TRUE; \
+ } \
+ } \
+ } \
+ \
+ b1 = b; \
+ \
+ if (oversampling > 1) \
+ t += raw1; \
+} while (0)
+
+#define CORE() \
+do { \
+ const uint8_t *raw_start; \
+ unsigned int i, j, k; \
+ unsigned int cl; /* clock */ \
+ unsigned int thresh0; /* old 0/1 threshold */ \
+ unsigned int tr; /* current threshold */ \
+ unsigned int c; /* current byte */ \
+ unsigned int t; /* t = raw[0] * j + raw[1] * (1 - j) */ \
+ unsigned int raw0; /* oversampling temporary */ \
+ unsigned int raw1; \
+ unsigned char b1; /* previous bit */ \
+ \
+ thresh0 = bs->thresh; \
+ raw_start = raw; \
+ raw += bs->skip; \
+ \
+ cl = 0; \
+ c = 0; \
+ b1 = 0; \
+ \
+ for (i = bs->cri_samples; i > 0; --i) { \
+ tr = bs->thresh >> thresh_frac; \
+ raw0 = GREEN (raw); \
+ raw1 = GREEN (raw + bpp); \
+ raw1 -= raw0; \
+ bs->thresh += (int)(raw0 - tr) * (int) ABS ((int) raw1); \
+ t = raw0 * oversampling; \
+ \
+ for (j = oversampling; j > 0; --j) \
+ CRI (); \
+ \
+ raw += bpp; \
+ } \
+ \
+ bs->thresh = thresh0; \
+ \
+ if (collect_points) \
+ *n_points = points - points_start; \
+ \
+ return FALSE; \
+} while (0)
+
+#define BIT_SLICER(fmt, os, tf) \
+static vbi_bool \
+bit_slicer_ ## fmt (vbi3_bit_slicer * bs, \
+ uint8_t * buffer, \
+ vbi3_bit_slicer_point *points, \
+ unsigned int * n_points, \
+ const uint8_t * raw) \
+{ \
+ static const vbi_pixfmt pixfmt = VBI_PIXFMT_ ## fmt; \
+ unsigned int bpp = \
+ vbi_pixfmt_bytes_per_pixel (VBI_PIXFMT_ ## fmt); \
+ static const unsigned int oversampling = os; \
+ static const vbi3_bit_slicer_point *points_start = NULL; \
+ static const vbi_bool collect_points = FALSE; \
+ unsigned int thresh_frac = tf; \
+ \
+ CORE (); \
+}
+
+#define DEF_THR_FRAC 9
+
+BIT_SLICER (Y8, 4, DEF_THR_FRAC) /* any format with 0 bytes between Y or G */
+ BIT_SLICER (YUYV, 4, DEF_THR_FRAC) /* 1 byte */
+ BIT_SLICER (RGB24_LE, 4, DEF_THR_FRAC) /* 2 bytes */
+ BIT_SLICER (RGBA24_LE, 4, DEF_THR_FRAC) /* 3 bytes */
+ BIT_SLICER (RGB16_LE, 4, bs->thresh_frac)
+ BIT_SLICER (RGB16_BE, 4, bs->thresh_frac)
+
+ static const unsigned int LP_AVG = 4;
+
+ static vbi_bool
+ low_pass_bit_slicer_Y8 (vbi3_bit_slicer * bs,
+ uint8_t * buffer,
+ vbi3_bit_slicer_point * points, unsigned int *n_points, const uint8_t * raw)
+{
+ vbi3_bit_slicer_point *points_start;
+ const uint8_t *raw_start;
+ unsigned int i, j, k, m;
+ unsigned int cl; /* clock */
+ unsigned int thresh0; /* old 0/1 threshold */
+ unsigned int tr; /* current threshold */
+ unsigned int c; /* current byte */
+ unsigned int raw0; /* oversampling temporary */
+ unsigned char b1; /* previous bit */
+ unsigned int bps;
+ unsigned int raw0sum;
+
+ points_start = points;
+
+ raw_start = raw;
+ raw += bs->skip;
+
+ bps = bs->bytes_per_sample;
+
+ thresh0 = bs->thresh;
+
+ c = -1;
+ cl = 0;
+ b1 = 0;
+
+ raw0sum = raw[0];
+ for (m = bps; m < (bps << LP_AVG); m += bps) {
+ raw0sum += raw[m];
+ }
+
+ i = bs->cri_samples;
+
+ for (;;) {
+ unsigned char b; /* current bit */
+
+ tr = bs->thresh >> bs->thresh_frac;
+ raw0 = raw0sum;
+ raw0sum = raw0sum + raw[bps << LP_AVG]
+ - raw[0];
+ raw += bps;
+ bs->thresh += (int) (raw0 - tr)
+ * (int) ABS ((int) (raw0sum - raw0));
+
+ b = (raw0 >= tr);
+
+ if (unlikely (b ^ b1)) {
+ cl = bs->oversampling_rate >> 1;
+ } else {
+ cl += bs->cri_rate;
+
+ if (cl >= bs->oversampling_rate) {
+ if (unlikely (NULL != points)) {
+ points->kind = VBI3_CRI_BIT;
+ points->index = (raw - raw_start)
+ * 256 / bs->bytes_per_sample + (1 << LP_AVG) * 128;
+ points->level = raw0 << (8 - LP_AVG);
+ points->thresh = tr << (8 - LP_AVG);
+ ++points;
+ }
+
+ cl -= bs->oversampling_rate;
+ c = c * 2 + b;
+ if ((c & bs->cri_mask) == bs->cri) {
+ break;
+ }
+ }
+ }
+
+ b1 = b;
+
+ if (0 == --i) {
+ bs->thresh = thresh0;
+
+ if (unlikely (NULL != points))
+ *n_points = points - points_start;
+
+ return FALSE;
+ }
+ }
+
+#define LP_SAMPLE(_kind) \
+do { \
+ unsigned int ii = (i >> 8) * bps; \
+ \
+ raw0 = raw[ii]; \
+ for (m = bps; m < (bps << LP_AVG); m += bps) \
+ raw0 += raw[ii + m]; \
+ if (unlikely (NULL != points)) { \
+ points->kind = _kind; \
+ points->index = (raw - raw_start) \
+ * 256 / bs->bytes_per_sample \
+ + (1 << LP_AVG) * 128 \
+ + ii * 256; \
+ points->level = raw0 << (8 - LP_AVG); \
+ points->thresh = tr << (8 - LP_AVG); \
+ ++points; \
+ } \
+} while (0)
+
+ i = bs->phase_shift; /* current bit position << 8 */
+ c = 0;
+
+ for (j = bs->frc_bits; j > 0; --j) {
+ LP_SAMPLE (VBI3_FRC_BIT);
+ c = c * 2 + (raw0 >= tr);
+ i += bs->step; /* next bit */
+ }
+
+ if (c != bs->frc)
+ return FALSE;
+
+ c = 0;
+
+ switch (bs->endian) {
+ case 3: /* bitwise, lsb first */
+ for (j = 0; j < bs->payload; ++j) {
+ LP_SAMPLE (VBI3_PAYLOAD_BIT);
+ c = (c >> 1) + ((raw0 >= tr) << 7);
+ i += bs->step;
+ if ((j & 7) == 7)
+ *buffer++ = c;
+ }
+ *buffer = c >> ((8 - bs->payload) & 7);
+ break;
+
+ case 2: /* bitwise, msb first */
+ for (j = 0; j < bs->payload; ++j) {
+ LP_SAMPLE (VBI3_PAYLOAD_BIT);
+ c = c * 2 + (raw0 >= tr);
+ i += bs->step;
+ if ((j & 7) == 7)
+ *buffer++ = c;
+ }
+ *buffer = c & ((1 << (bs->payload & 7)) - 1);
+ break;
+
+ case 1: /* octets, lsb first */
+ j = bs->payload;
+ do {
+ for (k = 0; k < 8; ++k) {
+ LP_SAMPLE (VBI3_PAYLOAD_BIT);
+ c = (c >> 1) + ((raw0 >= tr) << 7);
+ i += bs->step;
+ }
+ *buffer++ = c;
+ } while (--j > 0);
+ break;
+
+ default: /* octets, msb first */
+ j = bs->payload;
+ do {
+ for (k = 0; k < 8; ++k) {
+ LP_SAMPLE (VBI3_PAYLOAD_BIT);
+ c = c * 2 + (raw0 >= tr);
+ i += bs->step;
+ }
+ *buffer++ = c;
+ } while (--j > 0);
+ break;
+ }
+
+ if (unlikely (NULL != points)) {
+ *n_points = points - points_start;
+ }
+
+ return TRUE;
+}
+
+static vbi_bool
+null_function (vbi3_bit_slicer * bs,
+ uint8_t * buffer,
+ vbi3_bit_slicer_point * points, unsigned int *n_points, const uint8_t * raw)
+{
+ buffer = buffer; /* unused */
+ points = points;
+ n_points = n_points;
+ raw = raw;
+
+ warning (&bs->log, "vbi3_bit_slicer_set_params() not called.");
+
+ return FALSE;
+}
+
+/**
+ * @param bs Pointer to vbi3_bit_slicer object allocated with
+ * vbi3_bit_slicer_new().
+ * @param buffer Output data.
+ * @param buffer_size Size of the output buffer. The buffer must be
+ + large enough to store the number of bits given as @a payload_bits to
+ * vbi3_bit_slicer_new().
+ * @param points Information about the bits sampled by the bit slicer
+ * are stored here.
+ * @param n_points The number of sampling points stored in the
+ * @a points array will be stored here.
+ * @param max_points Size of the @a points array. The array must be
+ * large enough to store one sampling point for all @a crc_bits,
+ * @a frc_bits and @a payload_bits given to vbi3_bit_slicer_new().
+ * @param raw Input data. At least the number of pixels or samples
+ * given as @a samples_per_line to vbi3_bit_slicer_new().
+ *
+ * Like vbi3_bit_slicer_slice() but additionally provides information
+ * about where and how bits were sampled. This is mainly interesting
+ * for debugging.
+ *
+ * @returns
+ * @c FALSE if the @a buffer or @a points array is too small, if the
+ * pixel format is not supported or if the raw data does not contain
+ * the expected information, i. e. the CRI/FRC has not been found. In
+ * these cases the @a buffer remains unmodified but the @a points
+ * array may contain data.
+ *
+ * @bug
+ * Currently this function is only implemented for
+ * raw data in planar YUV formats and @c VBI3_PIXFMT_Y8.
+ */
+vbi_bool
+ vbi3_bit_slicer_slice_with_points
+ (vbi3_bit_slicer * bs,
+ uint8_t * buffer,
+ unsigned int buffer_size,
+ vbi3_bit_slicer_point * points,
+ unsigned int *n_points, unsigned int max_points, const uint8_t * raw) {
+ static const vbi_pixfmt pixfmt = VBI_PIXFMT_Y8;
+ static const unsigned int bpp = 1;
+ static const unsigned int oversampling = 4; /* see above */
+ static const unsigned int thresh_frac = DEF_THR_FRAC;
+ static const vbi_bool collect_points = TRUE;
+ vbi3_bit_slicer_point *points_start;
+
+ assert (NULL != bs);
+ assert (NULL != buffer);
+ assert (NULL != points);
+ assert (NULL != n_points);
+ assert (NULL != raw);
+
+ points_start = points;
+ *n_points = 0;
+
+ if (bs->payload > buffer_size * 8) {
+ warning (&bs->log,
+ "buffer_size %u < %u bits of payload.", buffer_size * 8, bs->payload);
+ return FALSE;
+ }
+
+ if (bs->total_bits > max_points) {
+ warning (&bs->log,
+ "max_points %u < %u CRI, FRC and payload bits.",
+ max_points, bs->total_bits);
+ return FALSE;
+ }
+
+ if (low_pass_bit_slicer_Y8 == bs->func) {
+ return bs->func (bs, buffer, points, n_points, raw);
+ } else if (bit_slicer_Y8 != bs->func) {
+ warning (&bs->log,
+ "Function not implemented for pixfmt %u.", bs->sample_format);
+ return bs->func (bs, buffer,
+ /* points */ NULL,
+ /* n_points */ NULL,
+ raw);
+ }
+
+ CORE ();
+}
+
+/**
+ * @param bs Pointer to vbi3_bit_slicer object allocated with
+ * vbi3_bit_slicer_new(). You must also call
+ * vbi3_bit_slicer_set_params() before calling this function.
+ * @param buffer Output data.
+ * @param buffer_size Size of the output buffer. The buffer must be
+ + large enough to store the number of bits given as @a payload to
+ * vbi3_bit_slicer_new().
+ * @param raw Input data. At least the number of pixels or samples
+ * given as @a samples_per_line to vbi3_bit_slicer_new().
+ *
+ * Decodes one scan line of raw vbi data. Note the bit slicer tries
+ * to adapt to the average signal amplitude, you should avoid
+ * using the same vbi3_bit_slicer object for data from different
+ * devices.
+ *
+ * @return
+ * @c FALSE if the @a buffer is too small or if the raw data does not
+ * contain the expected information, i. e. the CRI/FRC has not been
+ * found. This may also result from a too weak or noisy signal. Error
+ * correction must be implemented at a higher layer. When the function
+ * fails, the @a buffer remains unmodified.
+ */
+vbi_bool
+vbi3_bit_slicer_slice (vbi3_bit_slicer * bs,
+ uint8_t * buffer, unsigned int buffer_size, const uint8_t * raw)
+{
+ assert (NULL != bs);
+ assert (NULL != buffer);
+ assert (NULL != raw);
+
+ if (bs->payload > buffer_size * 8) {
+ warning (&bs->log,
+ "buffer_size %u < %u bits of payload.", buffer_size * 8, bs->payload);
+ return FALSE;
+ }
+
+ return bs->func (bs, buffer,
+ /* points */ NULL,
+ /* n_points */ NULL,
+ raw);
+}
+
+/**
+ * @param bs Pointer to vbi3_bit_slicer object allocated with
+ * vbi3_bit_slicer_new().
+ * @param sample_format Format of the raw data, see vbi3_pixfmt.
+ * Note the bit slicer looks only at the green component of RGB
+ * pixels.
+ * @param sampling_rate Raw vbi sampling rate in Hz, that is the number
+ * of samples or pixels sampled per second by the hardware.
+ * @param sample_offset The bit slicer shall skip this number of samples at
+ * the start of the line.
+ * @param samples_per_line Number of samples or pixels in one raw vbi
+ * line later passed to vbi3_bit_slicer_slice(). This limits the number of
+ * bytes read from the raw data buffer. Do not to confuse the value
+ * with bytes per line.
+ * @param cri The Clock Run In is a NRZ modulated sequence of '1'
+ * and '0' bits prepending most data transmissions to synchronize data
+ * acquisition circuits. The bit slicer compares the bits in this
+ * word, lsb last transmitted, against the transmitted CRI. Decoding
+ * of FRC and payload starts with the next bit after a match, thus
+ * @a cri must contain a unique bit sequence. For example 0xAB to
+ * match '101010101011xxx'.
+ * @param cri_mask Of the CRI bits in @a cri, only these bits are
+ * significant for a match. For instance it is wise not to rely on
+ * the very first CRI bits transmitted.
+ * @param cri_bits Number of CRI bits, must not exceed 32.
+ * @param cri_rate CRI bit rate in Hz, the number of CRI bits
+ * transmitted per second.
+ * @param cri_end Number of samples between the start of the line and
+ * the latest possible end of the CRI. This is useful when
+ * the transmission is much shorter than samples_per_line, otherwise
+ * just pass @c ~0 and a limit will be calculated.
+ * @param frc The FRaming Code usually following the CRI is a bit
+ * sequence identifying the data service. There is no mask parameter,
+ * all bits must match. We assume FRC has the same @a modulation as
+ * the payload and is transmitted at @a payload_rate.
+ * @param frc_bits Number of FRC bits, must not exceed 32.
+ * @param payload_bits Number of payload bits. Only this data
+ * will be stored in the vbi3_bit_slicer_slice() output. If this number
+ * is no multiple of eight, the most significant bits of the
+ * last byte are undefined.
+ * @param payload_rate Payload bit rate in Hz, the number of payload
+ * bits transmitted per second.
+ * @param modulation Modulation of the payload, see vbi3_modulation.
+ *
+ * Initializes a vbi3_bit_slicer object for use with
+ * vbi3_bit_slicer_slice(). This is a low level function, see also
+ * vbi3_raw_decoder_new().
+ *
+ * @returns
+ * @c FALSE when the parameters are invalid (e. g.
+ * @a samples_per_line too small to contain CRI, FRC and payload).
+ */
+vbi_bool
+vbi3_bit_slicer_set_params (vbi3_bit_slicer * bs,
+ vbi_pixfmt sample_format,
+ unsigned int sampling_rate,
+ unsigned int sample_offset,
+ unsigned int samples_per_line,
+ unsigned int cri,
+ unsigned int cri_mask,
+ unsigned int cri_bits,
+ unsigned int cri_rate,
+ unsigned int cri_end,
+ unsigned int frc,
+ unsigned int frc_bits,
+ unsigned int payload_bits,
+ unsigned int payload_rate, vbi3_modulation modulation)
+{
+ unsigned int c_mask;
+ unsigned int f_mask;
+ unsigned int min_samples_per_bit;
+ unsigned int oversampling;
+ unsigned int data_bits;
+ unsigned int data_samples;
+ unsigned int cri_samples;
+ unsigned int skip;
+
+ assert (NULL != bs);
+ assert (cri_bits <= 32);
+ assert (frc_bits <= 32);
+ assert (payload_bits <= 32767);
+ assert (samples_per_line <= 32767);
+
+ if (cri_rate > sampling_rate) {
+ warning (&bs->log,
+ "cri_rate %u > sampling_rate %u.", cri_rate, sampling_rate);
+ goto failure;
+ }
+
+ if (payload_rate > sampling_rate) {
+ warning (&bs->log,
+ "payload_rate %u > sampling_rate %u.", payload_rate, sampling_rate);
+ goto failure;
+ }
+
+ min_samples_per_bit = sampling_rate / MAX (cri_rate, payload_rate);
+
+ bs->sample_format = sample_format;
+
+ c_mask = (cri_bits == 32) ? ~0U : (1U << cri_bits) - 1;
+ f_mask = (frc_bits == 32) ? ~0U : (1U << frc_bits) - 1;
+
+ oversampling = 4;
+ skip = 0;
+
+ /* 0-1 threshold, start value. */
+ bs->thresh = 105 << DEF_THR_FRAC;
+ bs->thresh_frac = DEF_THR_FRAC;
+
+ switch (sample_format) {
+ case VBI_PIXFMT_YUV420:
+ bs->bytes_per_sample = 1;
+ bs->func = bit_slicer_Y8;
+ if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
+ bs->func = low_pass_bit_slicer_Y8;
+ oversampling = 1;
+ bs->thresh <<= LP_AVG - 2;
+ bs->thresh_frac += LP_AVG - 2;
+ }
+ break;
+
+
+ case VBI_PIXFMT_YUYV:
+ case VBI_PIXFMT_YVYU:
+ bs->bytes_per_sample = 2;
+ bs->func = bit_slicer_YUYV;
+ if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
+ bs->func = low_pass_bit_slicer_Y8;
+ oversampling = 1;
+ bs->thresh <<= LP_AVG - 2;
+ bs->thresh_frac += LP_AVG - 2;
+ }
+ break;
+
+ case VBI_PIXFMT_UYVY:
+ case VBI_PIXFMT_VYUY:
+ skip = 1;
+ bs->bytes_per_sample = 2;
+ bs->func = bit_slicer_YUYV;
+ if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
+ bs->func = low_pass_bit_slicer_Y8;
+ oversampling = 1;
+ bs->thresh <<= LP_AVG - 2;
+ bs->thresh_frac += LP_AVG - 2;
+ }
+ break;
+
+ case VBI_PIXFMT_RGBA24_LE:
+ case VBI_PIXFMT_BGRA24_LE:
+ skip = 1;
+ bs->bytes_per_sample = 4;
+ bs->func = bit_slicer_RGBA24_LE;
+ if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
+ bs->func = low_pass_bit_slicer_Y8;
+ oversampling = 1;
+ bs->thresh <<= LP_AVG - 2;
+ bs->thresh_frac += LP_AVG - 2;
+ }
+ break;
+
+ case VBI_PIXFMT_RGBA24_BE:
+ case VBI_PIXFMT_BGRA24_BE:
+ skip = 2;
+ bs->bytes_per_sample = 4;
+ bs->func = bit_slicer_RGBA24_LE;
+ if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
+ bs->func = low_pass_bit_slicer_Y8;
+ oversampling = 1;
+ bs->thresh <<= LP_AVG - 2;
+ bs->thresh_frac += LP_AVG - 2;
+ }
+ break;
+
+ case VBI_PIXFMT_RGB24_LE:
+ case VBI_PIXFMT_BGR24_LE:
+ skip = 1;
+ bs->bytes_per_sample = 3;
+ bs->func = bit_slicer_RGB24_LE;
+ if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
+ bs->func = low_pass_bit_slicer_Y8;
+ oversampling = 1;
+ bs->thresh <<= LP_AVG - 2;
+ bs->thresh_frac += LP_AVG - 2;
+ }
+ break;
+
+ case VBI_PIXFMT_RGB16_LE:
+ case VBI_PIXFMT_BGR16_LE:
+ bs->func = bit_slicer_RGB16_LE;
+ bs->green_mask = 0x07E0;
+ bs->thresh = 105 << (5 - 2 + 12);
+ bs->thresh_frac = 12;
+ bs->bytes_per_sample = 2;
+ break;
+
+ case VBI_PIXFMT_RGB16_BE:
+ case VBI_PIXFMT_BGR16_BE:
+ bs->func = bit_slicer_RGB16_BE;
+ bs->green_mask = 0x07E0;
+ bs->thresh = 105 << (5 - 2 + 12);
+ bs->thresh_frac = 12;
+ bs->bytes_per_sample = 2;
+ break;
+
+ case VBI_PIXFMT_RGBA15_LE:
+ case VBI_PIXFMT_BGRA15_LE:
+ bs->func = bit_slicer_RGB16_LE;
+ bs->green_mask = 0x03E0;
+ bs->thresh = 105 << (5 - 3 + 11);
+ bs->thresh_frac = 11;
+ bs->bytes_per_sample = 2;
+ break;
+
+ case VBI_PIXFMT_RGBA15_BE:
+ case VBI_PIXFMT_BGRA15_BE:
+ bs->func = bit_slicer_RGB16_BE;
+ bs->green_mask = 0x03E0;
+ bs->thresh = 105 << (5 - 3 + 11);
+ bs->thresh_frac = 11;
+ bs->bytes_per_sample = 2;
+ break;
+
+ case VBI_PIXFMT_ARGB15_LE:
+ case VBI_PIXFMT_ABGR15_LE:
+ bs->func = bit_slicer_RGB16_LE;
+ bs->green_mask = 0x07C0;
+ bs->thresh = 105 << (6 - 3 + 12);
+ bs->thresh_frac = 12;
+ bs->bytes_per_sample = 2;
+ break;
+
+ case VBI_PIXFMT_ARGB15_BE:
+ case VBI_PIXFMT_ABGR15_BE:
+ bs->func = bit_slicer_RGB16_BE;
+ bs->green_mask = 0x07C0;
+ bs->thresh = 105 << (6 - 3 + 12);
+ bs->thresh_frac = 12;
+ bs->bytes_per_sample = 2;
+ break;
+
+
+ default:
+ warning (&bs->log,
+ "Unknown sample_format 0x%x.", (unsigned int) sample_format);
+ return FALSE;
+ }
+
+ bs->skip = sample_offset * bs->bytes_per_sample + skip;
+
+ bs->cri_mask = cri_mask & c_mask;
+ bs->cri = cri & bs->cri_mask;
+
+ /* We stop searching for CRI when CRI, FRC and payload
+ cannot possibly fit anymore. Additionally this eliminates
+ a data end check in the payload loop. */
+ cri_samples = (sampling_rate * (int64_t) cri_bits) / cri_rate;
+
+ data_bits = payload_bits + frc_bits;
+ data_samples = (sampling_rate * (int64_t) data_bits) / payload_rate;
+
+ bs->total_bits = cri_bits + data_bits;
+
+ if ((sample_offset > samples_per_line)
+ || ((cri_samples + data_samples)
+ > (samples_per_line - sample_offset))) {
+ warning (&bs->log,
+ "%u samples_per_line too small for "
+ "sample_offset %u + %u cri_bits (%u samples) "
+ "+ %u frc_bits and %u payload_bits "
+ "(%u samples).",
+ samples_per_line, sample_offset,
+ cri_bits, cri_samples, frc_bits, payload_bits, data_samples);
+ goto failure;
+ }
+
+ cri_end = MIN (cri_end, samples_per_line - data_samples);
+
+ bs->cri_samples = cri_end - sample_offset;
+ bs->cri_rate = cri_rate;
+
+ bs->oversampling_rate = sampling_rate * oversampling;
+
+ bs->frc = frc & f_mask;
+ bs->frc_bits = frc_bits;
+
+ /* Payload bit distance in 1/256 raw samples. */
+ bs->step = (sampling_rate * (int64_t) 256) / payload_rate;
+
+ if (payload_bits & 7) {
+ /* Use bit routines. */
+ bs->payload = payload_bits;
+ bs->endian = 3;
+ } else {
+ /* Use faster octet routines. */
+ bs->payload = payload_bits >> 3;
+ bs->endian = 1;
+ }
+
+ switch (modulation) {
+ case VBI3_MODULATION_NRZ_MSB:
+ --bs->endian;
+
+ /* fall through */
+
+ case VBI3_MODULATION_NRZ_LSB:
+ bs->phase_shift = (int)
+ (sampling_rate * 256.0 / cri_rate * .5 + bs->step * .5 + 128);
+ break;
+
+ case VBI3_MODULATION_BIPHASE_MSB:
+ --bs->endian;
+
+ /* fall through */
+
+ case VBI3_MODULATION_BIPHASE_LSB:
+ /* Phase shift between the NRZ modulated CRI and the
+ biphase modulated rest. */
+ bs->phase_shift = (int)
+ (sampling_rate * 256.0 / cri_rate * .5 + bs->step * .25 + 128);
+ break;
+ }
+
+ return TRUE;
+
+failure:
+ bs->func = null_function;
+
+ return FALSE;
+}
+
+void
+vbi3_bit_slicer_set_log_fn (vbi3_bit_slicer * bs,
+ vbi_log_mask mask, vbi_log_fn * log_fn, void *user_data)
+{
+ assert (NULL != bs);
+
+ if (NULL == log_fn)
+ mask = 0;
+
+ bs->log.mask = mask;
+ bs->log.fn = log_fn;
+ bs->log.user_data = user_data;
+}
+
+/**
+ * @internal
+ */
+void
+_vbi3_bit_slicer_destroy (vbi3_bit_slicer * bs)
+{
+ assert (NULL != bs);
+
+ /* Make unusable. */
+ CLEAR (*bs);
+}
+
+/**
+ * @internal
+ */
+vbi_bool
+_vbi3_bit_slicer_init (vbi3_bit_slicer * bs)
+{
+ assert (NULL != bs);
+
+ CLEAR (*bs);
+
+ bs->func = null_function;
+
+ return TRUE;
+}
+
+/**
+ * @param bs Pointer to a vbi3_bit_slicer object allocated with
+ * vbi3_bit_slicer_new(), can be NULL.
+ *
+ * Deletes a vbi3_bit_slicer object.
+ */
+void
+vbi3_bit_slicer_delete (vbi3_bit_slicer * bs)
+{
+ if (NULL == bs)
+ return;
+
+ _vbi3_bit_slicer_destroy (bs);
+
+ vbi_free (bs);
+}
+
+/**
+ * Allocates a new vbi3_bit_slicer object.
+ *
+ * @returns
+ * @c NULL when out of memory.
+ */
+vbi3_bit_slicer *
+vbi3_bit_slicer_new (void)
+{
+ vbi3_bit_slicer *bs;
+
+ bs = vbi_malloc (sizeof (*bs));
+ if (NULL == bs) {
+ return NULL;
+ }
+
+ _vbi3_bit_slicer_init (bs);
+
+ return bs;
+}
+
+/*
+Local variables:
+c-set-style: K&R
+c-basic-offset: 8
+End:
+*/
diff --git a/ext/closedcaption/bit_slicer.h b/ext/closedcaption/bit_slicer.h
new file mode 100644
index 0000000000..a537f4f802
--- /dev/null
+++ b/ext/closedcaption/bit_slicer.h
@@ -0,0 +1,197 @@
+/*
+ * libzvbi -- Bit slicer
+ *
+ * Copyright (C) 2000-2007 Michael H. Schimek
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ */
+
+/* $Id: bit_slicer.h,v 1.11 2008-02-24 14:18:13 mschimek Exp $ */
+
+#ifndef __ZVBI_BIT_SLICER_H__
+#define __ZVBI_BIT_SLICER_H__
+
+#include "sampling_par.h"
+
+VBI_BEGIN_DECLS
+
+/**
+ * @addtogroup BitSlicer
+ * @{
+ */
+
+/**
+ * @brief Modulation used for VBI data transmission.
+ */
+typedef enum {
+ /**
+ * The data is 'non-return to zero' coded, logical '1' bits
+ * are described by high sample values, logical '0' bits by
+ * low values. The data is last significant bit first transmitted.
+ */
+ VBI3_MODULATION_NRZ_LSB,
+
+ /**
+ * 'Non-return to zero' coded, most significant bit first
+ * transmitted.
+ */
+ VBI3_MODULATION_NRZ_MSB,
+
+ /**
+ * The data is 'bi-phase' coded. Each data bit is described
+ * by two complementary signalling elements, a logical '1'
+ * by a sequence of '10' elements, a logical '0' by a '01'
+ * sequence. The data is last significant bit first transmitted.
+ */
+ VBI3_MODULATION_BIPHASE_LSB,
+
+ /** 'Bi-phase' coded, most significant bit first transmitted. */
+ VBI3_MODULATION_BIPHASE_MSB
+} vbi3_modulation;
+
+/**
+ * @brief Bit slicer context.
+ *
+ * The contents of this structure are private.
+ * Call vbi3_bit_slicer_new() to allocate a bit slicer context.
+ */
+typedef struct _vbi3_bit_slicer vbi3_bit_slicer;
+
+typedef enum {
+ VBI3_CRI_BIT = 1,
+ VBI3_FRC_BIT,
+ VBI3_PAYLOAD_BIT
+} vbi3_bit_slicer_bit;
+
+/**
+ * @brief Bit slicer sampling point.
+ *
+ * This structure contains information about
+ * a bit sampled by the bit slicer.
+ */
+typedef struct {
+ /** Whether this struct refers to a CRI, FRC or payload bit. */
+ vbi3_bit_slicer_bit kind;
+
+ /** Number of the sample times 256. */
+ unsigned int index;
+
+ /** Signal amplitude at this sample, in range 0 to 65535. */
+ unsigned int level;
+
+ /** 0/1 threshold at this sample, in range 0 to 65535. */
+ unsigned int thresh;
+} vbi3_bit_slicer_point;
+
+extern vbi_bool
+vbi3_bit_slicer_slice_with_points
+ (vbi3_bit_slicer * bs,
+ uint8_t * buffer,
+ unsigned int buffer_size,
+ vbi3_bit_slicer_point *points,
+ unsigned int * n_points,
+ unsigned int max_points,
+ const uint8_t * raw)
+ _vbi_nonnull ((1, 2, 4, 5, 7));
+extern vbi_bool
+vbi3_bit_slicer_slice (vbi3_bit_slicer * bs,
+ uint8_t * buffer,
+ unsigned int buffer_size,
+ const uint8_t * raw)
+ _vbi_nonnull ((1, 2, 4));
+extern vbi_bool
+vbi3_bit_slicer_set_params (vbi3_bit_slicer * bs,
+ vbi_pixfmt sample_format,
+ unsigned int sampling_rate,
+ unsigned int sample_offset,
+ unsigned int samples_per_line,
+ unsigned int cri,
+ unsigned int cri_mask,
+ unsigned int cri_bits,
+ unsigned int cri_rate,
+ unsigned int cri_end,
+ unsigned int frc,
+ unsigned int frc_bits,
+ unsigned int payload_bits,
+ unsigned int payload_rate,
+ vbi3_modulation modulation)
+ _vbi_nonnull ((1));
+extern void
+vbi3_bit_slicer_set_log_fn (vbi3_bit_slicer * bs,
+ vbi_log_mask mask,
+ vbi_log_fn * log_fn,
+ void * user_data)
+ _vbi_nonnull ((1));
+extern void
+vbi3_bit_slicer_delete (vbi3_bit_slicer * bs);
+extern vbi3_bit_slicer *
+vbi3_bit_slicer_new (void)
+ _vbi_alloc;
+
+/* Private */
+
+typedef vbi_bool
+_vbi3_bit_slicer_fn (vbi3_bit_slicer * bs,
+ uint8_t * buffer,
+ vbi3_bit_slicer_point *points,
+ unsigned int * n_points,
+ const uint8_t * raw);
+
+/** @internal */
+struct _vbi3_bit_slicer {
+ _vbi3_bit_slicer_fn * func;
+
+ vbi_pixfmt sample_format;
+ unsigned int cri;
+ unsigned int cri_mask;
+ unsigned int thresh;
+ unsigned int thresh_frac;
+ unsigned int cri_samples;
+ unsigned int cri_rate;
+ unsigned int oversampling_rate;
+ unsigned int phase_shift;
+ unsigned int step;
+ unsigned int frc;
+ unsigned int frc_bits;
+ unsigned int total_bits;
+ unsigned int payload;
+ unsigned int endian;
+ unsigned int bytes_per_sample;
+ unsigned int skip;
+ unsigned int green_mask;
+
+ _vbi_log_hook log;
+};
+
+extern void
+_vbi3_bit_slicer_destroy (vbi3_bit_slicer * bs)
+ _vbi_nonnull ((1));
+extern vbi_bool
+_vbi3_bit_slicer_init (vbi3_bit_slicer * bs)
+ _vbi_nonnull ((1));
+
+/** @} */
+
+VBI_END_DECLS
+
+#endif /* __ZVBI_BIT_SLICER_H__ */
+
+/*
+Local variables:
+c-set-style: K&R
+c-basic-offset: 8
+End:
+*/
diff --git a/ext/closedcaption/decoder.c b/ext/closedcaption/decoder.c
new file mode 100644
index 0000000000..98933b1c85
--- /dev/null
+++ b/ext/closedcaption/decoder.c
@@ -0,0 +1,832 @@
+/*
+ * libzvbi -- Old raw VBI decoder
+ *
+ * Copyright (C) 2000, 2001, 2002 Michael H. Schimek
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ */
+
+/* $Id: decoder.c,v 1.25 2008-02-19 00:35:15 mschimek Exp $ */
+
+/* Note this code is only retained for compatibility with older versions
+ of libzvbi. vbi_raw_decoder is now just a wrapper for the new raw
+ decoder (raw_decoder.c) and bit slicer (bit_slicer.c). We'll drop
+ the old API in libzvbi 0.3. Other modules (e.g. io-v4l2k.c) should
+ already use the new raw VBI decoder directly. */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include