1 /*
2 * libzvbi - Bit slicer
3 *
4 * Copyright (C) 2000-2007 Michael H. Schimek
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library 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 GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 * Boston, MA 02110-1301 USA.
20 */
21
22 /* $Id: bit_slicer.c,v 1.16 2008-02-19 00:35:14 mschimek Exp $ */
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include "misc.h"
29 #include "bit_slicer.h"
30
31 # define VBI_PIXFMT_Y8 VBI_PIXFMT_YUV420
32 # define VBI_PIXFMT_RGB24_LE VBI_PIXFMT_RGB24
33 # define VBI_PIXFMT_BGR24_LE VBI_PIXFMT_BGR24
34 # define VBI_PIXFMT_RGBA24_LE VBI_PIXFMT_RGBA32_LE
35 # define VBI_PIXFMT_BGRA24_LE VBI_PIXFMT_BGRA32_LE
36 # define VBI_PIXFMT_RGBA24_BE VBI_PIXFMT_RGBA32_BE
37 # define VBI_PIXFMT_BGRA24_BE VBI_PIXFMT_BGRA32_BE
38 # define vbi_pixfmt_bytes_per_pixel VBI_PIXFMT_BPP
39
40 /**
41 * $addtogroup BitSlicer Bit Slicer
42 * $ingroup Raw
43 * $brief Converting a single scan line of raw VBI
44 * data to sliced VBI data.
45 *
46 * These are low level functions most useful if you want to decode
47 * data services not covered by libzvbi. Usually you will want to
48 * use the raw VBI decoder, converting several lines of different
49 * data services at once.
50 */
51
52 /* This is time critical, tinker with care.
53
54 What about all these macros? They are templates to avoid a
55 pixel format switch within time critical loops. Instead we
56 compile bit slicer functions for different pixel formats.
57
58 I would use inline functions for proper type checking, but
59 there's no guarantee the compiler really will inline. */
60
61 /* Read a green sample, e.g. rrrrrggg gggbbbbb. endian is const. */
62 #define GREEN2(raw, endian) \
63 (((raw)[0 + endian] + (raw)[1 - endian] * 256) & bs->green_mask)
64
65 /* Read a sample with pixfmt conversion. pixfmt is const. */
66 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
67 #define GREEN(raw) \
68 ((VBI_PIXFMT_RGB16_LE == pixfmt) ? \
69 *(const uint16_t *)(raw) & bs->green_mask : \
70 ((VBI_PIXFMT_RGB16_BE == pixfmt) ? \
71 GREEN2 (raw, 1) : \
72 (raw)[0]))
73 #elif G_BYTE_ORDER == G_BIG_ENDIAN
74 #define GREEN(raw) \
75 ((VBI_PIXFMT_RGB16_LE == pixfmt) ? \
76 GREEN2 (raw, 0) : \
77 ((VBI_PIXFMT_RGB16_BE == pixfmt) ? \
78 *(const uint16_t *)(raw) & bs->green_mask : \
79 (raw)[0]))
80 #else
81 #define GREEN(raw) \
82 ((VBI_PIXFMT_RGB16_LE == pixfmt) ? \
83 GREEN2 (raw, 0) : \
84 ((VBI_PIXFMT_RGB16_BE == pixfmt) ? \
85 GREEN2 (raw, 1) : \
86 (raw)[0]))
87 #endif
88
89 /* raw0 = raw[index >> 8], linear interpolated. */
90 #define SAMPLE(_kind) \
91 do { \
92 const uint8_t *r; \
93 \
94 r = raw + (i >> 8) * bpp; \
95 raw0 = GREEN (r); \
96 raw1 = GREEN (r + bpp); \
97 raw0 = (int)(raw1 - raw0) * (i & 255) + (raw0 << 8); \
98 if (collect_points) { \
99 points->kind = _kind; \
100 points->index = (raw - raw_start) * 256 + i; \
101 points->level = raw0; \
102 points->thresh = tr; \
103 ++points; \
104 } \
105 } while (0)
106
107 #define PAYLOAD() \
108 do { \
109 i = bs->phase_shift; /* current bit position << 8 */ \
110 tr *= 256; \
111 c = 0; \
112 \
113 for (j = bs->frc_bits; j > 0; --j) { \
114 SAMPLE (VBI3_FRC_BIT); \
115 c = c * 2 + (raw0 >= tr); \
116 i += bs->step; /* next bit */ \
117 } \
118 \
119 if (c != bs->frc) \
120 return FALSE; \
121 \
122 switch (bs->endian) { \
123 case 3: /* bitwise, lsb first */ \
124 for (j = 0; j < bs->payload; ++j) { \
125 SAMPLE (VBI3_PAYLOAD_BIT); \
126 c = (c >> 1) + ((raw0 >= tr) << 7); \
127 i += bs->step; \
128 if ((j & 7) == 7) \
129 *buffer++ = c; \
130 } \
131 *buffer = c >> ((8 - bs->payload) & 7); \
132 break; \
133 \
134 case 2: /* bitwise, msb first */ \
135 for (j = 0; j < bs->payload; ++j) { \
136 SAMPLE (VBI3_PAYLOAD_BIT); \
137 c = c * 2 + (raw0 >= tr); \
138 i += bs->step; \
139 if ((j & 7) == 7) \
140 *buffer++ = c; \
141 } \
142 *buffer = c & ((1 << (bs->payload & 7)) - 1); \
143 break; \
144 \
145 case 1: /* octets, lsb first */ \
146 for (j = bs->payload; j > 0; --j) { \
147 for (k = 0, c = 0; k < 8; ++k) { \
148 SAMPLE (VBI3_PAYLOAD_BIT); \
149 c += (raw0 >= tr) << k; \
150 i += bs->step; \
151 } \
152 *buffer++ = c; \
153 } \
154 break; \
155 \
156 default: /* octets, msb first */ \
157 for (j = bs->payload; j > 0; --j) { \
158 for (k = 0; k < 8; ++k) { \
159 SAMPLE (VBI3_PAYLOAD_BIT); \
160 c = c * 2 + (raw0 >= tr); \
161 i += bs->step; \
162 } \
163 *buffer++ = c; \
164 } \
165 break; \
166 } \
167 } while (0)
168
169 #define CRI() \
170 do { \
171 unsigned int tavg; \
172 unsigned char b; /* current bit */ \
173 \
174 tavg = (t + (oversampling / 2)) / oversampling; \
175 b = (tavg >= tr); \
176 \
177 if (unlikely (b ^ b1)) { \
178 cl = bs->oversampling_rate >> 1; \
179 } else { \
180 cl += bs->cri_rate; \
181 \
182 if (cl >= bs->oversampling_rate) { \
183 if (collect_points) { \
184 points->kind = VBI3_CRI_BIT; \
185 points->index = (raw - raw_start) << 8; \
186 points->level = tavg << 8; \
187 points->thresh = tr << 8; \
188 ++points; \
189 } \
190 \
191 cl -= bs->oversampling_rate; \
192 c = c * 2 + b; \
193 if ((c & bs->cri_mask) == bs->cri) { \
194 PAYLOAD (); \
195 if (collect_points) { \
196 *n_points = points \
197 - points_start; \
198 } \
199 return TRUE; \
200 } \
201 } \
202 } \
203 \
204 b1 = b; \
205 \
206 if (oversampling > 1) \
207 t += raw1; \
208 } while (0)
209
210 #define CORE() \
211 do { \
212 const uint8_t *raw_start; \
213 unsigned int i, j, k; \
214 unsigned int cl; /* clock */ \
215 unsigned int thresh0; /* old 0/1 threshold */ \
216 unsigned int tr; /* current threshold */ \
217 unsigned int c; /* current byte */ \
218 unsigned int t; /* t = raw[0] * j + raw[1] * (1 - j) */ \
219 unsigned int raw0; /* oversampling temporary */ \
220 unsigned int raw1; \
221 unsigned char b1; /* previous bit */ \
222 \
223 thresh0 = bs->thresh; \
224 raw_start = raw; \
225 raw += bs->skip; \
226 \
227 cl = 0; \
228 c = 0; \
229 b1 = 0; \
230 \
231 for (i = bs->cri_samples; i > 0; --i) { \
232 tr = bs->thresh >> thresh_frac; \
233 raw0 = GREEN (raw); \
234 raw1 = GREEN (raw + bpp); \
235 raw1 -= raw0; \
236 bs->thresh += (int)(raw0 - tr) * (int) ABS ((int) raw1); \
237 t = raw0 * oversampling; \
238 \
239 for (j = oversampling; j > 0; --j) \
240 CRI (); \
241 \
242 raw += bpp; \
243 } \
244 \
245 bs->thresh = thresh0; \
246 \
247 if (collect_points) \
248 *n_points = points - points_start; \
249 \
250 return FALSE; \
251 } while (0)
252
253 #define BIT_SLICER(fmt, os, tf) \
254 static vbi_bool \
255 bit_slicer_ ## fmt (vbi3_bit_slicer * bs, \
256 uint8_t * buffer, \
257 vbi3_bit_slicer_point *points, \
258 unsigned int * n_points, \
259 const uint8_t * raw) \
260 { \
261 static const vbi_pixfmt pixfmt = VBI_PIXFMT_ ## fmt; \
262 unsigned int bpp = \
263 vbi_pixfmt_bytes_per_pixel (VBI_PIXFMT_ ## fmt); \
264 static const unsigned int oversampling = os; \
265 static const vbi3_bit_slicer_point *points_start = NULL; \
266 static const vbi_bool collect_points = FALSE; \
267 unsigned int thresh_frac = tf; \
268 \
269 CORE (); \
270 }
271
272 #define DEF_THR_FRAC 9
273
274 BIT_SLICER (Y8, 4, DEF_THR_FRAC) /* any format with 0 bytes between Y or G */
275 BIT_SLICER (YUYV, 4, DEF_THR_FRAC) /* 1 byte */
276 BIT_SLICER (RGB24_LE, 4, DEF_THR_FRAC) /* 2 bytes */
277 BIT_SLICER (RGBA24_LE, 4, DEF_THR_FRAC) /* 3 bytes */
278 BIT_SLICER (RGB16_LE, 4, bs->thresh_frac)
279 BIT_SLICER (RGB16_BE, 4, bs->thresh_frac)
280
281 static const unsigned int LP_AVG = 4;
282
283 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)284 low_pass_bit_slicer_Y8 (vbi3_bit_slicer * bs,
285 uint8_t * buffer,
286 vbi3_bit_slicer_point * points, unsigned int *n_points, const uint8_t * raw)
287 {
288 vbi3_bit_slicer_point *points_start;
289 const uint8_t *raw_start;
290 unsigned int i, j, k, m;
291 unsigned int cl; /* clock */
292 unsigned int thresh0; /* old 0/1 threshold */
293 unsigned int tr; /* current threshold */
294 unsigned int c; /* current byte */
295 unsigned int raw0; /* oversampling temporary */
296 unsigned char b1; /* previous bit */
297 unsigned int bps;
298 unsigned int raw0sum;
299
300 points_start = points;
301
302 raw_start = raw;
303 raw += bs->skip;
304
305 bps = bs->bytes_per_sample;
306
307 thresh0 = bs->thresh;
308
309 c = -1;
310 cl = 0;
311 b1 = 0;
312
313 raw0sum = raw[0];
314 for (m = bps; m < (bps << LP_AVG); m += bps) {
315 raw0sum += raw[m];
316 }
317
318 i = bs->cri_samples;
319
320 for (;;) {
321 unsigned char b; /* current bit */
322
323 tr = bs->thresh >> bs->thresh_frac;
324 raw0 = raw0sum;
325 raw0sum = raw0sum + raw[bps << LP_AVG]
326 - raw[0];
327 raw += bps;
328 bs->thresh += (int) (raw0 - tr)
329 * (int) ABS ((int) (raw0sum - raw0));
330
331 b = (raw0 >= tr);
332
333 if (unlikely (b ^ b1)) {
334 cl = bs->oversampling_rate >> 1;
335 } else {
336 cl += bs->cri_rate;
337
338 if (cl >= bs->oversampling_rate) {
339 if (unlikely (NULL != points)) {
340 points->kind = VBI3_CRI_BIT;
341 points->index = (raw - raw_start)
342 * 256 / bs->bytes_per_sample + (1 << LP_AVG) * 128;
343 points->level = raw0 << (8 - LP_AVG);
344 points->thresh = tr << (8 - LP_AVG);
345 ++points;
346 }
347
348 cl -= bs->oversampling_rate;
349 c = c * 2 + b;
350 if ((c & bs->cri_mask) == bs->cri) {
351 break;
352 }
353 }
354 }
355
356 b1 = b;
357
358 if (0 == --i) {
359 bs->thresh = thresh0;
360
361 if (unlikely (NULL != points))
362 *n_points = points - points_start;
363
364 return FALSE;
365 }
366 }
367
368 #define LP_SAMPLE(_kind) \
369 do { \
370 unsigned int ii = (i >> 8) * bps; \
371 \
372 raw0 = raw[ii]; \
373 for (m = bps; m < (bps << LP_AVG); m += bps) \
374 raw0 += raw[ii + m]; \
375 if (unlikely (NULL != points)) { \
376 points->kind = _kind; \
377 points->index = (raw - raw_start) \
378 * 256 / bs->bytes_per_sample \
379 + (1 << LP_AVG) * 128 \
380 + ii * 256; \
381 points->level = raw0 << (8 - LP_AVG); \
382 points->thresh = tr << (8 - LP_AVG); \
383 ++points; \
384 } \
385 } while (0)
386
387 i = bs->phase_shift; /* current bit position << 8 */
388 c = 0;
389
390 for (j = bs->frc_bits; j > 0; --j) {
391 LP_SAMPLE (VBI3_FRC_BIT);
392 c = c * 2 + (raw0 >= tr);
393 i += bs->step; /* next bit */
394 }
395
396 if (c != bs->frc)
397 return FALSE;
398
399 c = 0;
400
401 switch (bs->endian) {
402 case 3: /* bitwise, lsb first */
403 for (j = 0; j < bs->payload; ++j) {
404 LP_SAMPLE (VBI3_PAYLOAD_BIT);
405 c = (c >> 1) + ((raw0 >= tr) << 7);
406 i += bs->step;
407 if ((j & 7) == 7)
408 *buffer++ = c;
409 }
410 *buffer = c >> ((8 - bs->payload) & 7);
411 break;
412
413 case 2: /* bitwise, msb first */
414 for (j = 0; j < bs->payload; ++j) {
415 LP_SAMPLE (VBI3_PAYLOAD_BIT);
416 c = c * 2 + (raw0 >= tr);
417 i += bs->step;
418 if ((j & 7) == 7)
419 *buffer++ = c;
420 }
421 *buffer = c & ((1 << (bs->payload & 7)) - 1);
422 break;
423
424 case 1: /* octets, lsb first */
425 j = bs->payload;
426 do {
427 for (k = 0; k < 8; ++k) {
428 LP_SAMPLE (VBI3_PAYLOAD_BIT);
429 c = (c >> 1) + ((raw0 >= tr) << 7);
430 i += bs->step;
431 }
432 *buffer++ = c;
433 } while (--j > 0);
434 break;
435
436 default: /* octets, msb first */
437 j = bs->payload;
438 do {
439 for (k = 0; k < 8; ++k) {
440 LP_SAMPLE (VBI3_PAYLOAD_BIT);
441 c = c * 2 + (raw0 >= tr);
442 i += bs->step;
443 }
444 *buffer++ = c;
445 } while (--j > 0);
446 break;
447 }
448
449 if (unlikely (NULL != points)) {
450 *n_points = points - points_start;
451 }
452
453 return TRUE;
454 }
455
456 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)457 null_function (vbi3_bit_slicer * bs,
458 uint8_t * buffer,
459 vbi3_bit_slicer_point * points, unsigned int *n_points, const uint8_t * raw)
460 {
461 /* buffer = buffer; /\* unused *\/ */
462 /* points = points; */
463 /* n_points = n_points; */
464 /* raw = raw; */
465
466 warning (&bs->log, "vbi3_bit_slicer_set_params() not called.");
467
468 return FALSE;
469 }
470
471 /**
472 * @param bs Pointer to vbi3_bit_slicer object allocated with
473 * vbi3_bit_slicer_new().
474 * @param buffer Output data.
475 * @param buffer_size Size of the output buffer. The buffer must be
476 + large enough to store the number of bits given as @a payload_bits to
477 * vbi3_bit_slicer_new().
478 * @param points Information about the bits sampled by the bit slicer
479 * are stored here.
480 * @param n_points The number of sampling points stored in the
481 * @a points array will be stored here.
482 * @param max_points Size of the @a points array. The array must be
483 * large enough to store one sampling point for all @a crc_bits,
484 * @a frc_bits and @a payload_bits given to vbi3_bit_slicer_new().
485 * @param raw Input data. At least the number of pixels or samples
486 * given as @a samples_per_line to vbi3_bit_slicer_new().
487 *
488 * Like vbi3_bit_slicer_slice() but additionally provides information
489 * about where and how bits were sampled. This is mainly interesting
490 * for debugging.
491 *
492 * @returns
493 * @c FALSE if the @a buffer or @a points array is too small, if the
494 * pixel format is not supported or if the raw data does not contain
495 * the expected information, i. e. the CRI/FRC has not been found. In
496 * these cases the @a buffer remains unmodified but the @a points
497 * array may contain data.
498 *
499 * @bug
500 * Currently this function is only implemented for
501 * raw data in planar YUV formats and @c VBI3_PIXFMT_Y8.
502 */
503 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)504 vbi3_bit_slicer_slice_with_points
505 (vbi3_bit_slicer * bs,
506 uint8_t * buffer,
507 unsigned int buffer_size,
508 vbi3_bit_slicer_point * points,
509 unsigned int *n_points, unsigned int max_points, const uint8_t * raw) {
510 static const vbi_pixfmt pixfmt = VBI_PIXFMT_Y8;
511 static const unsigned int bpp = 1;
512 static const unsigned int oversampling = 4; /* see above */
513 static const unsigned int thresh_frac = DEF_THR_FRAC;
514 static const vbi_bool collect_points = TRUE;
515 vbi3_bit_slicer_point *points_start;
516
517 assert (NULL != bs);
518 assert (NULL != buffer);
519 assert (NULL != points);
520 assert (NULL != n_points);
521 assert (NULL != raw);
522
523 points_start = points;
524 *n_points = 0;
525
526 if (bs->payload > buffer_size * 8) {
527 warning (&bs->log,
528 "buffer_size %u < %u bits of payload.", buffer_size * 8, bs->payload);
529 return FALSE;
530 }
531
532 if (bs->total_bits > max_points) {
533 warning (&bs->log,
534 "max_points %u < %u CRI, FRC and payload bits.",
535 max_points, bs->total_bits);
536 return FALSE;
537 }
538
539 if (low_pass_bit_slicer_Y8 == bs->func) {
540 return bs->func (bs, buffer, points, n_points, raw);
541 } else if (bit_slicer_Y8 != bs->func) {
542 warning (&bs->log,
543 "Function not implemented for pixfmt %u.", bs->sample_format);
544 return bs->func (bs, buffer,
545 /* points */ NULL,
546 /* n_points */ NULL,
547 raw);
548 }
549
550 CORE ();
551 }
552
553 /**
554 * @param bs Pointer to vbi3_bit_slicer object allocated with
555 * vbi3_bit_slicer_new(). You must also call
556 * vbi3_bit_slicer_set_params() before calling this function.
557 * @param buffer Output data.
558 * @param buffer_size Size of the output buffer. The buffer must be
559 + large enough to store the number of bits given as @a payload to
560 * vbi3_bit_slicer_new().
561 * @param raw Input data. At least the number of pixels or samples
562 * given as @a samples_per_line to vbi3_bit_slicer_new().
563 *
564 * Decodes one scan line of raw vbi data. Note the bit slicer tries
565 * to adapt to the average signal amplitude, you should avoid
566 * using the same vbi3_bit_slicer object for data from different
567 * devices.
568 *
569 * @return
570 * @c FALSE if the @a buffer is too small or if the raw data does not
571 * contain the expected information, i. e. the CRI/FRC has not been
572 * found. This may also result from a too weak or noisy signal. Error
573 * correction must be implemented at a higher layer. When the function
574 * fails, the @a buffer remains unmodified.
575 */
576 vbi_bool
vbi3_bit_slicer_slice(vbi3_bit_slicer * bs,uint8_t * buffer,unsigned int buffer_size,const uint8_t * raw)577 vbi3_bit_slicer_slice (vbi3_bit_slicer * bs,
578 uint8_t * buffer, unsigned int buffer_size, const uint8_t * raw)
579 {
580 assert (NULL != bs);
581 assert (NULL != buffer);
582 assert (NULL != raw);
583
584 if (bs->payload > buffer_size * 8) {
585 warning (&bs->log,
586 "buffer_size %u < %u bits of payload.", buffer_size * 8, bs->payload);
587 return FALSE;
588 }
589
590 return bs->func (bs, buffer,
591 /* points */ NULL,
592 /* n_points */ NULL,
593 raw);
594 }
595
596 /**
597 * @param bs Pointer to vbi3_bit_slicer object allocated with
598 * vbi3_bit_slicer_new().
599 * @param sample_format Format of the raw data, see vbi3_pixfmt.
600 * Note the bit slicer looks only at the green component of RGB
601 * pixels.
602 * @param sampling_rate Raw vbi sampling rate in Hz, that is the number
603 * of samples or pixels sampled per second by the hardware.
604 * @param sample_offset The bit slicer shall skip this number of samples at
605 * the start of the line.
606 * @param samples_per_line Number of samples or pixels in one raw vbi
607 * line later passed to vbi3_bit_slicer_slice(). This limits the number of
608 * bytes read from the raw data buffer. Do not to confuse the value
609 * with bytes per line.
610 * @param cri The Clock Run In is a NRZ modulated sequence of '1'
611 * and '0' bits prepending most data transmissions to synchronize data
612 * acquisition circuits. The bit slicer compares the bits in this
613 * word, lsb last transmitted, against the transmitted CRI. Decoding
614 * of FRC and payload starts with the next bit after a match, thus
615 * @a cri must contain a unique bit sequence. For example 0xAB to
616 * match '101010101011xxx'.
617 * @param cri_mask Of the CRI bits in @a cri, only these bits are
618 * significant for a match. For instance it is wise not to rely on
619 * the very first CRI bits transmitted.
620 * @param cri_bits Number of CRI bits, must not exceed 32.
621 * @param cri_rate CRI bit rate in Hz, the number of CRI bits
622 * transmitted per second.
623 * @param cri_end Number of samples between the start of the line and
624 * the latest possible end of the CRI. This is useful when
625 * the transmission is much shorter than samples_per_line, otherwise
626 * just pass @c ~0 and a limit will be calculated.
627 * @param frc The FRaming Code usually following the CRI is a bit
628 * sequence identifying the data service. There is no mask parameter,
629 * all bits must match. We assume FRC has the same @a modulation as
630 * the payload and is transmitted at @a payload_rate.
631 * @param frc_bits Number of FRC bits, must not exceed 32.
632 * @param payload_bits Number of payload bits. Only this data
633 * will be stored in the vbi3_bit_slicer_slice() output. If this number
634 * is no multiple of eight, the most significant bits of the
635 * last byte are undefined.
636 * @param payload_rate Payload bit rate in Hz, the number of payload
637 * bits transmitted per second.
638 * @param modulation Modulation of the payload, see vbi3_modulation.
639 *
640 * Initializes a vbi3_bit_slicer object for use with
641 * vbi3_bit_slicer_slice(). This is a low level function, see also
642 * vbi3_raw_decoder_new().
643 *
644 * @returns
645 * @c FALSE when the parameters are invalid (e. g.
646 * @a samples_per_line too small to contain CRI, FRC and payload).
647 */
648 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)649 vbi3_bit_slicer_set_params (vbi3_bit_slicer * bs,
650 vbi_pixfmt sample_format,
651 unsigned int sampling_rate,
652 unsigned int sample_offset,
653 unsigned int samples_per_line,
654 unsigned int cri,
655 unsigned int cri_mask,
656 unsigned int cri_bits,
657 unsigned int cri_rate,
658 unsigned int cri_end,
659 unsigned int frc,
660 unsigned int frc_bits,
661 unsigned int payload_bits,
662 unsigned int payload_rate, vbi3_modulation modulation)
663 {
664 unsigned int c_mask;
665 unsigned int f_mask;
666 unsigned int min_samples_per_bit;
667 unsigned int oversampling;
668 unsigned int data_bits;
669 unsigned int data_samples;
670 unsigned int cri_samples;
671 unsigned int skip;
672
673 assert (NULL != bs);
674 assert (cri_bits <= 32);
675 assert (frc_bits <= 32);
676 assert (payload_bits <= 32767);
677 assert (samples_per_line <= 32767);
678
679 if (cri_rate > sampling_rate) {
680 warning (&bs->log,
681 "cri_rate %u > sampling_rate %u.", cri_rate, sampling_rate);
682 goto failure;
683 }
684
685 if (payload_rate > sampling_rate) {
686 warning (&bs->log,
687 "payload_rate %u > sampling_rate %u.", payload_rate, sampling_rate);
688 goto failure;
689 }
690
691 min_samples_per_bit = sampling_rate / MAX (cri_rate, payload_rate);
692
693 bs->sample_format = sample_format;
694
695 c_mask = (cri_bits == 32) ? ~0U : (1U << cri_bits) - 1;
696 f_mask = (frc_bits == 32) ? ~0U : (1U << frc_bits) - 1;
697
698 oversampling = 4;
699 skip = 0;
700
701 /* 0-1 threshold, start value. */
702 bs->thresh = 105 << DEF_THR_FRAC;
703 bs->thresh_frac = DEF_THR_FRAC;
704
705 switch (sample_format) {
706 case VBI_PIXFMT_YUV420:
707 bs->bytes_per_sample = 1;
708 bs->func = bit_slicer_Y8;
709 if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
710 bs->func = low_pass_bit_slicer_Y8;
711 oversampling = 1;
712 bs->thresh <<= LP_AVG - 2;
713 bs->thresh_frac += LP_AVG - 2;
714 }
715 break;
716
717
718 case VBI_PIXFMT_YUYV:
719 case VBI_PIXFMT_YVYU:
720 bs->bytes_per_sample = 2;
721 bs->func = bit_slicer_YUYV;
722 if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
723 bs->func = low_pass_bit_slicer_Y8;
724 oversampling = 1;
725 bs->thresh <<= LP_AVG - 2;
726 bs->thresh_frac += LP_AVG - 2;
727 }
728 break;
729
730 case VBI_PIXFMT_UYVY:
731 case VBI_PIXFMT_VYUY:
732 skip = 1;
733 bs->bytes_per_sample = 2;
734 bs->func = bit_slicer_YUYV;
735 if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
736 bs->func = low_pass_bit_slicer_Y8;
737 oversampling = 1;
738 bs->thresh <<= LP_AVG - 2;
739 bs->thresh_frac += LP_AVG - 2;
740 }
741 break;
742
743 case VBI_PIXFMT_RGBA24_LE:
744 case VBI_PIXFMT_BGRA24_LE:
745 skip = 1;
746 bs->bytes_per_sample = 4;
747 bs->func = bit_slicer_RGBA24_LE;
748 if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
749 bs->func = low_pass_bit_slicer_Y8;
750 oversampling = 1;
751 bs->thresh <<= LP_AVG - 2;
752 bs->thresh_frac += LP_AVG - 2;
753 }
754 break;
755
756 case VBI_PIXFMT_RGBA24_BE:
757 case VBI_PIXFMT_BGRA24_BE:
758 skip = 2;
759 bs->bytes_per_sample = 4;
760 bs->func = bit_slicer_RGBA24_LE;
761 if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
762 bs->func = low_pass_bit_slicer_Y8;
763 oversampling = 1;
764 bs->thresh <<= LP_AVG - 2;
765 bs->thresh_frac += LP_AVG - 2;
766 }
767 break;
768
769 case VBI_PIXFMT_RGB24_LE:
770 case VBI_PIXFMT_BGR24_LE:
771 skip = 1;
772 bs->bytes_per_sample = 3;
773 bs->func = bit_slicer_RGB24_LE;
774 if (min_samples_per_bit > (3U << (LP_AVG - 1))) {
775 bs->func = low_pass_bit_slicer_Y8;
776 oversampling = 1;
777 bs->thresh <<= LP_AVG - 2;
778 bs->thresh_frac += LP_AVG - 2;
779 }
780 break;
781
782 case VBI_PIXFMT_RGB16_LE:
783 case VBI_PIXFMT_BGR16_LE:
784 bs->func = bit_slicer_RGB16_LE;
785 bs->green_mask = 0x07E0;
786 bs->thresh = 105 << (5 - 2 + 12);
787 bs->thresh_frac = 12;
788 bs->bytes_per_sample = 2;
789 break;
790
791 case VBI_PIXFMT_RGB16_BE:
792 case VBI_PIXFMT_BGR16_BE:
793 bs->func = bit_slicer_RGB16_BE;
794 bs->green_mask = 0x07E0;
795 bs->thresh = 105 << (5 - 2 + 12);
796 bs->thresh_frac = 12;
797 bs->bytes_per_sample = 2;
798 break;
799
800 case VBI_PIXFMT_RGBA15_LE:
801 case VBI_PIXFMT_BGRA15_LE:
802 bs->func = bit_slicer_RGB16_LE;
803 bs->green_mask = 0x03E0;
804 bs->thresh = 105 << (5 - 3 + 11);
805 bs->thresh_frac = 11;
806 bs->bytes_per_sample = 2;
807 break;
808
809 case VBI_PIXFMT_RGBA15_BE:
810 case VBI_PIXFMT_BGRA15_BE:
811 bs->func = bit_slicer_RGB16_BE;
812 bs->green_mask = 0x03E0;
813 bs->thresh = 105 << (5 - 3 + 11);
814 bs->thresh_frac = 11;
815 bs->bytes_per_sample = 2;
816 break;
817
818 case VBI_PIXFMT_ARGB15_LE:
819 case VBI_PIXFMT_ABGR15_LE:
820 bs->func = bit_slicer_RGB16_LE;
821 bs->green_mask = 0x07C0;
822 bs->thresh = 105 << (6 - 3 + 12);
823 bs->thresh_frac = 12;
824 bs->bytes_per_sample = 2;
825 break;
826
827 case VBI_PIXFMT_ARGB15_BE:
828 case VBI_PIXFMT_ABGR15_BE:
829 bs->func = bit_slicer_RGB16_BE;
830 bs->green_mask = 0x07C0;
831 bs->thresh = 105 << (6 - 3 + 12);
832 bs->thresh_frac = 12;
833 bs->bytes_per_sample = 2;
834 break;
835
836
837 default:
838 warning (&bs->log,
839 "Unknown sample_format 0x%x.", (unsigned int) sample_format);
840 return FALSE;
841 }
842
843 bs->skip = sample_offset * bs->bytes_per_sample + skip;
844
845 bs->cri_mask = cri_mask & c_mask;
846 bs->cri = cri & bs->cri_mask;
847
848 /* We stop searching for CRI when CRI, FRC and payload
849 cannot possibly fit anymore. Additionally this eliminates
850 a data end check in the payload loop. */
851 cri_samples = (sampling_rate * (int64_t) cri_bits) / cri_rate;
852
853 data_bits = payload_bits + frc_bits;
854 data_samples = (sampling_rate * (int64_t) data_bits) / payload_rate;
855
856 bs->total_bits = cri_bits + data_bits;
857
858 if ((sample_offset > samples_per_line)
859 || ((cri_samples + data_samples)
860 > (samples_per_line - sample_offset))) {
861 warning (&bs->log,
862 "%u samples_per_line too small for "
863 "sample_offset %u + %u cri_bits (%u samples) "
864 "+ %u frc_bits and %u payload_bits "
865 "(%u samples).",
866 samples_per_line, sample_offset,
867 cri_bits, cri_samples, frc_bits, payload_bits, data_samples);
868 goto failure;
869 }
870
871 cri_end = MIN (cri_end, samples_per_line - data_samples);
872
873 bs->cri_samples = cri_end - sample_offset;
874 bs->cri_rate = cri_rate;
875
876 bs->oversampling_rate = sampling_rate * oversampling;
877
878 bs->frc = frc & f_mask;
879 bs->frc_bits = frc_bits;
880
881 /* Payload bit distance in 1/256 raw samples. */
882 bs->step = (sampling_rate * (int64_t) 256) / payload_rate;
883
884 if (payload_bits & 7) {
885 /* Use bit routines. */
886 bs->payload = payload_bits;
887 bs->endian = 3;
888 } else {
889 /* Use faster octet routines. */
890 bs->payload = payload_bits >> 3;
891 bs->endian = 1;
892 }
893
894 switch (modulation) {
895 case VBI3_MODULATION_NRZ_MSB:
896 --bs->endian;
897
898 /* fall through */
899
900 case VBI3_MODULATION_NRZ_LSB:
901 bs->phase_shift = (int)
902 (sampling_rate * 256.0 / cri_rate * .5 + bs->step * .5 + 128);
903 break;
904
905 case VBI3_MODULATION_BIPHASE_MSB:
906 --bs->endian;
907
908 /* fall through */
909
910 case VBI3_MODULATION_BIPHASE_LSB:
911 /* Phase shift between the NRZ modulated CRI and the
912 biphase modulated rest. */
913 bs->phase_shift = (int)
914 (sampling_rate * 256.0 / cri_rate * .5 + bs->step * .25 + 128);
915 break;
916 }
917
918 return TRUE;
919
920 failure:
921 bs->func = null_function;
922
923 return FALSE;
924 }
925
926 void
vbi3_bit_slicer_set_log_fn(vbi3_bit_slicer * bs,vbi_log_mask mask,vbi_log_fn * log_fn,void * user_data)927 vbi3_bit_slicer_set_log_fn (vbi3_bit_slicer * bs,
928 vbi_log_mask mask, vbi_log_fn * log_fn, void *user_data)
929 {
930 assert (NULL != bs);
931
932 if (NULL == log_fn)
933 mask = 0;
934
935 bs->log.mask = mask;
936 bs->log.fn = log_fn;
937 bs->log.user_data = user_data;
938 }
939
940 /**
941 * @internal
942 */
943 void
_vbi3_bit_slicer_destroy(vbi3_bit_slicer * bs)944 _vbi3_bit_slicer_destroy (vbi3_bit_slicer * bs)
945 {
946 assert (NULL != bs);
947
948 /* Make unusable. */
949 CLEAR (*bs);
950 }
951
952 /**
953 * @internal
954 */
955 vbi_bool
_vbi3_bit_slicer_init(vbi3_bit_slicer * bs)956 _vbi3_bit_slicer_init (vbi3_bit_slicer * bs)
957 {
958 assert (NULL != bs);
959
960 CLEAR (*bs);
961
962 bs->func = null_function;
963
964 return TRUE;
965 }
966
967 /**
968 * @param bs Pointer to a vbi3_bit_slicer object allocated with
969 * vbi3_bit_slicer_new(), can be NULL.
970 *
971 * Deletes a vbi3_bit_slicer object.
972 */
973 void
vbi3_bit_slicer_delete(vbi3_bit_slicer * bs)974 vbi3_bit_slicer_delete (vbi3_bit_slicer * bs)
975 {
976 if (NULL == bs)
977 return;
978
979 _vbi3_bit_slicer_destroy (bs);
980
981 vbi_free (bs);
982 }
983
984 /**
985 * Allocates a new vbi3_bit_slicer object.
986 *
987 * @returns
988 * @c NULL when out of memory.
989 */
990 vbi3_bit_slicer *
vbi3_bit_slicer_new(void)991 vbi3_bit_slicer_new (void)
992 {
993 vbi3_bit_slicer *bs;
994
995 bs = vbi_malloc (sizeof (*bs));
996 if (NULL == bs) {
997 return NULL;
998 }
999
1000 _vbi3_bit_slicer_init (bs);
1001
1002 return bs;
1003 }
1004
1005 /*
1006 Local variables:
1007 c-set-style: K&R
1008 c-basic-offset: 8
1009 End:
1010 */
1011