2 * av7110_av.c: audio and video MPEG decoder stuff
4 * Copyright (C) 1999-2002 Ralph Metzler
5 * & Marcus Metzler for convergence integrated media GmbH
7 * originally based on code by:
8 * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version 2
13 * of the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
28 * the project's page is at http://www.linuxtv.org/dvb/
31 #include <linux/types.h>
32 #include <linux/kernel.h>
33 #include <linux/string.h>
34 #include <linux/delay.h>
38 #include "av7110_hw.h"
39 #include "av7110_av.h"
40 #include "av7110_ipack.h"
42 /* MPEG-2 (ISO 13818 / H.222.0) stream types */
43 #define PROG_STREAM_MAP 0xBC
44 #define PRIVATE_STREAM1 0xBD
45 #define PADDING_STREAM 0xBE
46 #define PRIVATE_STREAM2 0xBF
47 #define AUDIO_STREAM_S 0xC0
48 #define AUDIO_STREAM_E 0xDF
49 #define VIDEO_STREAM_S 0xE0
50 #define VIDEO_STREAM_E 0xEF
51 #define ECM_STREAM 0xF0
52 #define EMM_STREAM 0xF1
53 #define DSM_CC_STREAM 0xF2
54 #define ISO13522_STREAM 0xF3
55 #define PROG_STREAM_DIR 0xFF
57 #define PTS_DTS_FLAGS 0xC0
63 #define TRANS_ERROR 0x80
64 #define PAY_START 0x40
65 #define TRANS_PRIO 0x20
66 #define PID_MASK_HI 0x1F
68 #define TRANS_SCRMBL1 0x80
69 #define TRANS_SCRMBL2 0x40
70 #define ADAPT_FIELD 0x20
72 #define COUNT_MASK 0x0F
75 #define DISCON_IND 0x80
76 #define RAND_ACC_IND 0x40
77 #define ES_PRI_IND 0x20
79 #define OPCR_FLAG 0x08
80 #define SPLICE_FLAG 0x04
81 #define TRANS_PRIV 0x02
82 #define ADAP_EXT_FLAG 0x01
84 // adaptation extension flags
86 #define PIECE_RATE 0x40
87 #define SEAM_SPLICE 0x20
90 static void p_to_t(u8
const *buf
, long int length
, u16 pid
,
91 u8
*counter
, struct dvb_demux_feed
*feed
);
92 static int write_ts_to_decoder(struct av7110
*av7110
, int type
, const u8
*buf
, size_t len
);
95 int av7110_record_cb(struct dvb_filter_pes2ts
*p2t
, u8
*buf
, size_t len
)
97 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) p2t
->priv
;
99 if (!(dvbdmxfeed
->ts_type
& TS_PACKET
))
101 if (buf
[3] == 0xe0) // video PES do not have a length in TS
103 if (dvbdmxfeed
->ts_type
& TS_PAYLOAD_ONLY
)
104 return dvbdmxfeed
->cb
.ts(buf
, len
, NULL
, 0,
105 &dvbdmxfeed
->feed
.ts
, DMX_OK
);
107 return dvb_filter_pes2ts(p2t
, buf
, len
, 1);
110 static int dvb_filter_pes2ts_cb(void *priv
, unsigned char *data
)
112 struct dvb_demux_feed
*dvbdmxfeed
= (struct dvb_demux_feed
*) priv
;
114 dvbdmxfeed
->cb
.ts(data
, 188, NULL
, 0,
115 &dvbdmxfeed
->feed
.ts
, DMX_OK
);
119 int av7110_av_start_record(struct av7110
*av7110
, int av
,
120 struct dvb_demux_feed
*dvbdmxfeed
)
123 struct dvb_demux
*dvbdmx
= dvbdmxfeed
->demux
;
125 dprintk(2, "av7110:%p, , dvb_demux_feed:%p\n", av7110
, dvbdmxfeed
);
127 if (av7110
->playing
|| (av7110
->rec_mode
& av
))
129 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Stop
, 0);
130 dvbdmx
->recording
= 1;
131 av7110
->rec_mode
|= av
;
133 switch (av7110
->rec_mode
) {
135 dvb_filter_pes2ts_init(&av7110
->p2t
[0],
136 dvbdmx
->pesfilter
[0]->pid
,
137 dvb_filter_pes2ts_cb
,
138 (void *) dvbdmx
->pesfilter
[0]);
139 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, AudioPES
, 0);
143 dvb_filter_pes2ts_init(&av7110
->p2t
[1],
144 dvbdmx
->pesfilter
[1]->pid
,
145 dvb_filter_pes2ts_cb
,
146 (void *) dvbdmx
->pesfilter
[1]);
147 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, VideoPES
, 0);
151 dvb_filter_pes2ts_init(&av7110
->p2t
[0],
152 dvbdmx
->pesfilter
[0]->pid
,
153 dvb_filter_pes2ts_cb
,
154 (void *) dvbdmx
->pesfilter
[0]);
155 dvb_filter_pes2ts_init(&av7110
->p2t
[1],
156 dvbdmx
->pesfilter
[1]->pid
,
157 dvb_filter_pes2ts_cb
,
158 (void *) dvbdmx
->pesfilter
[1]);
159 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, AV_PES
, 0);
165 int av7110_av_start_play(struct av7110
*av7110
, int av
)
168 dprintk(2, "av7110:%p, \n", av7110
);
170 if (av7110
->rec_mode
)
172 if (av7110
->playing
& av
)
175 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Stop
, 0);
177 if (av7110
->playing
== RP_NONE
) {
178 av7110_ipack_reset(&av7110
->ipack
[0]);
179 av7110_ipack_reset(&av7110
->ipack
[1]);
182 av7110
->playing
|= av
;
183 switch (av7110
->playing
) {
185 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, AudioPES
, 0);
188 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, VideoPES
, 0);
193 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, AV_PES
, 0);
199 int av7110_av_stop(struct av7110
*av7110
, int av
)
202 dprintk(2, "av7110:%p, \n", av7110
);
204 if (!(av7110
->playing
& av
) && !(av7110
->rec_mode
& av
))
206 av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Stop
, 0);
207 if (av7110
->playing
) {
208 av7110
->playing
&= ~av
;
209 switch (av7110
->playing
) {
211 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, AudioPES
, 0);
214 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Play
, 2, VideoPES
, 0);
217 ret
= av7110_set_vidmode(av7110
, av7110
->vidmode
);
221 av7110
->rec_mode
&= ~av
;
222 switch (av7110
->rec_mode
) {
224 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, AudioPES
, 0);
227 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Record
, 2, VideoPES
, 0);
237 int av7110_pes_play(void *dest
, struct dvb_ringbuffer
*buf
, int dlen
)
244 wake_up(&buf
->queue
);
248 if ((len
= dvb_ringbuffer_avail(buf
)) < 6)
250 sync
= DVB_RINGBUFFER_PEEK(buf
, 0) << 24;
251 sync
|= DVB_RINGBUFFER_PEEK(buf
, 1) << 16;
252 sync
|= DVB_RINGBUFFER_PEEK(buf
, 2) << 8;
253 sync
|= DVB_RINGBUFFER_PEEK(buf
, 3);
255 if (((sync
&~ 0x0f) == 0x000001e0) ||
256 ((sync
&~ 0x1f) == 0x000001c0) ||
257 (sync
== 0x000001bd))
260 DVB_RINGBUFFER_SKIP(buf
, 1);
262 blen
= DVB_RINGBUFFER_PEEK(buf
, 4) << 8;
263 blen
|= DVB_RINGBUFFER_PEEK(buf
, 5);
265 if (len
< blen
|| blen
> dlen
) {
266 //printk("buffer empty - avail %d blen %u dlen %d\n", len, blen, dlen);
267 wake_up(&buf
->queue
);
271 dvb_ringbuffer_read(buf
, dest
, (size_t) blen
);
273 dprintk(2, "pread=0x%08lx, pwrite=0x%08lx\n",
274 (unsigned long) buf
->pread
, (unsigned long) buf
->pwrite
);
275 wake_up(&buf
->queue
);
280 int av7110_set_volume(struct av7110
*av7110
, int volleft
, int volright
)
282 int err
, vol
, val
, balance
= 0;
284 dprintk(2, "av7110:%p, \n", av7110
);
286 av7110
->mixer
.volume_left
= volleft
;
287 av7110
->mixer
.volume_right
= volright
;
289 switch (av7110
->adac_type
) {
291 volleft
= (volleft
* 256) / 1036;
292 volright
= (volright
* 256) / 1036;
297 if ((err
= SendDAC(av7110
, 3, 0x80 + volleft
)))
299 return SendDAC(av7110
, 4, volright
);
301 case DVB_ADAC_CRYSTAL
:
302 volleft
= 127 - volleft
/ 2;
303 volright
= 127 - volright
/ 2;
304 i2c_writereg(av7110
, 0x20, 0x03, volleft
);
305 i2c_writereg(av7110
, 0x20, 0x04, volright
);
308 case DVB_ADAC_MSP34x0
:
309 vol
= (volleft
> volright
) ? volleft
: volright
;
310 val
= (vol
* 0x73 / 255) << 8;
312 balance
= ((volright
- volleft
) * 127) / vol
;
313 msp_writereg(av7110
, MSP_WR_DSP
, 0x0001, balance
<< 8);
314 msp_writereg(av7110
, MSP_WR_DSP
, 0x0000, val
); /* loudspeaker */
315 msp_writereg(av7110
, MSP_WR_DSP
, 0x0006, val
); /* headphonesr */
318 case DVB_ADAC_MSP34x5
:
319 vol
= (volleft
> volright
) ? volleft
: volright
;
320 val
= (vol
* 0x73 / 255) << 8;
322 balance
= ((volright
- volleft
) * 127) / vol
;
323 msp_writereg(av7110
, MSP_WR_DSP
, 0x0001, balance
<< 8);
324 msp_writereg(av7110
, MSP_WR_DSP
, 0x0000, val
); /* loudspeaker */
331 int av7110_set_vidmode(struct av7110
*av7110
, enum av7110_video_mode mode
)
334 dprintk(2, "av7110:%p, \n", av7110
);
336 ret
= av7110_fw_cmd(av7110
, COMTYPE_ENCODER
, LoadVidCode
, 1, mode
);
338 if (!ret
&& !av7110
->playing
) {
339 ret
= ChangePIDs(av7110
, av7110
->pids
[DMX_PES_VIDEO
],
340 av7110
->pids
[DMX_PES_AUDIO
],
341 av7110
->pids
[DMX_PES_TELETEXT
],
342 0, av7110
->pids
[DMX_PES_PCR
]);
344 ret
= av7110_fw_cmd(av7110
, COMTYPE_PIDFILTER
, Scan
, 0);
350 static enum av7110_video_mode sw2mode
[16] = {
351 AV7110_VIDEO_MODE_PAL
, AV7110_VIDEO_MODE_NTSC
,
352 AV7110_VIDEO_MODE_NTSC
, AV7110_VIDEO_MODE_PAL
,
353 AV7110_VIDEO_MODE_NTSC
, AV7110_VIDEO_MODE_NTSC
,
354 AV7110_VIDEO_MODE_PAL
, AV7110_VIDEO_MODE_NTSC
,
355 AV7110_VIDEO_MODE_PAL
, AV7110_VIDEO_MODE_PAL
,
356 AV7110_VIDEO_MODE_PAL
, AV7110_VIDEO_MODE_PAL
,
357 AV7110_VIDEO_MODE_PAL
, AV7110_VIDEO_MODE_PAL
,
358 AV7110_VIDEO_MODE_PAL
, AV7110_VIDEO_MODE_PAL
,
361 static int get_video_format(struct av7110
*av7110
, u8
*buf
, int count
)
369 dprintk(2, "av7110:%p, \n", av7110
);
373 for (i
= 7; i
< count
- 10; i
++) {
375 if (p
[0] || p
[1] || p
[2] != 0x01 || p
[3] != 0xb3)
378 hsize
= ((p
[1] &0xF0) >> 4) | (p
[0] << 4);
379 vsize
= ((p
[1] &0x0F) << 8) | (p
[2]);
381 ret
= av7110_set_vidmode(av7110
, sw2mode
[sw
]);
383 dprintk(2, "playback %dx%d fr=%d\n", hsize
, vsize
, sw
);
392 /****************************************************************************
393 * I/O buffer management and control
394 ****************************************************************************/
396 static inline long aux_ring_buffer_write(struct dvb_ringbuffer
*rbuf
,
397 const u8
*buf
, unsigned long count
)
399 unsigned long todo
= count
;
403 if (dvb_ringbuffer_free(rbuf
) < 2048) {
404 if (wait_event_interruptible(rbuf
->queue
,
405 (dvb_ringbuffer_free(rbuf
) >= 2048)))
408 free
= dvb_ringbuffer_free(rbuf
);
411 dvb_ringbuffer_write(rbuf
, buf
, free
);
419 static void play_video_cb(u8
*buf
, int count
, void *priv
)
421 struct av7110
*av7110
= (struct av7110
*) priv
;
422 dprintk(2, "av7110:%p, \n", av7110
);
424 if ((buf
[3] & 0xe0) == 0xe0) {
425 get_video_format(av7110
, buf
, count
);
426 aux_ring_buffer_write(&av7110
->avout
, buf
, count
);
428 aux_ring_buffer_write(&av7110
->aout
, buf
, count
);
431 static void play_audio_cb(u8
*buf
, int count
, void *priv
)
433 struct av7110
*av7110
= (struct av7110
*) priv
;
434 dprintk(2, "av7110:%p, \n", av7110
);
436 aux_ring_buffer_write(&av7110
->aout
, buf
, count
);
440 #define FREE_COND_TS (dvb_ringbuffer_free(rb) >= 4096)
442 static ssize_t
ts_play(struct av7110
*av7110
, const char __user
*buf
,
443 unsigned long count
, int nonblock
, int type
)
445 struct dvb_ringbuffer
*rb
;
447 unsigned long todo
= count
;
449 dprintk(2, "%s: type %d cnt %lu\n", __func__
, type
, count
);
451 rb
= (type
) ? &av7110
->avout
: &av7110
->aout
;
452 kb
= av7110
->kbuf
[type
];
457 if (nonblock
&& !FREE_COND_TS
)
460 while (todo
>= TS_SIZE
) {
464 if (wait_event_interruptible(rb
->queue
, FREE_COND_TS
))
467 if (copy_from_user(kb
, buf
, TS_SIZE
))
469 write_ts_to_decoder(av7110
, type
, kb
, TS_SIZE
);
478 #define FREE_COND (dvb_ringbuffer_free(&av7110->avout) >= 20 * 1024 && \
479 dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)
481 static ssize_t
dvb_play(struct av7110
*av7110
, const char __user
*buf
,
482 unsigned long count
, int nonblock
, int type
)
484 unsigned long todo
= count
, n
;
485 dprintk(2, "av7110:%p, \n", av7110
);
487 if (!av7110
->kbuf
[type
])
490 if (nonblock
&& !FREE_COND
)
497 if (wait_event_interruptible(av7110
->avout
.queue
,
504 if (copy_from_user(av7110
->kbuf
[type
], buf
, n
))
506 av7110_ipack_instant_repack(av7110
->kbuf
[type
], n
,
507 &av7110
->ipack
[type
]);
514 static ssize_t
dvb_play_kernel(struct av7110
*av7110
, const u8
*buf
,
515 unsigned long count
, int nonblock
, int type
)
517 unsigned long todo
= count
, n
;
518 dprintk(2, "av7110:%p, \n", av7110
);
520 if (!av7110
->kbuf
[type
])
523 if (nonblock
&& !FREE_COND
)
530 if (wait_event_interruptible(av7110
->avout
.queue
,
537 av7110_ipack_instant_repack(buf
, n
, &av7110
->ipack
[type
]);
544 static ssize_t
dvb_aplay(struct av7110
*av7110
, const char __user
*buf
,
545 unsigned long count
, int nonblock
, int type
)
547 unsigned long todo
= count
, n
;
548 dprintk(2, "av7110:%p, \n", av7110
);
550 if (!av7110
->kbuf
[type
])
552 if (nonblock
&& dvb_ringbuffer_free(&av7110
->aout
) < 20 * 1024)
556 if (dvb_ringbuffer_free(&av7110
->aout
) < 20 * 1024) {
559 if (wait_event_interruptible(av7110
->aout
.queue
,
560 (dvb_ringbuffer_free(&av7110
->aout
) >= 20 * 1024)))
566 if (copy_from_user(av7110
->kbuf
[type
], buf
, n
))
568 av7110_ipack_instant_repack(av7110
->kbuf
[type
], n
,
569 &av7110
->ipack
[type
]);
576 void av7110_p2t_init(struct av7110_p2t
*p
, struct dvb_demux_feed
*feed
)
578 memset(p
->pes
, 0, TS_SIZE
);
586 static void clear_p2t(struct av7110_p2t
*p
)
588 memset(p
->pes
, 0, TS_SIZE
);
595 static int find_pes_header(u8
const *buf
, long int length
, int *frags
)
602 while (c
< length
- 3 && !found
) {
603 if (buf
[c
] == 0x00 && buf
[c
+ 1] == 0x00 &&
604 buf
[c
+ 2] == 0x01) {
605 switch ( buf
[c
+ 3] ) {
606 case PROG_STREAM_MAP
:
607 case PRIVATE_STREAM2
:
608 case PROG_STREAM_DIR
:
611 case PADDING_STREAM
:
613 case ISO13522_STREAM
:
614 case PRIVATE_STREAM1
:
615 case AUDIO_STREAM_S
... AUDIO_STREAM_E
:
616 case VIDEO_STREAM_S
... VIDEO_STREAM_E
:
627 if (c
== length
- 3 && !found
) {
628 if (buf
[length
- 1] == 0x00)
630 if (buf
[length
- 2] == 0x00 &&
631 buf
[length
- 1] == 0x00)
633 if (buf
[length
- 3] == 0x00 &&
634 buf
[length
- 2] == 0x00 &&
635 buf
[length
- 1] == 0x01)
643 void av7110_p2t_write(u8
const *buf
, long int length
, u16 pid
, struct av7110_p2t
*p
)
654 if (buf
[c
] == 0x00 && buf
[c
+ 1] == 0x01) {
660 if (buf
[c
] == 0x01) {
670 case PROG_STREAM_MAP
:
671 case PRIVATE_STREAM2
:
672 case PROG_STREAM_DIR
:
675 case PADDING_STREAM
:
677 case ISO13522_STREAM
:
678 case PRIVATE_STREAM1
:
679 case AUDIO_STREAM_S
... AUDIO_STREAM_E
:
680 case VIDEO_STREAM_S
... VIDEO_STREAM_E
:
686 memcpy(p
->pes
+ p
->pos
, buf
+ c
, (TS_SIZE
- 4) - p
->pos
);
687 c
+= (TS_SIZE
- 4) - p
->pos
;
688 p_to_t(p
->pes
, (TS_SIZE
- 4), pid
, &p
->counter
, p
->feed
);
701 c2
= find_pes_header(buf
+ c
, length
- c
, &p
->frags
);
702 if (c2
>= 0 && c2
< (TS_SIZE
- 4) - p
->pos
)
705 l
= (TS_SIZE
- 4) - p
->pos
;
706 memcpy(p
->pes
+ p
->pos
, buf
, l
);
709 p_to_t(p
->pes
, p
->pos
, pid
, &p
->counter
, p
->feed
);
715 c2
= find_pes_header(buf
+ c
+ add
, length
- c
- add
, &p
->frags
);
719 p_to_t(buf
+ c
, c2
- c
, pid
, &p
->counter
, p
->feed
);
727 rest
= l
% (TS_SIZE
- 4);
729 p_to_t(buf
+ c
, l
, pid
, &p
->counter
, p
->feed
);
730 memcpy(p
->pes
, buf
+ c
+ l
, rest
);
738 static int write_ts_header2(u16 pid
, u8
*counter
, int pes_start
, u8
*buf
, u8 length
)
743 u8 tshead
[4] = { 0x47, 0x00, 0x00, 0x10 };
745 fill
= (TS_SIZE
- 4) - length
;
750 tshead
[1] |= (u8
)((pid
& 0x1F00) >> 8);
751 tshead
[2] |= (u8
)(pid
& 0x00FF);
752 tshead
[3] |= ((*counter
)++ & 0x0F);
753 memcpy(buf
, tshead
, 4);
763 for (i
= 6; i
< fill
+ 4; i
++) {
773 static void p_to_t(u8
const *buf
, long int length
, u16 pid
, u8
*counter
,
774 struct dvb_demux_feed
*feed
)
782 buf
[0] == 0x00 && buf
[1] == 0x00 && buf
[2] == 0x01)
784 case PROG_STREAM_MAP
:
785 case PRIVATE_STREAM2
:
786 case PROG_STREAM_DIR
:
789 case PADDING_STREAM
:
791 case ISO13522_STREAM
:
792 case PRIVATE_STREAM1
:
793 case AUDIO_STREAM_S
... AUDIO_STREAM_E
:
794 case VIDEO_STREAM_S
... VIDEO_STREAM_E
:
803 memset(obuf
, 0, TS_SIZE
);
804 if (length
- c
>= (TS_SIZE
- 4)){
805 l
= write_ts_header2(pid
, counter
, pes_start
,
806 obuf
, (TS_SIZE
- 4));
807 memcpy(obuf
+ l
, buf
+ c
, TS_SIZE
- l
);
810 l
= write_ts_header2(pid
, counter
, pes_start
,
812 memcpy(obuf
+ l
, buf
+ c
, TS_SIZE
- l
);
815 feed
->cb
.ts(obuf
, 188, NULL
, 0, &feed
->feed
.ts
, DMX_OK
);
821 static int write_ts_to_decoder(struct av7110
*av7110
, int type
, const u8
*buf
, size_t len
)
823 struct ipack
*ipack
= &av7110
->ipack
[type
];
825 if (buf
[1] & TRANS_ERROR
) {
826 av7110_ipack_reset(ipack
);
830 if (!(buf
[3] & PAYLOAD
))
833 if (buf
[1] & PAY_START
)
834 av7110_ipack_flush(ipack
);
836 if (buf
[3] & ADAPT_FIELD
) {
843 av7110_ipack_instant_repack(buf
+ 4, len
- 4, ipack
);
848 int av7110_write_to_decoder(struct dvb_demux_feed
*feed
, const u8
*buf
, size_t len
)
850 struct dvb_demux
*demux
= feed
->demux
;
851 struct av7110
*av7110
= (struct av7110
*) demux
->priv
;
853 dprintk(2, "av7110:%p, \n", av7110
);
855 if (av7110
->full_ts
&& demux
->dmx
.frontend
->source
!= DMX_MEMORY_FE
)
858 switch (feed
->pes_type
) {
860 if (av7110
->audiostate
.stream_source
== AUDIO_SOURCE_MEMORY
)
864 if (av7110
->videostate
.stream_source
== VIDEO_SOURCE_MEMORY
)
871 return write_ts_to_decoder(av7110
, feed
->pes_type
, buf
, len
);
876 /******************************************************************************
877 * Video MPEG decoder events
878 ******************************************************************************/
879 void dvb_video_add_event(struct av7110
*av7110
, struct video_event
*event
)
881 struct dvb_video_events
*events
= &av7110
->video_events
;
884 spin_lock_bh(&events
->lock
);
886 wp
= (events
->eventw
+ 1) % MAX_VIDEO_EVENT
;
887 if (wp
== events
->eventr
) {
888 events
->overflow
= 1;
889 events
->eventr
= (events
->eventr
+ 1) % MAX_VIDEO_EVENT
;
892 memcpy(&events
->events
[events
->eventw
], event
, sizeof(struct video_event
));
895 spin_unlock_bh(&events
->lock
);
897 wake_up_interruptible(&events
->wait_queue
);
901 static int dvb_video_get_event (struct av7110
*av7110
, struct video_event
*event
, int flags
)
903 struct dvb_video_events
*events
= &av7110
->video_events
;
905 if (events
->overflow
) {
906 events
->overflow
= 0;
909 if (events
->eventw
== events
->eventr
) {
912 if (flags
& O_NONBLOCK
)
915 ret
= wait_event_interruptible(events
->wait_queue
,
916 events
->eventw
!= events
->eventr
);
921 spin_lock_bh(&events
->lock
);
923 memcpy(event
, &events
->events
[events
->eventr
],
924 sizeof(struct video_event
));
925 events
->eventr
= (events
->eventr
+ 1) % MAX_VIDEO_EVENT
;
927 spin_unlock_bh(&events
->lock
);
933 /******************************************************************************
934 * DVB device file operations
935 ******************************************************************************/
937 static unsigned int dvb_video_poll(struct file
*file
, poll_table
*wait
)
939 struct dvb_device
*dvbdev
= file
->private_data
;
940 struct av7110
*av7110
= dvbdev
->priv
;
941 unsigned int mask
= 0;
943 dprintk(2, "av7110:%p, \n", av7110
);
945 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
)
946 poll_wait(file
, &av7110
->avout
.queue
, wait
);
948 poll_wait(file
, &av7110
->video_events
.wait_queue
, wait
);
950 if (av7110
->video_events
.eventw
!= av7110
->video_events
.eventr
)
953 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
954 if (av7110
->playing
) {
956 mask
|= (POLLOUT
| POLLWRNORM
);
957 } else /* if not playing: may play if asked for */
958 mask
|= (POLLOUT
| POLLWRNORM
);
964 static ssize_t
dvb_video_write(struct file
*file
, const char __user
*buf
,
965 size_t count
, loff_t
*ppos
)
967 struct dvb_device
*dvbdev
= file
->private_data
;
968 struct av7110
*av7110
= dvbdev
->priv
;
971 dprintk(2, "av7110:%p, \n", av7110
);
973 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
)
976 if (av7110
->videostate
.stream_source
!= VIDEO_SOURCE_MEMORY
)
979 if (get_user(c
, buf
))
981 if (c
== 0x47 && count
% TS_SIZE
== 0)
982 return ts_play(av7110
, buf
, count
, file
->f_flags
& O_NONBLOCK
, 1);
984 return dvb_play(av7110
, buf
, count
, file
->f_flags
& O_NONBLOCK
, 1);
987 static unsigned int dvb_audio_poll(struct file
*file
, poll_table
*wait
)
989 struct dvb_device
*dvbdev
= file
->private_data
;
990 struct av7110
*av7110
= dvbdev
->priv
;
991 unsigned int mask
= 0;
993 dprintk(2, "av7110:%p, \n", av7110
);
995 poll_wait(file
, &av7110
->aout
.queue
, wait
);
997 if (av7110
->playing
) {
998 if (dvb_ringbuffer_free(&av7110
->aout
) >= 20 * 1024)
999 mask
|= (POLLOUT
| POLLWRNORM
);
1000 } else /* if not playing: may play if asked for */
1001 mask
= (POLLOUT
| POLLWRNORM
);
1006 static ssize_t
dvb_audio_write(struct file
*file
, const char __user
*buf
,
1007 size_t count
, loff_t
*ppos
)
1009 struct dvb_device
*dvbdev
= file
->private_data
;
1010 struct av7110
*av7110
= dvbdev
->priv
;
1013 dprintk(2, "av7110:%p, \n", av7110
);
1015 if (av7110
->audiostate
.stream_source
!= AUDIO_SOURCE_MEMORY
) {
1016 printk(KERN_ERR
"not audio source memory\n");
1020 if (get_user(c
, buf
))
1022 if (c
== 0x47 && count
% TS_SIZE
== 0)
1023 return ts_play(av7110
, buf
, count
, file
->f_flags
& O_NONBLOCK
, 0);
1025 return dvb_aplay(av7110
, buf
, count
, file
->f_flags
& O_NONBLOCK
, 0);
1028 static u8 iframe_header
[] = { 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x80, 0x00, 0x00 };
1030 #define MIN_IFRAME 400000
1032 static int play_iframe(struct av7110
*av7110
, char __user
*buf
, unsigned int len
, int nonblock
)
1035 int progressive
= 0;
1038 dprintk(2, "av7110:%p, \n", av7110
);
1040 if (!(av7110
->playing
& RP_VIDEO
)) {
1041 if (av7110_av_start_play(av7110
, RP_VIDEO
) < 0)
1045 /* search in buf for instances of 00 00 01 b5 1? */
1046 for (i
= 0; i
< len
; i
++) {
1048 if (get_user(c
, buf
+ i
))
1051 progressive
= c
& 0x08;
1055 match
= (match
== 1 || match
== 2) ? 2 : 1;
1059 case 2: if (c
== 0x01)
1062 case 3: if (c
== 0xb5)
1065 case 4: if ((c
& 0xf0) == 0x10)
1072 /* setting n always > 1, fixes problems when playing stillframes
1073 consisting of I- and P-Frames */
1074 n
= MIN_IFRAME
/ len
+ 1;
1076 dvb_play_kernel(av7110
, iframe_header
, sizeof(iframe_header
), 0, 1);
1078 for (i
= 0; i
< n
; i
++)
1079 dvb_play(av7110
, buf
, len
, 0, 1);
1081 av7110_ipack_flush(&av7110
->ipack
[1]);
1084 return vidcom(av7110
, AV_VIDEO_CMD_FREEZE
, 1);
1090 static int dvb_video_ioctl(struct file
*file
,
1091 unsigned int cmd
, void *parg
)
1093 struct dvb_device
*dvbdev
= file
->private_data
;
1094 struct av7110
*av7110
= dvbdev
->priv
;
1095 unsigned long arg
= (unsigned long) parg
;
1098 dprintk(1, "av7110:%p, cmd=%04x\n", av7110
,cmd
);
1100 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) {
1101 if ( cmd
!= VIDEO_GET_STATUS
&& cmd
!= VIDEO_GET_EVENT
&&
1102 cmd
!= VIDEO_GET_SIZE
) {
1109 av7110
->videostate
.play_state
= VIDEO_STOPPED
;
1110 if (av7110
->videostate
.stream_source
== VIDEO_SOURCE_MEMORY
)
1111 ret
= av7110_av_stop(av7110
, RP_VIDEO
);
1113 ret
= vidcom(av7110
, AV_VIDEO_CMD_STOP
,
1114 av7110
->videostate
.video_blank
? 0 : 1);
1116 av7110
->trickmode
= TRICK_NONE
;
1120 av7110
->trickmode
= TRICK_NONE
;
1121 if (av7110
->videostate
.play_state
== VIDEO_FREEZED
) {
1122 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1123 ret
= vidcom(av7110
, AV_VIDEO_CMD_PLAY
, 0);
1127 if (av7110
->videostate
.stream_source
== VIDEO_SOURCE_MEMORY
) {
1128 if (av7110
->playing
== RP_AV
) {
1129 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Stop
, 0);
1132 av7110
->playing
&= ~RP_VIDEO
;
1134 ret
= av7110_av_start_play(av7110
, RP_VIDEO
);
1137 ret
= vidcom(av7110
, AV_VIDEO_CMD_PLAY
, 0);
1139 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1143 av7110
->videostate
.play_state
= VIDEO_FREEZED
;
1144 if (av7110
->playing
& RP_VIDEO
)
1145 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Pause
, 0);
1147 ret
= vidcom(av7110
, AV_VIDEO_CMD_FREEZE
, 1);
1149 av7110
->trickmode
= TRICK_FREEZE
;
1152 case VIDEO_CONTINUE
:
1153 if (av7110
->playing
& RP_VIDEO
)
1154 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Continue
, 0);
1156 ret
= vidcom(av7110
, AV_VIDEO_CMD_PLAY
, 0);
1158 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1159 av7110
->trickmode
= TRICK_NONE
;
1163 case VIDEO_SELECT_SOURCE
:
1164 av7110
->videostate
.stream_source
= (video_stream_source_t
) arg
;
1167 case VIDEO_SET_BLANK
:
1168 av7110
->videostate
.video_blank
= (int) arg
;
1171 case VIDEO_GET_STATUS
:
1172 memcpy(parg
, &av7110
->videostate
, sizeof(struct video_status
));
1175 case VIDEO_GET_EVENT
:
1176 ret
= dvb_video_get_event(av7110
, parg
, file
->f_flags
);
1179 case VIDEO_GET_SIZE
:
1180 memcpy(parg
, &av7110
->video_size
, sizeof(video_size_t
));
1183 case VIDEO_SET_DISPLAY_FORMAT
:
1185 video_displayformat_t format
= (video_displayformat_t
) arg
;
1187 case VIDEO_PAN_SCAN
:
1188 av7110
->display_panscan
= VID_PAN_SCAN_PREF
;
1190 case VIDEO_LETTER_BOX
:
1191 av7110
->display_panscan
= VID_VC_AND_PS_PREF
;
1193 case VIDEO_CENTER_CUT_OUT
:
1194 av7110
->display_panscan
= VID_CENTRE_CUT_PREF
;
1201 av7110
->videostate
.display_format
= format
;
1202 ret
= av7110_fw_cmd(av7110
, COMTYPE_ENCODER
, SetPanScanType
,
1203 1, av7110
->display_panscan
);
1207 case VIDEO_SET_FORMAT
:
1212 av7110
->display_ar
= arg
;
1213 ret
= av7110_fw_cmd(av7110
, COMTYPE_ENCODER
, SetMonitorType
,
1217 case VIDEO_STILLPICTURE
:
1219 struct video_still_picture
*pic
=
1220 (struct video_still_picture
*) parg
;
1221 av7110
->videostate
.stream_source
= VIDEO_SOURCE_MEMORY
;
1222 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->avout
);
1223 ret
= play_iframe(av7110
, pic
->iFrame
, pic
->size
,
1224 file
->f_flags
& O_NONBLOCK
);
1228 case VIDEO_FAST_FORWARD
:
1229 //note: arg is ignored by firmware
1230 if (av7110
->playing
& RP_VIDEO
)
1231 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1232 __Scan_I
, 2, AV_PES
, 0);
1234 ret
= vidcom(av7110
, AV_VIDEO_CMD_FFWD
, arg
);
1236 av7110
->trickmode
= TRICK_FAST
;
1237 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1241 case VIDEO_SLOWMOTION
:
1242 if (av7110
->playing
&RP_VIDEO
) {
1243 if (av7110
->trickmode
!= TRICK_SLOW
)
1244 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
, __Slow
, 2, 0, 0);
1246 ret
= vidcom(av7110
, AV_VIDEO_CMD_SLOW
, arg
);
1248 ret
= vidcom(av7110
, AV_VIDEO_CMD_PLAY
, 0);
1250 ret
= vidcom(av7110
, AV_VIDEO_CMD_STOP
, 0);
1252 ret
= vidcom(av7110
, AV_VIDEO_CMD_SLOW
, arg
);
1255 av7110
->trickmode
= TRICK_SLOW
;
1256 av7110
->videostate
.play_state
= VIDEO_PLAYING
;
1260 case VIDEO_GET_CAPABILITIES
:
1261 *(int *)parg
= VIDEO_CAP_MPEG1
| VIDEO_CAP_MPEG2
|
1262 VIDEO_CAP_SYS
| VIDEO_CAP_PROG
;
1265 case VIDEO_CLEAR_BUFFER
:
1266 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->avout
);
1267 av7110_ipack_reset(&av7110
->ipack
[1]);
1268 if (av7110
->playing
== RP_AV
) {
1269 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1270 __Play
, 2, AV_PES
, 0);
1273 if (av7110
->trickmode
== TRICK_FAST
)
1274 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1275 __Scan_I
, 2, AV_PES
, 0);
1276 if (av7110
->trickmode
== TRICK_SLOW
) {
1277 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1280 ret
= vidcom(av7110
, AV_VIDEO_CMD_SLOW
, arg
);
1282 if (av7110
->trickmode
== TRICK_FREEZE
)
1283 ret
= vidcom(av7110
, AV_VIDEO_CMD_STOP
, 1);
1287 case VIDEO_SET_STREAMTYPE
:
1298 static int dvb_audio_ioctl(struct file
*file
,
1299 unsigned int cmd
, void *parg
)
1301 struct dvb_device
*dvbdev
= file
->private_data
;
1302 struct av7110
*av7110
= dvbdev
->priv
;
1303 unsigned long arg
= (unsigned long) parg
;
1306 dprintk(1, "av7110:%p, cmd=%04x\n", av7110
,cmd
);
1308 if (((file
->f_flags
& O_ACCMODE
) == O_RDONLY
) &&
1309 (cmd
!= AUDIO_GET_STATUS
))
1314 if (av7110
->audiostate
.stream_source
== AUDIO_SOURCE_MEMORY
)
1315 ret
= av7110_av_stop(av7110
, RP_AUDIO
);
1317 ret
= audcom(av7110
, AUDIO_CMD_MUTE
);
1319 av7110
->audiostate
.play_state
= AUDIO_STOPPED
;
1323 if (av7110
->audiostate
.stream_source
== AUDIO_SOURCE_MEMORY
)
1324 ret
= av7110_av_start_play(av7110
, RP_AUDIO
);
1326 ret
= audcom(av7110
, AUDIO_CMD_UNMUTE
);
1328 av7110
->audiostate
.play_state
= AUDIO_PLAYING
;
1332 ret
= audcom(av7110
, AUDIO_CMD_MUTE
);
1334 av7110
->audiostate
.play_state
= AUDIO_PAUSED
;
1337 case AUDIO_CONTINUE
:
1338 if (av7110
->audiostate
.play_state
== AUDIO_PAUSED
) {
1339 av7110
->audiostate
.play_state
= AUDIO_PLAYING
;
1340 ret
= audcom(av7110
, AUDIO_CMD_UNMUTE
| AUDIO_CMD_PCM16
);
1344 case AUDIO_SELECT_SOURCE
:
1345 av7110
->audiostate
.stream_source
= (audio_stream_source_t
) arg
;
1348 case AUDIO_SET_MUTE
:
1350 ret
= audcom(av7110
, arg
? AUDIO_CMD_MUTE
: AUDIO_CMD_UNMUTE
);
1352 av7110
->audiostate
.mute_state
= (int) arg
;
1356 case AUDIO_SET_AV_SYNC
:
1357 av7110
->audiostate
.AV_sync_state
= (int) arg
;
1358 ret
= audcom(av7110
, arg
? AUDIO_CMD_SYNC_ON
: AUDIO_CMD_SYNC_OFF
);
1361 case AUDIO_SET_BYPASS_MODE
:
1362 if (FW_VERSION(av7110
->arm_app
) < 0x2621)
1364 av7110
->audiostate
.bypass_mode
= (int)arg
;
1367 case AUDIO_CHANNEL_SELECT
:
1368 av7110
->audiostate
.channel_select
= (audio_channel_select_t
) arg
;
1369 switch(av7110
->audiostate
.channel_select
) {
1371 ret
= audcom(av7110
, AUDIO_CMD_STEREO
);
1373 if (av7110
->adac_type
== DVB_ADAC_CRYSTAL
)
1374 i2c_writereg(av7110
, 0x20, 0x02, 0x49);
1375 else if (av7110
->adac_type
== DVB_ADAC_MSP34x5
)
1376 msp_writereg(av7110
, MSP_WR_DSP
, 0x0008, 0x0220);
1379 case AUDIO_MONO_LEFT
:
1380 ret
= audcom(av7110
, AUDIO_CMD_MONO_L
);
1382 if (av7110
->adac_type
== DVB_ADAC_CRYSTAL
)
1383 i2c_writereg(av7110
, 0x20, 0x02, 0x4a);
1384 else if (av7110
->adac_type
== DVB_ADAC_MSP34x5
)
1385 msp_writereg(av7110
, MSP_WR_DSP
, 0x0008, 0x0200);
1388 case AUDIO_MONO_RIGHT
:
1389 ret
= audcom(av7110
, AUDIO_CMD_MONO_R
);
1391 if (av7110
->adac_type
== DVB_ADAC_CRYSTAL
)
1392 i2c_writereg(av7110
, 0x20, 0x02, 0x45);
1393 else if (av7110
->adac_type
== DVB_ADAC_MSP34x5
)
1394 msp_writereg(av7110
, MSP_WR_DSP
, 0x0008, 0x0210);
1403 case AUDIO_GET_STATUS
:
1404 memcpy(parg
, &av7110
->audiostate
, sizeof(struct audio_status
));
1407 case AUDIO_GET_CAPABILITIES
:
1408 if (FW_VERSION(av7110
->arm_app
) < 0x2621)
1409 *(unsigned int *)parg
= AUDIO_CAP_LPCM
| AUDIO_CAP_MP1
| AUDIO_CAP_MP2
;
1411 *(unsigned int *)parg
= AUDIO_CAP_LPCM
| AUDIO_CAP_DTS
| AUDIO_CAP_AC3
|
1412 AUDIO_CAP_MP1
| AUDIO_CAP_MP2
;
1415 case AUDIO_CLEAR_BUFFER
:
1416 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->aout
);
1417 av7110_ipack_reset(&av7110
->ipack
[0]);
1418 if (av7110
->playing
== RP_AV
)
1419 ret
= av7110_fw_cmd(av7110
, COMTYPE_REC_PLAY
,
1420 __Play
, 2, AV_PES
, 0);
1426 case AUDIO_SET_MIXER
:
1428 struct audio_mixer
*amix
= (struct audio_mixer
*)parg
;
1429 ret
= av7110_set_volume(av7110
, amix
->volume_left
, amix
->volume_right
);
1433 case AUDIO_SET_STREAMTYPE
:
1444 static int dvb_video_open(struct inode
*inode
, struct file
*file
)
1446 struct dvb_device
*dvbdev
= file
->private_data
;
1447 struct av7110
*av7110
= dvbdev
->priv
;
1450 dprintk(2, "av7110:%p, \n", av7110
);
1452 if ((err
= dvb_generic_open(inode
, file
)) < 0)
1455 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
1456 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->aout
);
1457 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->avout
);
1458 av7110
->video_blank
= 1;
1459 av7110
->audiostate
.AV_sync_state
= 1;
1460 av7110
->videostate
.stream_source
= VIDEO_SOURCE_DEMUX
;
1462 /* empty event queue */
1463 av7110
->video_events
.eventr
= av7110
->video_events
.eventw
= 0;
1469 static int dvb_video_release(struct inode
*inode
, struct file
*file
)
1471 struct dvb_device
*dvbdev
= file
->private_data
;
1472 struct av7110
*av7110
= dvbdev
->priv
;
1474 dprintk(2, "av7110:%p, \n", av7110
);
1476 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
1477 av7110_av_stop(av7110
, RP_VIDEO
);
1480 return dvb_generic_release(inode
, file
);
1483 static int dvb_audio_open(struct inode
*inode
, struct file
*file
)
1485 struct dvb_device
*dvbdev
= file
->private_data
;
1486 struct av7110
*av7110
= dvbdev
->priv
;
1487 int err
= dvb_generic_open(inode
, file
);
1489 dprintk(2, "av7110:%p, \n", av7110
);
1493 dvb_ringbuffer_flush_spinlock_wakeup(&av7110
->aout
);
1494 av7110
->audiostate
.stream_source
= AUDIO_SOURCE_DEMUX
;
1498 static int dvb_audio_release(struct inode
*inode
, struct file
*file
)
1500 struct dvb_device
*dvbdev
= file
->private_data
;
1501 struct av7110
*av7110
= dvbdev
->priv
;
1503 dprintk(2, "av7110:%p, \n", av7110
);
1505 av7110_av_stop(av7110
, RP_AUDIO
);
1506 return dvb_generic_release(inode
, file
);
1511 /******************************************************************************
1512 * driver registration
1513 ******************************************************************************/
1515 static const struct file_operations dvb_video_fops
= {
1516 .owner
= THIS_MODULE
,
1517 .write
= dvb_video_write
,
1518 .unlocked_ioctl
= dvb_generic_ioctl
,
1519 .open
= dvb_video_open
,
1520 .release
= dvb_video_release
,
1521 .poll
= dvb_video_poll
,
1524 static struct dvb_device dvbdev_video
= {
1527 .readers
= 5, /* arbitrary */
1529 .fops
= &dvb_video_fops
,
1530 .kernel_ioctl
= dvb_video_ioctl
,
1533 static const struct file_operations dvb_audio_fops
= {
1534 .owner
= THIS_MODULE
,
1535 .write
= dvb_audio_write
,
1536 .unlocked_ioctl
= dvb_generic_ioctl
,
1537 .open
= dvb_audio_open
,
1538 .release
= dvb_audio_release
,
1539 .poll
= dvb_audio_poll
,
1542 static struct dvb_device dvbdev_audio
= {
1546 .fops
= &dvb_audio_fops
,
1547 .kernel_ioctl
= dvb_audio_ioctl
,
1551 int av7110_av_register(struct av7110
*av7110
)
1553 av7110
->audiostate
.AV_sync_state
= 0;
1554 av7110
->audiostate
.mute_state
= 0;
1555 av7110
->audiostate
.play_state
= AUDIO_STOPPED
;
1556 av7110
->audiostate
.stream_source
= AUDIO_SOURCE_DEMUX
;
1557 av7110
->audiostate
.channel_select
= AUDIO_STEREO
;
1558 av7110
->audiostate
.bypass_mode
= 0;
1560 av7110
->videostate
.video_blank
= 0;
1561 av7110
->videostate
.play_state
= VIDEO_STOPPED
;
1562 av7110
->videostate
.stream_source
= VIDEO_SOURCE_DEMUX
;
1563 av7110
->videostate
.video_format
= VIDEO_FORMAT_4_3
;
1564 av7110
->videostate
.display_format
= VIDEO_LETTER_BOX
;
1565 av7110
->display_ar
= VIDEO_FORMAT_4_3
;
1566 av7110
->display_panscan
= VID_VC_AND_PS_PREF
;
1568 init_waitqueue_head(&av7110
->video_events
.wait_queue
);
1569 spin_lock_init(&av7110
->video_events
.lock
);
1570 av7110
->video_events
.eventw
= av7110
->video_events
.eventr
= 0;
1571 av7110
->video_events
.overflow
= 0;
1572 memset(&av7110
->video_size
, 0, sizeof (video_size_t
));
1574 dvb_register_device(&av7110
->dvb_adapter
, &av7110
->video_dev
,
1575 &dvbdev_video
, av7110
, DVB_DEVICE_VIDEO
);
1577 dvb_register_device(&av7110
->dvb_adapter
, &av7110
->audio_dev
,
1578 &dvbdev_audio
, av7110
, DVB_DEVICE_AUDIO
);
1583 void av7110_av_unregister(struct av7110
*av7110
)
1585 dvb_unregister_device(av7110
->audio_dev
);
1586 dvb_unregister_device(av7110
->video_dev
);
1589 int av7110_av_init(struct av7110
*av7110
)
1591 void (*play
[])(u8
*, int, void *) = { play_audio_cb
, play_video_cb
};
1594 for (i
= 0; i
< 2; i
++) {
1595 struct ipack
*ipack
= av7110
->ipack
+ i
;
1597 ret
= av7110_ipack_init(ipack
, IPACKS
, play
[i
]);
1600 av7110_ipack_free(--ipack
);
1603 ipack
->data
= av7110
;
1606 dvb_ringbuffer_init(&av7110
->avout
, av7110
->iobuf
, AVOUTLEN
);
1607 dvb_ringbuffer_init(&av7110
->aout
, av7110
->iobuf
+ AVOUTLEN
, AOUTLEN
);
1609 av7110
->kbuf
[0] = (u8
*)(av7110
->iobuf
+ AVOUTLEN
+ AOUTLEN
+ BMPLEN
);
1610 av7110
->kbuf
[1] = av7110
->kbuf
[0] + 2 * IPACKS
;
1615 void av7110_av_exit(struct av7110
*av7110
)
1617 av7110_ipack_free(&av7110
->ipack
[0]);
1618 av7110_ipack_free(&av7110
->ipack
[1]);