--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+#include <fcntl.h>
+#include <math.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkkeysyms.h>
+#include <alsa/asoundlib.h>
+#include <linux/dvb/dmx.h>
+#include <linux/dvb/frontend.h>
+
+/* c++ `pkg-config --cflags --libs gtk+-2.0` dmux.C thread.C ./x86_64/libzmpeg3.a -lpthread -lasound -lm */
+
+#include "libzmpeg3.h"
+#include "thread.h"
+
+double the_time();
+void reset();
+int open_tuner(int dev_no,int chan,int vid_pid,int aud_pid);
+void close_tuner();
+double audio_time(int stream);
+void alsa_close();
+void alsa_open(int chs,int rate);
+short *alsa_bfr(int ch);
+int alsa_bfrsz();
+int alsa_recovery(int ret);
+int alsa_write(int len);
+void dst_exit(GtkWidget *widget, gpointer data);
+gint key_press_cb(GtkWidget* widget, GdkEventKey* event, gpointer data);
+double video_time(int stream);
+void stats();
+void sig_int(int n);
+int main(int ac,char **av);
+
+/* alpha currently is broken in gdk */
+/* would render faster if alpha worked correctly */
+#define RGBA FALSE
+
+#if RGBA
+#define BPP 4
+#define COLOR_MODEL zmpeg3_t::cmdl_RGBA8888
+#else
+#define BPP 3
+#define COLOR_MODEL zmpeg3_t::cmdl_RGB888
+#endif
+
+int verbose = 0;
+double nudge = .5; // 3.5;
+const double ahead = .5;
+
+//#define DEBUG
+#ifndef DEBUG
+#define dprintf(s...) do{}while(0)
+#else
+#define dprintf(s...) printf(s)
+#endif
+
+#define NETTUNE_AIR 1
+#define NETTUNE_CABLE 2
+
+static unsigned long ntsc_dvb[ ] = {
+ 0, 0, 57, 63, 69, 79, 85, 177, 183, 189 ,
+ 195, 201, 207, 213, 473, 479, 485, 491, 497, 503 ,
+ 509, 515, 521, 527, 533, 539, 545, 551, 557, 563 ,
+ 569, 575, 581, 587, 593, 599, 605, 611, 617, 623 ,
+ 629, 635, 641, 647, 653, 659, 665, 671, 677, 683 ,
+ 689, 695, 701, 707, 713, 719, 725, 731, 737, 743 ,
+ 749, 755, 761, 767, 773, 779, 785, 791, 797, 803 ,
+ 809, 815, 821, 827, 833, 839, 845, 851, 857, 863 ,
+ 869, 875, 881, 887, 893, 899, 905, 911, 917, 923 ,
+ 929, 935, 941, 947, 953, 959, 965, 971, 977, 983 ,
+ 989, 995, 1001, 1007, 1013, 1019, 1025, 1031, 1037, 1043
+};
+
+static unsigned long catv_dvb[] = {
+ 0, 0, 57, 63, 69, 79, 85, 177, 183, 189,
+ 195, 201, 207, 213, 123, 129, 135, 141, 147, 153,
+ 159, 165, 171, 219, 225, 231, 237, 243, 249, 255,
+ 261, 267, 273, 279, 285, 291, 297, 303, 309, 315,
+ 321, 327, 333, 339, 345, 351, 357, 363, 369, 375,
+ 381, 387, 393, 399, 405, 411, 417, 423, 429, 435,
+ 441, 447, 453, 459, 465, 471, 477, 483, 489, 495,
+ 501, 507, 513, 519, 525, 531, 537, 543, 549, 555,
+ 561, 567, 573, 579, 585, 591, 597, 603, 609, 615,
+ 621, 627, 633, 639, 645, 93, 99, 105, 111, 117,
+ 651, 657, 663, 669, 675, 681, 687, 693, 699, 705,
+ 711, 717, 723, 729, 735, 741, 747, 753, 759, 765,
+ 771, 777, 783, 789, 795, 781, 807, 813, 819, 825,
+ 831, 837, 843, 849, 855, 861, 867, 873, 879, 885,
+ 891, 897, 903, 909, 915, 921, 927, 933, 939, 945,
+ 951, 957, 963, 969, 975, 981, 987, 993, 999
+};
+
+int frontend_fd;
+int audio_fd;
+int video_fd;
+int dvr_fd;
+int prev_lock;
+int has_lock;
+int done;
+zmpeg3_t *zsrc;
+int aud, vid;
+int subchan;
+int audio_done;
+int video_done;
+
+class vid_thread : public Thread
+{
+ void Proc();
+} *the_vid;
+
+class aud_thread : public Thread
+{
+ void Proc();
+} *the_aud;
+
+class lck_thread : public Thread
+{
+ void Proc();
+} *the_lck;
+
+int do_status()
+{
+ fe_status_t status;
+ uint16_t snr, signal;
+ uint32_t ber, uncorrected_blocks;
+
+ bzero(&status, sizeof(status));
+ ioctl(frontend_fd, FE_READ_STATUS, &status);
+ if( verbose ) {
+ ioctl(frontend_fd, FE_READ_SIGNAL_STRENGTH, &signal);
+ ioctl(frontend_fd, FE_READ_SNR, &snr);
+ ioctl(frontend_fd, FE_READ_BER, &ber);
+ ioctl(frontend_fd, FE_READ_UNCORRECTED_BLOCKS, &uncorrected_blocks);
+ printf("lck:: %02x | signal %04x | snr %04x | ber %08x | unc %08x | ",
+ status, signal, snr, ber, uncorrected_blocks);
+ }
+ has_lock = status & FE_HAS_LOCK ? 1 : 0;
+ if( verbose )
+ printf( has_lock ? "lock\n" : "lost\n" );
+ if( prev_lock != has_lock ) {
+ printf(" %s\n",has_lock ? "signal locked" : "signal lost");
+ prev_lock = has_lock;
+ }
+ return has_lock;
+}
+
+void lck_thread::
+Proc()
+{
+ dprintf("lck_thread::Proc()\n");
+ while( Running() ) {
+ do_status();
+ sleep(1);
+ }
+}
+
+double tstart;
+
+double the_time()
+{
+ double time;
+ struct timeval tv;
+ gettimeofday(&tv,NULL);
+ time = tv.tv_sec + tv.tv_usec/1000000.0;
+ if( tstart < 0. ) tstart = time;
+ return time - tstart;
+}
+
+void reset()
+{
+ frontend_fd = -1;
+ audio_fd = -1;
+ video_fd = -1;
+ dvr_fd = -1;
+ the_vid = 0;
+ the_lck = 0;
+ prev_lock = 0;
+ has_lock = 0;
+ tstart = -1.;
+ aud = 0;
+ vid = 0;
+ subchan = -1;
+}
+
+int open_tuner(int dev_no,int chan,int vid_pid,int aud_pid)
+{
+ char frontend_path[512];
+ char demux_path[512];
+ char dvr_path[512];
+ //dvr_fd = open("/tmp/dat7",O_RDONLY);
+ //return dvr_fd >= 0 ? 0 : 1;
+
+ sprintf(frontend_path, "/dev/dvb/adapter%d/frontend%d", dev_no, 0);
+ sprintf(demux_path, "/dev/dvb/adapter%d/demux%d", dev_no, 0);
+ sprintf(dvr_path, "/dev/dvb/adapter%d/dvr%d", dev_no, 0);
+ if( (frontend_fd=::open(frontend_path, O_RDWR)) < 0 ) {
+ fprintf(stderr, "open_tuner %s: %s\n", frontend_path, strerror(errno));
+ return 1;
+ }
+
+ struct dvb_frontend_parameters frontend_param;
+ bzero(&frontend_param, sizeof(frontend_param));
+
+// Set frequency
+ int index = chan;
+ int table = NETTUNE_AIR;
+
+ switch(table) {
+ case NETTUNE_AIR:
+ frontend_param.frequency = ntsc_dvb[index] * 1000000;
+ frontend_param.u.vsb.modulation = VSB_8;
+ break;
+ case NETTUNE_CABLE:
+ frontend_param.frequency = catv_dvb[index] * 1000000;
+ frontend_param.u.vsb.modulation = QAM_AUTO;
+ break;
+ }
+
+ if( ioctl(frontend_fd, FE_SET_FRONTEND, &frontend_param) < 0 ) {
+ fprintf(stderr, "open_tuner FE_SET_FRONTEND frequency=%d: %s",
+ frontend_param.frequency, strerror(errno));
+ return 1;
+ }
+
+ int retry = 5;
+ while( !do_status() && --retry>=0 ) sleep(1);
+
+ if( retry < 0 ) {
+ fprintf(stderr, "open_tuner: no signal on channel %d\n",chan);
+ return 1;
+ }
+
+ if( (video_fd=::open(demux_path, O_RDWR)) < 0 ) {
+ fprintf(stderr, "open_tuner %s for video: %s\n",
+ demux_path, strerror(errno));
+ return 1;
+ }
+
+// Setting exactly one PES filter to 0x2000 dumps the entire
+// transport stream.
+ struct dmx_pes_filter_params pesfilter;
+ if( !vid_pid && !aud_pid ) {
+ pesfilter.pid = 0x2000;
+ pesfilter.input = DMX_IN_FRONTEND;
+ pesfilter.output = DMX_OUT_TS_TAP;
+ pesfilter.pes_type = DMX_PES_OTHER;
+ pesfilter.flags = DMX_IMMEDIATE_START;
+ if( ioctl(video_fd, DMX_SET_PES_FILTER, &pesfilter) < 0 ) {
+ fprintf(stderr, "open_tuner DMX_SET_PES_FILTER for raw: %s\n",
+ strerror(errno));
+ return 1;
+ }
+ }
+
+
+ if( vid_pid ) {
+ pesfilter.pid = vid_pid;
+ pesfilter.input = DMX_IN_FRONTEND;
+ pesfilter.output = DMX_OUT_TS_TAP;
+ pesfilter.pes_type = DMX_PES_VIDEO;
+ pesfilter.flags = DMX_IMMEDIATE_START;
+ if( ioctl(video_fd, DMX_SET_PES_FILTER, &pesfilter) < 0 ) {
+ fprintf(stderr, "open_tuner DMX_SET_PES_FILTER for video: %s\n",
+ strerror(errno));
+ return 1;
+ }
+ }
+
+ if( aud_pid ) {
+ if( (audio_fd=::open(demux_path,O_RDWR)) < 0 ) {
+ fprintf(stderr, "open_tuner %s for audio: %s\n",
+ demux_path, strerror(errno));
+ return 1;
+ }
+ pesfilter.pid = aud_pid;
+ pesfilter.input = DMX_IN_FRONTEND;
+ pesfilter.output = DMX_OUT_TS_TAP;
+ pesfilter.pes_type = DMX_PES_AUDIO;
+ pesfilter.flags = DMX_IMMEDIATE_START;
+ if( ioctl(audio_fd, DMX_SET_PES_FILTER, &pesfilter) < 0 ) {
+ fprintf(stderr, "open_tuner DMX_SET_PES_FILTER for audio: %s\n",
+ strerror(errno));
+ return 1;
+ }
+ }
+
+// Open transport stream for reading
+ if( (dvr_fd=::open(dvr_path, O_RDONLY)) < 0 ) {
+ fprintf(stderr, "open_tuner %s: %s\n", dvr_path, strerror(errno));
+ return 1;
+ }
+
+ return 0;
+}
+
+void close_tuner()
+{
+ if( frontend_fd >= 0 ) close(frontend_fd);
+ if( audio_fd >= 0 ) close(audio_fd);
+ if( video_fd >= 0 ) close(video_fd);
+ if( dvr_fd >= 0 ) close(dvr_fd);
+}
+
+int open_stream()
+{
+ if( zsrc == 0 && dvr_fd >= 0 ) {
+ int ret;
+ zsrc = new zmpeg3_t(dvr_fd, ret, ZIO_THREADED);
+ //zsrc = new zmpeg3_t(dvr_fd, ret);
+ zsrc->set_cpus(2);
+ if( ret ) {
+ fprintf(stderr,"mpeg3 open failed (%d)\n", ret);
+ return 1;
+ }
+ if( subchan >= 0 ) {
+ int nch = zsrc->dvb.channel_count();
+ while( --nch >= 0 ) {
+ int mjr, mnr;
+ if( zsrc->dvb.get_channel(nch, mjr, mnr) ) continue;
+ if( mnr == subchan ) break;
+ }
+ if( nch >= 0 ) {
+ zsrc->dvb.vstream_number(nch, 0, vid);
+ zsrc->dvb.astream_number(nch, 0, aud, 0);
+ }
+ }
+ }
+ return 0;
+}
+
+void close_stream()
+{
+ if( zsrc ) { delete zsrc; zsrc = 0; }
+}
+
+int start_stream()
+{
+ if( !the_lck && frontend_fd >= 0 ) {
+ the_lck = new lck_thread();
+ the_lck->Run();
+ }
+ if( !the_vid && dvr_fd >= 0 ) {
+ the_vid = new vid_thread();
+ the_vid->Run();
+ }
+ if( !the_aud && dvr_fd >= 0 ) {
+ the_aud = new aud_thread();
+ the_aud->Run();
+ }
+ return 0;
+}
+
+void stop_stream()
+{
+ if( the_lck ) { the_lck->Kill(); the_lck = 0; }
+ if( the_vid ) { the_vid->Kill(); the_vid = 0; }
+ if( the_aud ) { the_aud->Kill(); the_aud = 0; }
+}
+
+double astart;
+
+double audio_time(int stream)
+{
+ double anow = zsrc->get_audio_time(stream);
+ if( astart < 0. ) astart = anow;
+ return anow - astart;
+}
+
+void aud_thread::
+Proc()
+{
+ int audio_channels, sample_rate, more_data;
+
+ audio_channels = zsrc->audio_channels(aud);
+ sample_rate = zsrc->sample_rate(aud);
+ alsa_open(audio_channels,sample_rate);
+ astart = -1.;
+ more_data = 1;
+
+ while( done == 0 && more_data ) {
+ more_data = 0;
+ int ich;
+ int n = alsa_bfrsz();
+ for( ich=0; ich<audio_channels; ++ich ) {
+ short *bfr = alsa_bfr(ich);
+ int ret = ich == 0 ?
+ zsrc->read_audio(bfr, ich, n, aud) :
+ zsrc->reread_audio(bfr, ich, n, aud);
+ if( verbose )
+ printf("read_audio(stream=%d,channel=%d) = %d\n", aud, ich, ret);
+ }
+ alsa_write(n);
+ //double atime = audio_time(aud);
+ //double ttime = the_time();
+ //doule delay = atime - ttime;
+ //printf("delay = %f (%f-%f)\n",delay,atime,ttime);
+ //if( (delay-ahead) > 0. )
+ // usleep((int)(delay*1000000.0/2.));
+ more_data |= !zsrc->end_of_audio(aud);
+ }
+
+ alsa_close();
+ audio_done = 1;
+}
+
+snd_pcm_t *zpcm;
+snd_pcm_uframes_t zpcm_ufrm_size;
+snd_pcm_sframes_t zpcm_sbfr_size;
+snd_pcm_sframes_t zpcm_sper_size;
+unsigned int zpcm_rate;
+static const char *zpcm_device = "plughw:0,0";
+static unsigned int zpcm_bfr_time_us = 500000;
+static unsigned int zpcm_per_time_us = 200000;
+static snd_pcm_channel_area_t *zpcm_areas = 0;
+static int zpcm_channels = 0;
+static short **zpcm_buffers = 0;
+static short *zpcm_samples = 0;
+
+void alsa_close()
+{
+ if( zpcm_buffers != 0 ) { delete [] zpcm_buffers; zpcm_buffers = 0; }
+ if( zpcm_areas != 0 ) { delete [] zpcm_areas; zpcm_areas = 0; }
+ if( zpcm_samples != 0 ) { delete [] zpcm_samples; zpcm_samples = 0; }
+ if( zpcm != 0 ) { snd_pcm_close(zpcm); zpcm = 0; }
+}
+
+void alsa_open(int chs,int rate)
+{
+ int ich, bits, byts, dir, ret;
+ snd_pcm_format_t fmt = SND_PCM_FORMAT_S16;
+ snd_pcm_hw_params_t *phw;
+ snd_pcm_sw_params_t *psw;
+ snd_pcm_hw_params_alloca(&phw);
+ snd_pcm_sw_params_alloca(&psw);
+
+ zpcm = 0;
+ ret = snd_pcm_open(&zpcm, zpcm_device,
+ SND_PCM_STREAM_PLAYBACK, 0 /* SND_PCM_NONBLOCK */);
+ if( ret >= 0 )
+ ret = snd_pcm_hw_params_any(zpcm, phw);
+ if( ret >= 0 )
+ ret = snd_pcm_hw_params_set_rate_resample(zpcm, phw, 1);
+ if( ret >= 0 )
+ ret = snd_pcm_hw_params_set_access(zpcm, phw,
+ SND_PCM_ACCESS_RW_NONINTERLEAVED);
+ if( ret >= 0 )
+ ret = snd_pcm_hw_params_set_format(zpcm, phw, fmt);
+ if( ret >= 0 ) {
+ zpcm_channels = chs;
+ ret = snd_pcm_hw_params_set_channels(zpcm, phw, chs);
+ }
+ if( ret >= 0 ) {
+ zpcm_rate = rate;
+ ret = snd_pcm_hw_params_set_rate_near(zpcm, phw, &zpcm_rate, 0);
+ if( (int)zpcm_rate != rate )
+ printf("nearest audio_rate for %d is %u\n",rate,zpcm_rate);
+ }
+ if( ret >= 0 )
+ ret = snd_pcm_hw_params_set_buffer_time_near(zpcm, phw,
+ &zpcm_bfr_time_us, &dir);
+ if( ret >= 0 )
+ ret = snd_pcm_hw_params_get_buffer_size(phw, &zpcm_ufrm_size);
+ if( ret >= 0 ) {
+ zpcm_sbfr_size = zpcm_ufrm_size;
+ ret = snd_pcm_hw_params_set_period_time_near(zpcm, phw,
+ &zpcm_per_time_us, &dir);
+ }
+ if( ret >= 0 )
+ ret = snd_pcm_hw_params_get_period_size(phw, &zpcm_ufrm_size, &dir);
+ if( ret >= 0 ) {
+ zpcm_sper_size = zpcm_ufrm_size;
+ ret = snd_pcm_hw_params(zpcm, phw);
+ }
+ if( ret >= 0 )
+ ret = snd_pcm_sw_params_current(zpcm, psw);
+ if( ret >= 0 )
+ ret = snd_pcm_sw_params_set_start_threshold(zpcm, psw,
+ (zpcm_sbfr_size / zpcm_sper_size) * zpcm_sper_size);
+ if( ret >= 0 )
+ ret = snd_pcm_sw_params_set_avail_min(zpcm, psw, zpcm_sper_size);
+ if( ret >= 0 )
+ ret = snd_pcm_sw_params(zpcm, psw);
+ /* snd_pcm_dump(zpcm, stdout); */
+
+ if( ret >= 0 ) {
+ zpcm_areas = new snd_pcm_channel_area_t[chs];
+ byts = snd_pcm_format_physical_width(fmt) / 8;
+ zpcm_samples = new short[zpcm_sper_size * chs * byts/2];
+ zpcm_buffers = new short *[chs];
+ if( zpcm_samples ) {
+ for( ich = 0; ich < chs; ++ich ) {
+ zpcm_areas[ich].addr = zpcm_samples;
+ zpcm_areas[ich].first = ich * zpcm_sper_size * bits;
+ zpcm_areas[ich].step = bits;
+ zpcm_buffers[ich] = zpcm_samples + ich*zpcm_sper_size;
+ }
+ }
+ else {
+ fprintf(stderr,"alsa sample buffer allocation failure.\n");
+ ret = -999;
+ }
+ }
+ if( ret < 0 ) {
+ if( ret > -999 )
+ printf("audio error: %s\n", snd_strerror(ret));
+ alsa_close();
+ }
+}
+
+short *alsa_bfr(int ch)
+{
+ return zpcm_buffers[ch];
+}
+
+int alsa_bfrsz()
+{
+ return zpcm_sper_size;
+}
+
+int alsa_recovery(int ret)
+{
+ printf("alsa recovery\n");
+ switch( ret ) {
+ case -ESTRPIPE:
+ /* wait until the suspend flag is released, then fall through */
+ while( (ret=snd_pcm_resume(zpcm)) == -EAGAIN ) usleep(100000);
+ case -EPIPE:
+ ret = snd_pcm_prepare(zpcm);
+ if( ret < 0 )
+ printf("underrun, prepare failed: %s\n", snd_strerror(ret));
+ break;
+ default:
+ printf("unhandled error: %s\n",snd_strerror(ret));
+ break;
+ }
+ return ret;
+}
+
+int alsa_write(int len)
+{
+ int i, ret;
+ short *bfrs[zpcm_channels];
+ ret = 0;
+ for( i=0; i<zpcm_channels; ++i ) bfrs[i] = zpcm_buffers[i];
+
+ while( len > 0 ) {
+ ret = snd_pcm_writen(zpcm,(void **)bfrs, len);
+ if( ret == -EAGAIN ) continue;
+ if ( ret < 0 ) {
+ alsa_recovery(ret);
+ break;
+ }
+ for( i=0; i<zpcm_channels; ++i ) bfrs[i] += ret;
+ len -= ret;
+ }
+ return ret < 0 ? ret : 0;
+}
+
+void dst_exit(GtkWidget *widget, gpointer data)
+{
+ exit(0);
+}
+
+gint
+key_press_cb(GtkWidget* widget, GdkEventKey* event, gpointer data)
+{
+#if 0
+ if (event->length > 0)
+ printf("The key event's string is `%s'\n", event->string);
+
+ printf("The name of this keysym is `%s'\n",
+ gdk_keyval_name(event->keyval));
+
+ switch (event->keyval) {
+ case GDK_Home:
+ printf("The Home key was pressed.\n");
+ break;
+ case GDK_Up:
+ printf("The Up arrow key was pressed.\n");
+ break;
+ default:
+ break;
+ }
+
+ if( gdk_keyval_is_lower(event->keyval) ) {
+ printf("A non-uppercase key was pressed.\n");
+ }
+ else if( gdk_keyval_is_upper(event->keyval) ) {
+ printf("An uppercase letter was pressed.\n");
+ }
+#endif
+ switch (event->keyval) {
+ case GDK_plus:
+ case GDK_equal:
+ nudge += 0.1;
+ printf("+nudge = %f\n",nudge);
+ break;
+ case GDK_minus:
+ case GDK_underscore:
+ nudge -= 0.1;
+ printf("-nudge = %f\n",nudge);
+ break;
+ case GDK_q:
+ printf("exit\n");
+ dst_exit(widget,data);
+ break;
+ }
+ return TRUE;
+}
+
+
+double vstart;
+
+double video_time(int stream)
+{
+ double vnow = zsrc->get_video_time(stream);
+ if( vstart < 0. && vnow > 0. ) vstart = vnow;
+ vnow += nudge;
+ return vnow - vstart;
+}
+
+void vid_thread::
+Proc()
+{
+ GtkWidget *window;
+ GtkWidget *panel_hbox;
+ GtkWidget *image;
+ GdkPixbuf *pbuf0, *pbuf1;
+ GdkImage *img0, *img1;
+ GdkVisual *visual;
+ float frame_rate, frame_delay;
+ unsigned char **rows, **row0, **row1, *cap, *cap0, *cap1;
+ int ret, row, frame, more_data;
+ int width, height, owidth, oheight;
+ const int frame_drop = 1;
+ int rheight = 1050;
+ int rwidth = 1680;
+
+ frame_rate = zsrc->frame_rate(vid);
+ frame_delay = 2.0 / frame_rate;
+ height = zsrc->video_height(vid);
+ width = zsrc->video_width(vid);
+ //oheight = rheight-96;
+ //owidth = rwidth-64;
+ oheight = height;
+ owidth = width;
+ int fheight = rheight - 96;
+ int fwidth = rwidth - 64;
+ if( oheight > fheight || owidth > fwidth ) {
+ int mheight = (owidth * fheight) / fwidth;
+ int mwidth = (oheight * fwidth) / fheight;
+ if( mheight > fheight ) mheight = fheight;
+ if( mwidth > fwidth ) mwidth = fwidth;
+ oheight = mheight;
+ owidth = mwidth;
+ }
+ else if( oheight < 1050/2 && owidth < 1650/2 ) {
+ oheight = oheight * 2;
+ owidth = owidth * 2;
+ }
+
+ visual = gdk_visual_get_system();
+ /* toplevel window */
+ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_signal_connect(GTK_OBJECT(window),"destroy",
+ GTK_SIGNAL_FUNC(dst_exit),NULL);
+ gtk_signal_connect(GTK_OBJECT(window),"key_press_event",
+ GTK_SIGNAL_FUNC(key_press_cb),NULL);
+ gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_NONE);
+ /* try for shared image bfr, only seems to work with gtk_rgb */
+ img0 = gdk_image_new(GDK_IMAGE_SHARED, visual, owidth, oheight);
+ pbuf0 = gdk_pixbuf_new_from_data((const guchar *)img0->mem,
+ GDK_COLORSPACE_RGB,RGBA,8,owidth,oheight,owidth*BPP,NULL,NULL);
+ cap0 = gdk_pixbuf_get_pixels(pbuf0);
+ image = gtk_image_new_from_pixbuf(pbuf0);
+ /* double buffered */
+ img1 = gdk_image_new(GDK_IMAGE_SHARED, visual, owidth, oheight);
+ pbuf1 = gdk_pixbuf_new_from_data((const guchar *)img1->mem,
+ GDK_COLORSPACE_RGB,RGBA,8,owidth,oheight,owidth*BPP,NULL,NULL);
+ cap1 = gdk_pixbuf_get_pixels(pbuf1);
+
+ panel_hbox = gtk_hbox_new(FALSE,0);
+ gtk_container_add(GTK_CONTAINER(window), panel_hbox);
+ /* pack image into panel */
+ gtk_box_pack_start(GTK_BOX(panel_hbox), image, TRUE, TRUE, 0);
+
+
+ row0 = new unsigned char *[oheight];
+ row1 = new unsigned char *[oheight];
+ int cmdl = COLOR_MODEL;
+ for( row=0; row<oheight; ++row ) {
+ row0[row] = cap0 + row*owidth*BPP;
+ row1[row] = cap1 + row*owidth*BPP;
+ }
+
+ gtk_widget_show_all(window);
+ cap = cap0;
+ rows = row0;
+ frame = 0;
+ vstart = -1.;
+ more_data = 1;
+
+ while( done == 0 && more_data ) {
+ if( !gtk_events_pending() ) {
+ more_data = 0;
+ double delay = the_time() - video_time(vid);
+ if( frame_drop ) {
+ if( delay >= frame_delay ) {
+ int nframes = (long)ceil(delay/frame_rate);
+ if( nframes > 2 ) nframes = 2;
+ dprintf(" d%d",nframes);
+ zsrc->drop_frames(nframes,vid);
+ }
+ }
+ delay = -delay;
+ if( delay > 0 ) {
+ dprintf(" D%5.3f",delay*1000.0);
+ int us = (int)(delay*1000000.0);
+ usleep(us);
+ }
+ ret = zsrc->read_frame(rows, 0, 0, width, height,
+ owidth, oheight, cmdl, vid);
+ //printf("%d %ld\n",frame,zsrc->vtrack[0]->demuxer->titles[0]->fs->current_byte);
+ //printf("%d %ld %ld %ld\n",frame,zsrc->vtrack[0]->demuxer->titles[0]->fs->current_byte,
+ // zsrc->vtrack[0]->demuxer->titles[0]->fs->buffer->file_pos,
+ // zsrc->vtrack[0]->demuxer->titles[0]->fs->buffer->file_pos -
+ // zsrc->vtrack[0]->demuxer->titles[0]->fs->current_byte);
+ if( verbose )
+ printf("read_video(stream=%d, frame=%d) = %d\n", vid, frame, ret);
+ GdkGC *blk = image->style->black_gc;
+ gdk_draw_rgb_image(image->window,blk, 0,0,owidth,oheight,
+ GDK_RGB_DITHER_NONE,cap,owidth*BPP);
+#if 0
+#if 0
+ { static FILE *fp = 0;
+ int sz = owidth*oheight*BPP;
+ if( fp == 0 ) fp = fopen("/tmp/dat.raw","w");
+ fwrite(cap,1,sz,fp);
+ }
+#else
+ if( frame < 150 ) { static FILE *fp = 0;
+ int z, sz = owidth*oheight*BPP;
+ uint8_t zbfr[sz];
+ if( fp == 0 ) fp = fopen("/tmp/dat.raw","r");
+ fread(zbfr,1,sz,fp);
+ for( z=0; z<sz && abs(zbfr[z]-cap[z])<=1; ++z );
+ //for( z=0; z<sz && zbfr[z]==cap[z]; ++z );
+ if( z < sz )
+ printf("bug %d\n",z);
+ }
+#endif
+#endif
+ *(unsigned long *)&cap ^= ((unsigned long)cap0 ^ (unsigned long)cap1);
+ *(unsigned long *)&rows ^= ((unsigned long)row0 ^ (unsigned long)row1);
+ more_data |= !zsrc->end_of_video(vid);
+ ++frame;
+ }
+ else
+ gtk_main_iteration();
+ }
+ video_done = 1;
+}
+
+void stats()
+{
+ int has_audio = zsrc->has_audio();
+ printf(" has_audio = %d\n", has_audio);
+ int total_astreams = zsrc->total_astreams();
+ printf(" total_astreams = %d\n", total_astreams);
+ for( int astream=0; astream<total_astreams; ++astream ) {
+ int audio_channels = zsrc->audio_channels(astream);
+ printf(" audio_channels = %d\n", audio_channels);
+ int sample_rate = zsrc->sample_rate(astream);
+ printf(" sample_rate = %d\n", sample_rate);
+ long audio_samples = zsrc->audio_samples(astream);
+ printf(" audio_samples = %ld\n", audio_samples);
+ }
+ printf("\n");
+ int has_video = zsrc->has_video();
+ printf(" has_video = %d\n", has_video);
+ int total_vstreams = zsrc->total_vstreams();
+ printf(" total_vstreams = %d\n", total_vstreams);
+ for( int vstream=0; vstream<total_vstreams; ++vstream ) {
+ int width = zsrc->video_width(vstream);
+ printf(" video_width = %d\n", width);
+ int height = zsrc->video_height(vstream);
+ printf(" video_height = %d\n", height);
+ float frame_rate = zsrc->frame_rate(vstream);
+ printf(" frame_rate = %f\n", frame_rate);
+ long video_frames = zsrc->video_frames(vstream);
+ printf(" video_frames = %ld\n", video_frames);
+ int colormodel = zsrc->colormodel(vstream);
+ printf(" colormodel = %d\n", colormodel);
+ }
+ int channel_count = zsrc->dvb.channel_count();
+ printf("\ndvb data: %d channels\n",channel_count);
+ for( int channel=0; channel<channel_count; ++channel ) {
+ int major, minor, stream; char name[8], enc[4];
+ zsrc->dvb.get_channel(channel, major, minor);
+ zsrc->dvb.get_station_id(channel, &name[0]);
+ zsrc->dvb.total_astreams(channel, total_astreams);
+ zsrc->dvb.total_vstreams(channel, total_vstreams);
+ printf(" dvb channel %d.%d (%s) %d vstreams, %d astreams\n",
+ major, minor, name, total_vstreams, total_astreams);
+ for( int vstream=0; vstream<total_vstreams; ++vstream ) {
+ zsrc->dvb.vstream_number(channel, vstream, stream);
+ printf(" video%-2d = %d\n",vstream,stream);
+ }
+ for(int astream=0; astream<total_astreams; ++astream ) {
+ zsrc->dvb.astream_number(channel, astream, stream, &enc[0]);
+ printf(" audio%-2d = %d (%s)\n",astream,stream,&enc[0]);
+ }
+ }
+ printf("\n");
+}
+
+void sig_int(int n)
+{
+ done = 1;
+}
+
+int ich[] = { /* June 14, 2009 */
+ 7, // 7.1 (KMGH-DT) 1 vstreams, 1 astreams (eng)
+ // 7.27 (KZCO-SD) 1 vstreams, 1 astreams (spa)
+ 9, // 9.1 (KUSA-DT) 1 vstreams, 1 astreams (eng)
+ // 9.2 (WX-Plus) 1 vstreams, 1 astreams (eng)
+ // 9.3 (NBC Uni) 1 vstreams, 1 astreams (eng)
+ 13, // 12.1 (KBDI-DT) 1 vstreams, 1 astreams (eng)
+ // 12.2 (KBDI-DC) 1 vstreams, 1 astreams (eng)
+ // 12.3 (KBDI-WV) 1 vstreams, 1 astreams (eng)
+ 15, // 14.1 (KTFD-DT) 1 vstreams, 1 astreams (spa)
+ 19, // 20.1 (KTVD-DT) 1 vstreams, 1 astreams (eng)
+ 21, // 22.1 (KDVR DT) 1 vstreams, 2 astreams (eng) (spa)
+ 29, // 25.1 (KDEN-DT) 1 vstreams, 1 astreams (eng)
+ 32, // 31.1 (KDVR DT) 1 vstreams, 2 astreams (eng) (spa)
+ 34, // 2.1 (KWGN-DT) 1 vstreams, 2 astreams (eng) (eng)
+ 35, // 4.1 (KCNC-DT) 1 vstreams, 2 astreams (eng) (spa)
+ 38, // 38.1 (KPJR-1_) 1 vstreams, 1 astreams (eng)
+ // 38.2 (KPJR-2_) 1 vstreams, 1 astreams (eng)
+ // 38.3 (KPJR-3_) 1 vstreams, 1 astreams (eng)
+ // 38.4 (KPJR-4_) 1 vstreams, 1 astreams (eng)
+ // 38.5 (KPJR-5_) 1 vstreams, 1 astreams (eng)
+ 40, // 41.1 (KRMT 41) 1 vstreams, 1 astreams (eng)
+ 43, // 59.1 (ION____) 1 vstreams, 1 astreams (eng)
+ // 59.2 (qubo___) 1 vstreams, 2 astreams (eng) (eng)
+ // 59.3 (IONLife) 1 vstreams, 1 astreams (eng)
+ // 59.4 (Worship) 1 vstreams, 1 astreams (eng)
+ 46, // 53.1 (KWHD-DT) 1 vstreams, 1 astreams (eng)
+ 51, // 50.1 (Univisi) 1 vstreams, 1 astreams (spa)
+};
+
+int main(int ac, char **av)
+{
+ setbuf(stdout,NULL);
+ setbuf(stderr,NULL);
+ if( ac < 2 ) {
+ printf("channel ordinal required\n");
+ return 1;
+ }
+ int ch_ord = atoi(av[1]);
+ if( ch_ord >= 0 ) {
+ gtk_set_locale();
+ gtk_init(&ac, &av);
+ audio_done = 0;
+ video_done = 0;
+ reset();
+ if( ac == 3 ) {
+ subchan = atoi(av[2]);
+ }
+ else if( ac == 4 ) {
+ vid = atoi(av[2]);
+ aud = atoi(av[3]);
+ }
+ if( !open_tuner(0,ch_ord,0,0) ) {
+ if( !open_stream() ) {
+ stats();
+ zsrc->seek_byte(0);
+ // zsrc->show_subtitle(0);
+ start_stream();
+ while( !done ) {
+ usleep(100000);
+ if( audio_done && video_done) break;
+ }
+ stop_stream();
+ close_stream();
+ }
+ }
+ close_tuner();
+ }
+ else {
+ for( int ch=-ch_ord>2? -ch_ord : 2; ch<78; ++ch ) {
+ printf("\r %2d?\r",ch);
+ reset();
+ /* extra open/close clears previous bfr data */
+ if( !open_tuner(0,ch,0,0) ) close_tuner();
+ usleep(100000);
+ if( !open_tuner(0,ch,0,0) && !open_stream() ) {
+ int nch = zsrc->dvb.channel_count();
+ if( nch > 0 ) {
+ for( int ich=0, n=0; ich<nch; ++ich ) {
+ int mjr, mnr;
+ zsrc->dvb.get_channel(ich, mjr, mnr);
+ int astrs, vstrs, stream; char name[8], enc[4];
+ zsrc->dvb.get_station_id(ich, &name[0]);
+ zsrc->dvb.total_astreams(ich, astrs);
+ zsrc->dvb.total_vstreams(ich, vstrs);
+ if( n++ ) printf(" "); else printf(" %2d: ", ch);
+ printf(" %2d.%-2d (%s) %d vstreams, %d astreams",
+ mjr, mnr, name, vstrs, astrs);
+ for( int j=0; j<astrs; ++j ) {
+ zsrc->dvb.astream_number(ich, j, stream, &enc[0]);
+ printf(" (%s)",&enc[0]);
+ }
+ printf("\n");
+ }
+ }
+ close_stream();
+ }
+ close_tuner();
+ }
+ }
+ return 0;
+}
+
projects / goodguy / history.git / blobdiff