BPI/BPI-CM9-Linux
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
BPI-CM9-Linux/aml-comp/vendor/amlogic/zvbi/test/capture.c
T
Qubot 818cb714e3 Import complete source tree
2026-08-24 10:03:24 +08:00

831 lines
19 KiB
C
Raw Permalink Blame History

/*
* libzvbi test
*
* Copyright (C) 2000, 2001, 2002 Michael H. Schimek
*
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
/* $Id: capture.c,v 1.39 2008/08/19 10:06:52 mschimek Exp $ */
/* For libzvbi version 0.2.x / 0.3.x. */
#undef NDEBUG
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <locale.h>
#include <errno.h>
#include <assert.h>
#include <unistd.h>
#ifdef HAVE_GETOPT_LONG
#include <getopt.h>
#endif
#include "src/version.h"
#if 2 == VBI_VERSION_MINOR
# include "src/hamm.h"
# define SCANNING(sp) ((sp)->scanning)
#elif 3 == VBI_VERSION_MINOR
# include "src/vbi.h"
# include "src/zvbi.h"
# include "src/misc.h"
# define SCANNING(sp) \
(0 != ((sp)->videostd_set & VBI_VIDEOSTD_SET_525_60) ? 525 : 625)
#else
# error VBI_VERSION_MINOR == ?
#endif
#include "sliced.h"
#undef _
#define _(x) x /* TODO */
#define PROGRAM_NAME "zvbi-capture"
static const char * option_out_file_name;
static enum file_format option_out_file_format;
static unsigned int option_out_ts_pid;
static int option_read_not_pull;
static int option_strict;
static int option_dump_wss;
static int option_dump_sliced;
static int option_cc_test;
static int option_cc_test_test;
static vbi_bool option_raw_output;
static vbi_bool option_sliced_output;
static unsigned int option_sim_flags;
static struct stream * cst;
static struct stream * wst;
static const char ** sim_cc_streams;
static unsigned int n_sim_cc_streams;
struct frame {
vbi_sliced sliced[50];
unsigned int n_lines;
uint8_t * raw;
double sample_time;
int64_t stream_time;
};
static struct frame frame_buffers[5];
static unsigned int next_frame;
static unsigned int n_frames_buffered;
static unsigned int sliced_output_count;
static unsigned int raw_output_count;
/*
* Dump
*/
extern int vbi_printable (int);
static void
decode_wss_625 (const uint8_t * buf)
{
static const char *formats[] = {
"Full format 4:3, 576 lines",
"Letterbox 14:9 centre, 504 lines",
"Letterbox 14:9 top, 504 lines",
"Letterbox 16:9 centre, 430 lines",
"Letterbox 16:9 top, 430 lines",
"Letterbox > 16:9 centre",
"Full format 14:9 centre, 576 lines",
"Anamorphic 16:9, 576 lines"
};
static const char *subtitles[] = {
"none",
"in active image area",
"out of active image area",
"?"
};
int g1 = buf[0] & 15;
int parity;
if (option_dump_wss) {
parity = g1;
parity ^= parity >> 2;
parity ^= parity >> 1;
g1 &= 7;
printf ("WSS PAL: ");
if (!(parity & 1))
printf ("<parity error> ");
printf ("%s; %s mode; %s colour coding;\n"
" %s helper; reserved b7=%d; %s\n"
" open subtitles: %s; %scopyright %s; copying %s\n",
formats[g1],
(buf[0] & 0x10) ? "film" : "camera",
(buf[0] & 0x20) ? "MA/CP" : "standard",
(buf[0] & 0x40) ? "modulated" : "no",
!!(buf[0] & 0x80),
(buf[1] & 0x01) ? "have TTX subtitles; " : "",
subtitles[(buf[1] >> 1) & 3],
(buf[1] & 0x08) ? "surround sound; " : "",
(buf[1] & 0x10) ? "asserted" : "unknown",
(buf[1] & 0x20) ? "restricted" : "not restricted");
}
}
static void
decode_wss_cpr1204 (const uint8_t * buf)
{
if (option_dump_wss) {
const int poly = (1 << 6) + (1 << 1) + 1;
int g = (buf[0] << 12) + (buf[1] << 4) + buf[2];
int j, crc;
crc = g | (((1 << 6) - 1) << (14 + 6));
for (j = 14 + 6 - 1; j >= 0; j--) {
if (crc & ((1 << 6) << j))
crc ^= poly << j;
}
fprintf (stderr, "WSS CPR >> g=%08x crc=%08x\n", g, crc);
}
}
static void
decode_sliced (const vbi_sliced * s,
unsigned int n_lines,
double sample_time,
int64_t stream_time)
{
if (option_dump_sliced) {
const vbi_sliced *q = s;
unsigned int i;
printf ("Frame %f %010" PRId64 "\n",
sample_time, stream_time);
for (i = 0; i < n_lines; q++, i++) {
unsigned int j;
printf ("%08x %3d ", q->id, q->line);
for (j = 0; j < sizeof(q->data); j++) {
printf ("%02x ", 0xFF & q->data[j]);
}
putchar (' ');
for (j = 0; j < sizeof(q->data); j++) {
char c = _vbi_to_ascii (q->data[j]);
putchar (c);
}
putchar ('\n');
}
}
for (; n_lines > 0; s++, n_lines--) {
if (s->id == 0) {
continue;
} else if (s->id & (VBI_SLICED_VPS |
VBI_SLICED_TELETEXT_B |
VBI_SLICED_CAPTION_525 |
VBI_SLICED_CAPTION_625)) {
/* Nothing to do.
Use the 'decode' tool instead. */
} else if (s->id & VBI_SLICED_WSS_625) {
decode_wss_625 (s->data);
} else if (s->id & VBI_SLICED_WSS_CPR1204) {
decode_wss_cpr1204 (s->data);
} else {
fprintf (stderr, "Oops. Unhandled VBI service %08x\n",
s->id);
}
}
}
/* Purpose of this function is to record raw and sliced VBI data
around three kinds of events for remote examination:
- Frames without data,
- Lines which contain 0x00 0x00 instead of 0x80 0x80 bytes,
- Lines where the transmitted bytes have wrong parity.
The raw VBI data may be required to understand what happened,
and due to its volume we cannot record it unconditionally. */
static vbi_bool
cc_test (const vbi_sliced * sliced,
unsigned int n_lines)
{
static const unsigned int max_error_count[3] = { 5, 5, 5 };
static unsigned int error_count[3];
static unsigned int frame_count;
unsigned int error_set;
unsigned int i;
error_set = 0;
if (option_cc_test_test && 0 == rand() % 300)
n_lines = 0;
if (0 == n_lines) {
error_msg ("No data on this frame...");
if (error_count[0] < max_error_count[0]) {
++error_count[0];
error_set |= 1 << 0;
}
} else {
for (i = 0; i < n_lines; ++i) {
if (sliced[i].id & (VBI_SLICED_CAPTION_525 |
VBI_SLICED_CAPTION_625)) {
int b1, b2;
int c1, c2;
b1 = sliced[i].data[0];
b2 = sliced[i].data[1];
if (option_cc_test_test
&& 0 == rand() % 300) {
b1 = 0;
b2 = 0;
}
if (0x00 == b1 && 0x00 == b2) {
error_msg ("Null bytes...");
if (error_count[1]
< max_error_count[1]) {
++error_count[1];
error_set |= 1 << 1;
}
}
c1 = vbi_unpar8 (b1);
c2 = vbi_unpar8 (b2);
if (option_cc_test_test
&& 0 == rand() % 300) {
c2 = -1;
}
if ((c1 | c2) < 0) {
error_msg ("Parity error...");
if (error_count[2]
< max_error_count[2]) {
++error_count[2];
error_set |= 1 << 2;
}
break;
}
}
}
}
if (0 != error_set) {
unsigned int n_errors = 0;
unsigned int n_kinds = 0;
for (i = 0; i < N_ELEMENTS (error_count); ++i) {
n_errors += 5 - error_count[i];
n_kinds += (error_count[i] < 5);
}
if (0 == n_kinds) {
error_msg ("Done.");
return FALSE; /* terminate loop */
}
if (0 == frame_count % (5 * 30)) {
error_msg ("Waiting for %u errors of %u kinds...",
n_errors, n_kinds);
}
}
++frame_count;
if (option_raw_output != (0 != error_set)) {
option_sliced_output = (0 != error_set);
raw_output_count = N_ELEMENTS (frame_buffers) * 2;
if (sliced_output_count < raw_output_count)
sliced_output_count = raw_output_count;
}
return TRUE; /* success, continue loop */
}
static vbi_bool
decode_frame (const vbi_sliced * sliced,
unsigned int n_lines,
const uint8_t * raw,
const vbi_sampling_par *sp,
double sample_time,
int64_t stream_time)
{
if (option_dump_sliced || option_dump_wss)
decode_sliced (sliced, n_lines,
sample_time, stream_time);
if (option_cc_test) {
struct frame *f;
unsigned int size;
f = frame_buffers + next_frame;
if (n_frames_buffered >= N_ELEMENTS (frame_buffers)) {
write_stream_sliced (wst,
(sliced_output_count > 0) ?
f->sliced : NULL,
f->n_lines,
(raw_output_count > 0) ?
f->raw : NULL,
sp,
f->sample_time,
f->stream_time);
if (sliced_output_count > 0)
--sliced_output_count;
if (raw_output_count > 0)
--raw_output_count;
n_frames_buffered = N_ELEMENTS (frame_buffers) - 1;
}
assert (n_lines <= N_ELEMENTS (f->sliced));
memcpy (f->sliced, sliced, n_lines * sizeof (*sliced));
f->n_lines = n_lines;
size = (sp->count[0] + sp->count[1]) * sp->bytes_per_line;
memcpy (f->raw, raw, size);
f->sample_time = sample_time;
f->stream_time = stream_time;
if (++next_frame >= N_ELEMENTS (frame_buffers))
next_frame = 0;
++n_frames_buffered;
if (!cc_test (sliced, n_lines))
return FALSE;
} else if (option_raw_output || option_sliced_output) {
write_stream_sliced (wst,
option_sliced_output ? sliced : NULL,
n_lines,
option_raw_output ? raw : NULL,
sp,
sample_time,
stream_time);
}
return TRUE;
}
static void
init_frame_buffers (const vbi_sampling_par *sp)
{
unsigned int size;
unsigned int i;
size = (sp->count[0] + sp->count[1]) * sp->bytes_per_line;
for (i = 0; i < N_ELEMENTS (frame_buffers); ++i) {
frame_buffers[i].raw = malloc (size);
if (NULL == frame_buffers[i].raw)
no_mem_exit ();
}
}
static void
usage (FILE * fp)
{
fprintf (fp, _("\
%s %s -- VBI capture tool\n\n\
Copyright (C) 2000-2007 Michael H. Schimek\n\
This program is licensed under GPLv2 or later. NO WARRANTIES.\n\n\
Usage: %s [options] > sliced VBI data\n\
-h | --help | --usage Print this message and exit\n\
-q | --quiet Suppress progress and error messages\n\
-v | --verbose Increase verbosity\n\
-V | --version Print the program version and exit\n\
Device options:\n\
-c | --sim-cc file Simulate a VBI device and load this Closed Caption\n\
test stream into the simulation\n\
-d | --device file Capture from this device (default %s)\n\
V4L/V4L2: /dev/vbi, /dev/vbi0, /dev/vbi1, ...\n\
Linux DVB: /dev/dvb/adapter0/demux0, ...\n\
*BSD bktr driver: /dev/vbi, /dev/vbi0, ...\n\
-i | --pid pid Capture the stream with this PID from a Linux\n\
DVB device\n\
-m | --sim-laced Simulate a VBI device capturing interlaced raw\n\
VBI data\n\
-n | --ntsc Video standard hint for V4L interface and\n\
simulated VBI device (default PAL/SECAM)\n\
-p | --pal | --secam Video standard hint for V4L interface\n\
-s | --sim Simulate a VBI device\n\
-u | --sim-unsync Simulate a VBI device with wrong/unknown field\n\
parity\n\
-w | --sim-noise Simulate a VBI device with noisy signal\n\
-x | --proxy Capture through the VBI proxy daemon\n\
Output options:\n\
-j | --dump Sliced VBI data (text)\n\
-l | --sliced Sliced VBI data (binary)\n\
-o | --output name Write the VBI data to this file instead of\n\
standard output\n"
/* later */ /*
"-r | --raw Raw VBI data (binary)\n"
*/
"-P | --pes DVB PES stream\n\
-T | --ts pid DVB TS stream\n\
"),
PROGRAM_NAME, VERSION, program_invocation_name,
option_dev_name);
}
static const char short_options[] = "c:d:hi:jlmno:pqr:suvwxPT:V";
#ifdef HAVE_GETOPT_LONG
static const struct option
long_options[] = {
{ "sim-cc", required_argument, NULL, 'c' },
{ "device", required_argument, NULL, 'd' },
{ "help", no_argument, NULL, 'h' },
{ "usage", no_argument, NULL, 'h' },
{ "pid", required_argument, NULL, 'i' },
{ "dump", no_argument, NULL, 'j' },
{ "sliced", no_argument, NULL, 'l' },
{ "sim-laced", no_argument, NULL, 'm' },
{ "ntsc", no_argument, NULL, 'n' },
{ "output", required_argument, NULL, 'o' },
{ "pal", no_argument, NULL, 'p' },
{ "secam", no_argument, NULL, 'p' },
{ "quiet", no_argument, NULL, 'q' },
{ "raw", optional_argument, NULL, 'r' },
{ "sim", no_argument, NULL, 's' },
{ "sim-unsync", no_argument, NULL, 'u' },
{ "verbose", no_argument, NULL, 'v' },
{ "sim-noise", optional_argument, NULL, 'w' },
{ "proxy", no_argument, NULL, 'x' },
{ "pes", no_argument, NULL, 'P' },
{ "ts", required_argument, NULL, 'T' },
{ "version", no_argument, NULL, 'V' },
{ "loose", no_argument, &option_strict, 0 },
{ "strict", no_argument, &option_strict, 2 },
{ "cc-test", no_argument, &option_cc_test, TRUE },
{ "cc-test-test", no_argument, &option_cc_test_test, TRUE },
{ "dump-wss", no_argument, &option_dump_wss, TRUE },
{ "read", no_argument, &option_read_not_pull, TRUE },
{ "pull", no_argument, &option_read_not_pull, FALSE },
{ NULL, 0, 0, 0 }
};
#else
#define getopt_long(ac, av, s, l, i) getopt(ac, av, s)
#endif
static int option_index;
static char *
load_string (const char * name)
{
FILE *fp;
char *buffer;
size_t buffer_size;
size_t done;
buffer = NULL;
buffer_size = 0;
done = 0;
fp = fopen (name, "r");
if (NULL == fp) {
exit (EXIT_FAILURE);
}
for (;;) {
char *new_buffer;
size_t new_size;
size_t space;
size_t actual;
new_size = 16384;
if (buffer_size > 0)
new_size = buffer_size * 2;
new_buffer = realloc (buffer, new_size);
if (NULL == new_buffer) {
free (buffer);
exit (EXIT_FAILURE);
}
buffer = new_buffer;
buffer_size = new_size;
space = buffer_size - done - 1;
actual = fread (buffer + done, 1, space, fp);
if ((size_t) -1 == actual) {
exit (EXIT_FAILURE);
}
done += actual;
if (actual < space)
break;
}
buffer[done] = 0;
fclose (fp);
return buffer;
}
static void
sim_load_caption (void)
{
unsigned int i;
for (i = 0; i < n_sim_cc_streams; ++i) {
char *buffer;
vbi_bool success;
fprintf (stderr, "Loading '%s'.\n", sim_cc_streams[i]);
buffer = load_string (sim_cc_streams[i]);
success = capture_stream_sim_load_caption
(cst, buffer, /* append */ (i > 0));
assert (success);
}
}
int
main (int argc,
char ** argv)
{
unsigned int interfaces;
unsigned int scanning;
unsigned int services;
vbi_bool sim_interlaced;
vbi_bool sim_synchronous;
init_helpers (argc, argv);
scanning = 625;
sim_interlaced = FALSE;
sim_synchronous = TRUE;
option_strict = 1;
option_dump_wss = FALSE;
option_read_not_pull = FALSE;
interfaces = (INTERFACE_V4L2 |
INTERFACE_V4L |
INTERFACE_BKTR);
for (;;) {
int c;
c = getopt_long (argc, argv, short_options,
long_options, &option_index);
if (-1 == c)
break;
switch (c) {
case 0: /* getopt_long() flag */
if (option_dump_wss) {
option_raw_output = FALSE;
option_sliced_output = FALSE;
}
break;
case 'c':
{
const char **pp;
pp = realloc (sim_cc_streams,
(n_sim_cc_streams + 1)
* sizeof (*pp));
assert (NULL != pp);
sim_cc_streams = pp;
sim_cc_streams[n_sim_cc_streams++] = optarg;
interfaces = INTERFACE_SIM;
break;
}
case 'd':
parse_option_dev_name ();
break;
case 'h':
usage (stdout);
exit (EXIT_SUCCESS);
case 'i':
parse_option_dvb_pid ();
interfaces = INTERFACE_DVB;
break;
case 'j':
option_dump_sliced = TRUE;
option_raw_output = FALSE;
option_sliced_output = FALSE;
break;
case 'l':
option_sliced_output = TRUE;
option_dump_sliced = FALSE;
option_dump_wss = FALSE;
if (FILE_FORMAT_XML != option_out_file_format)
option_out_file_format = FILE_FORMAT_SLICED;
break;
case 'm':
sim_interlaced = TRUE;
interfaces = INTERFACE_SIM;
break;
case 'n':
scanning = 525;
break;
case 'o':
assert (NULL != optarg);
option_out_file_name = optarg;
break;
case 'p':
scanning = 625;
break;
case 'q':
parse_option_quiet ();
break;
#if 0
case 'r':
/* Optional optarg: line numbers
(not implemented yet). */
option_raw_output = TRUE;
option_dump_sliced = FALSE;
option_dump_wss = FALSE;
option_out_file_format = FILE_FORMAT_XML;
break;
#endif
case 's':
interfaces = INTERFACE_SIM;
break;
case 'u':
sim_synchronous = FALSE;
interfaces = INTERFACE_SIM;
break;
case 'v':
parse_option_verbose ();
break;
case 'w':
/* Optional optarg: noise parameters
(not implemented yet). */
interfaces = INTERFACE_SIM;
option_sim_flags |= _VBI_RAW_NOISE_2;
break;
case 'x':
interfaces &= ~(INTERFACE_SIM | INTERFACE_DVB);
interfaces |= INTERFACE_PROXY;
break;
case 'P':
option_sliced_output = TRUE;
option_dump_sliced = FALSE;
option_dump_wss = FALSE;
option_out_file_format = FILE_FORMAT_DVB_PES;
break;
case 'T':
option_sliced_output = TRUE;
option_dump_sliced = FALSE;
option_dump_wss = FALSE;
option_out_ts_pid = parse_option_ts ();
option_out_file_format = FILE_FORMAT_DVB_TS;
break;
case 'V':
printf (PROGRAM_NAME " " VERSION "\n");
exit (EXIT_SUCCESS);
default:
usage (stderr);
exit (EXIT_FAILURE);
}
}
if (!(option_sliced_output
|| option_raw_output
|| option_dump_sliced
|| option_dump_wss)) {
error_msg (_("Give one of the -j, -l, -P or -T options\n"
"to enable output, or -h for help."));
exit (EXIT_FAILURE);
}
services = (VBI_SLICED_VBI_525 |
VBI_SLICED_VBI_625 |
VBI_SLICED_TELETEXT_B |
VBI_SLICED_CAPTION_525 |
VBI_SLICED_CAPTION_625 |
VBI_SLICED_VPS |
VBI_SLICED_VPS_F2 |
VBI_SLICED_WSS_625 |
VBI_SLICED_WSS_CPR1204);
switch (option_out_file_format) {
case FILE_FORMAT_DVB_PES:
case FILE_FORMAT_DVB_TS:
/* Other formats cannot be encoded. */
services &= (VBI_SLICED_TELETEXT_B |
VBI_SLICED_CAPTION_625 |
VBI_SLICED_VPS |
VBI_SLICED_WSS_625);
break;
default:
break;
}
cst = capture_stream_new (interfaces,
option_dev_name,
scanning,
services,
/* n_buffers (V4L2 mmap) */ 5,
option_dvb_pid,
sim_interlaced,
sim_synchronous,
option_raw_output,
option_read_not_pull,
option_strict,
decode_frame);
if (interfaces & INTERFACE_SIM) {
sim_load_caption ();
capture_stream_sim_set_flags (cst, option_sim_flags);
if (0 != option_sim_flags)
capture_stream_sim_decode_raw (cst, TRUE);
}
if (option_cc_test_test)
option_cc_test = TRUE;
if (option_cc_test) {
option_raw_output = FALSE;
option_sliced_output = TRUE;
option_dump_sliced = FALSE;
option_dump_wss = FALSE;
option_out_file_format = FILE_FORMAT_SLICED;
sliced_output_count = 2 * 60 * 30;
}
if (option_raw_output || option_sliced_output) {
vbi_sampling_par sp;
capture_stream_get_sampling_par (cst, &sp);
if (option_cc_test)
init_frame_buffers (&sp);
wst = write_stream_new (option_out_file_name,
option_out_file_format,
option_out_ts_pid,
SCANNING (&sp));
}
stream_loop (cst);
stream_delete (wst);
wst = NULL;
stream_delete (cst);
cst = NULL;
exit(EXIT_SUCCESS);
}
Reference in New Issue View Git Blame Copy Permalink