![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cvdv.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [DVB] / margi2|
Return to cvdv.c CVS log | Up to [DVB] / margi2 |
1.1 cvs 1: /*
2: cvdv.c
3:
1.13 mocm 4: Copyright (C) Christian Wolff
5: Marcus Metzler for convergence integrated media.
1.1 cvs 6:
7: This program is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 2 of the License, or
10: (at your option) any later version.
11:
12: This program is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with this program; if not, write to the Free Software
19: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20: */
21:
22: /////////////////////////////////////////////////////////////////////
23: // //
24: // Driver for the Convergence Digital Video decoder card (pci) //
25: // with L64017, L64021, PCM1723, and Bt864/Bt865 chipset //
26: // (c) Christian Wolff 19990209 for convergence integrated media //
27: // //
28: /////////////////////////////////////////////////////////////////////
29:
30: #define __NO_VERSION__
31:
1.24 mocm 32: //#include <linux/module.h>
1.1 cvs 33: #include "cvdv.h"
1.23 mocm 34: #include "ost/osd.h"
1.1 cvs 35: #include "i2c.h"
36:
37: //////////////////////
38: // global variables //
39: //////////////////////
40:
41: // Our major device number
42: unsigned int major_device_number;
43:
44:
45: // my little random function for memory test
1.12 mocm 46: uint16_t rnd_seed;
47: uint16_t rnd(uint16_t range)
1.1 cvs 48: { // returns random 0..(range-1) range<=872
1.12 mocm 49: uint32_t b = 75 * (rnd_seed + 1) - 1;
50: rnd_seed = (uint16_t) (b & 0xFFFF);
1.1 cvs 51: return ((b * range) / 0xFFFF) - ((b / 0xFFFF) * range);
52: }
53: void rnd_omize(void)
54: {
1.12 mocm 55: rnd_seed = (uint16_t) jiffies;
1.1 cvs 56: }
57:
1.5 mocm 58: static char *cimlogo[] = {
59: ".............................................",
60: ".............................................",
61: "......................###....................",
62: ".....................#####...................",
63: ".....................######..................",
64: "..............#......#####...................",
65: "...........#####....######...................",
66: ".........########...######...................",
67: "........########....######...................",
68: ".......#########...######....................",
69: "......########.....######...####.............",
70: ".....#######.......#####...#####.............",
71: ".....######.......######...######............",
72: "....#######.......######....######...........",
73: "....######........######....######...........",
74: "....#####........######......#####...........",
75: "...######........######......#####...........",
76: "...#####.........######......######..........",
77: "...#####.........#####.......######..........",
78: "...#####........######........#####..........",
79: "...#####........######.......######..........",
80: "...#####........#####.........#####..........",
81: "...#####.......######........######..........",
82: "...#####.......######........#####...........",
83: "...######.......####.........#####...........",
84: "....#####........##.........######...........",
85: "....######..................######...........",
86: "....######.................######............",
87: ".....#######..............######.....#####...",
88: ".....########............#######....#######..",
89: "......#########........########.....#######..",
90: ".......#######################......########.",
91: "........#####################.......#######..",
92: "..........#################.........#######..",
93: "............#############............#####...",
94: "...............#.#####.................##....",
95: ".............................................",
96: "............................................."
97: };
1.1 cvs 98:
99: /////////////////////////////////////////////
100: // //
101: // Controlling the L64021 MPEG-2 Decoder //
102: // //
103: /////////////////////////////////////////////
104:
105: int OSDTest(struct cvdv_cards *card)
106: {
1.5 mocm 107: int i, j, col, x0, y0, x1, y1,aspx;
1.12 mocm 108: uint8_t b;
1.5 mocm 109:
1.1 cvs 110:
111: if (!card->OSD.open)
112: return -2;
113:
114: OSDQuery(card, &x0, &y0, &x1, &y1, &aspx);
115: OSDShow(card);
1.5 mocm 116: OSDSetColor(card, 0, 0, 0, 0, 0, 0, 0);
117: OSDSetColor(card, 1, 128, 255, 255, 0, 0, 0);
118: for ( i = 0; i < cimlogo_width; i++){
119: for ( j = 0; j < cimlogo_height; j++){
120: b = cimlogo[j][i];
121: col = (b == '#') ? 1: 0;
122: OSDSetPixel(card, x0+i, y0+j, col);
1.1 cvs 123: }
124: }
125:
126: return 0;
127: }
128:
129:
130: void SetVideoSystem(struct cvdv_cards *card)
131: {
1.21 mocm 132: uint8_t reg;
133:
1.1 cvs 134: // set the hsync and vsync generators in the L64017 according to the video standard
1.21 mocm 135: reg = read_indexed_register(card, IIO_VIDEO_CONTROL1);
136: reg &= ~0x03;
1.1 cvs 137: switch (card->videomode) {
138: case PAL: // 864*625*50Hz = 27MHz, 25fps
139: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x41 | 0x0a);
140: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
141: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
142: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x96);
143: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x15);
144: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0x13);
145: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x54);
1.21 mocm 146: reg |= VMS_PAL;
1.1 cvs 147: break;
148: case PALN:
149: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0xa1 | 0x0a);
150: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
151: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
152: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x96);
153: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x15);
154: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0x13);
155: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x54);
1.21 mocm 156: reg |= VMS_PAL;
1.1 cvs 157: break;
158:
159: case PALNc:
160: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x81 | 0x0a);
161: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
162: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
163: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x8c);
164: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x28);
165: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xed);
166: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
1.21 mocm 167: reg |= VMS_PAL;
1.1 cvs 168: break;
169:
170: case NTSC: // 858*525*59.94006Hz = 27MHz, 29.97fps
171: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x01 | 0x0a);
172: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
173: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x1c);
174: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x3e);
175: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0xf8);
176: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xe0);
177: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
1.21 mocm 178: reg |= VMS_NTSC;
1.1 cvs 179: break;
180:
181: case PALM:
182: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x01 | 0x0a);
183: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
184: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
185: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x4e);
186: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x4a);
187: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xe1);
188: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
1.21 mocm 189: reg |= VMS_PAL;
1.1 cvs 190: break;
191:
192: case NTSC60: // 857*525*60.010002Hz = 27MHz, 30fps
193: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x21 | 0x0a);
194: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
195: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x1c);
196: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x3e);
197: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0xf8);
198: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xe0);
199: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
1.21 mocm 200: reg |= VMS_NTSC;
1.1 cvs 201: break;
202:
203: case PALM60:
204: I2CWrite(card, card->i2c_addr, CS_CONTROL0, 0x61 | 0x0a);
205: I2CWrite(card, card->i2c_addr, CS_CONTROL1, 0x04);
206: I2CWrite(card, card->i2c_addr, CS_SC_AMP, 0x15);
207: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH0, 0x4e);
208: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH1, 0x4a);
209: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH2, 0xe1);
210: I2CWrite(card, card->i2c_addr, CS_SC_SYNTH3, 0x43);
1.21 mocm 211: reg |= VMS_PAL;
1.1 cvs 212: break;
213:
214: case PAL60:
215: break;
216: }
1.21 mocm 217: write_indexed_register(card, IIO_VIDEO_CONTROL1, reg);
1.1 cvs 218: // set the pixel generators according to the video standard
219: L64021Setup(card);
220: }
221:
1.12 mocm 222: int SetVideoAttr(struct cvdv_cards *card, uint16_t vattr)
1.1 cvs 223: {
1.12 mocm 224: uint8_t video_compression_mode;
225: uint8_t tv_system;
226: uint8_t aspect_ratio;
227: uint8_t display_mode;
228: uint8_t line_21_switch_1;
229: uint8_t line_21_switch_2;
230: uint8_t source_picture_resolution;
231: uint8_t source_picture_letterboxed;
232: uint8_t reserved;
233: uint8_t film_camera_mode;
234: uint16_t hsize, vsize;
1.1 cvs 235: if (vattr != card->lastvattr) {
236: video_compression_mode = (vattr >> 14) & 0x03;
237: tv_system = (vattr >> 12) & 0x03;
238: aspect_ratio = (vattr >> 10) & 0x03;
239: display_mode = (vattr >> 8) & 0x03;
240: line_21_switch_1 = (vattr >> 7) & 0x01;
241: line_21_switch_2 = (vattr >> 6) & 0x01;
242: source_picture_resolution = (vattr >> 3) & 0x07;
243: source_picture_letterboxed = (vattr >> 2) & 0x01;
244: reserved = (vattr >> 1) & 0x01;
245: film_camera_mode = (vattr >> 0) & 0x01;
246: card->videomode =
247: ((tv_system == 0) ? NTSC : ((tv_system == 1) ?
248: PAL : PAL));
249: SetVideoSystem(card);
250: hsize =
251: ((source_picture_resolution == 0) ? 720
252: : ((source_picture_resolution == 1) ? 702 : 352));
253: vsize = ((source_picture_resolution == 3)
254: ? ((tv_system == 0) ? 240 : 288)
255: : ((tv_system == 0) ? 480 : 576));
256: if (DecoderOpen
257: (card, hsize, vsize, ((aspect_ratio) ? 3 : 2),
258: ((video_compression_mode) ? 0 : 1),
259: source_picture_letterboxed, tv_system)) {
1.14 mocm 260: MDEBUG(0,
1.1 cvs 261: ": Video Decoder Open failed: On-card memory insufficient for frame stores\n");
262: }
263: card->lastvattr = vattr;
264: } else {
1.14 mocm 265: MDEBUG(0,
1.1 cvs 266: ": Video attribute not set, equal to previous one.\n");
267: }
268: return 0;
269: }
270:
1.12 mocm 271: int SetAudioAttr(struct cvdv_cards *card, uint16_t aattr)
1.1 cvs 272: {
1.12 mocm 273: uint8_t audio_coding_mode;
274: uint8_t multichannel_extension;
275: uint8_t audio_type;
276: uint8_t audio_application_mode;
277: uint8_t quantization_drc;
278: uint8_t fs;
279: uint8_t reserved;
280: uint8_t num_audio_ch;
1.1 cvs 281: if (aattr) {
282: if (aattr != card->lastaattr) {
283: audio_coding_mode = (aattr >> 13) & 0x07;
284: multichannel_extension = (aattr >> 12) & 0x01;
285: audio_type = (aattr >> 10) & 0x03;
286: audio_application_mode = (aattr >> 8) & 0x03;
287: quantization_drc = (aattr >> 6) & 0x03;
288: fs = (aattr >> 4) & 0x03;
289: reserved = (aattr >> 3) & 0x01;
290: num_audio_ch = (aattr >> 0) & 0x07;
291: switch (audio_coding_mode) {
292: case 0: // AC-3
293: card->setup.audioselect = audio_AC3;
294: break;
295: case 2: // MPEG Audio
296: card->setup.audioselect = audio_MPEG;
297: break;
298: case 3: // MPEG Audio with ext.
299: card->setup.audioselect = audio_MPEG_EXT;
300: break;
301: case 4: // Linear Pulse Code Modulation LPCM
302: card->setup.audioselect = audio_LPCM;
303: break;
304: case 6: // DTS
305: card->setup.audioselect = audio_DTS;
306: break;
307: case 7: // SDDS
308: card->setup.audioselect = audio_SDDS;
309: break;
310: }
311: DecoderPrepareAudio(card);
312: AudioInit(card, ((fs) ? 96 : 48),
313: ((audio_application_mode == 2) ? 1 : 0));
314: } else {
1.14 mocm 315: MDEBUG(0,
1.1 cvs 316: ": Audio attribute not set, equal to previous one.\n");
317: }
318: } else {
319: card->setup.audioselect = audio_none;
320: DecoderPrepareAudio(card);
321: }
322: card->lastaattr = aattr;
323: return 0;
324: }
325:
326: int Prepare(struct cvdv_cards *card)
327: {
328: int err, h;
329: struct StreamSetup *setup = &card->setup;
330:
331: if (!card->ChannelBuffersAllocated) {
332:
333: DecoderStreamReset(card);
334: if (setup->streamtype == stream_none) {
335: setup->streamtype = stream_PS;
336: }
337:
338: if (setup->audioselect == audio_none) {
339: setup->audioselect = audio_MPEG;
340: }
341:
342: DecoderPrepareAudio(card);
343: AudioMute(card, 1);
344: DecoderPrepareVideo(card);
345: VideoSetBackground(card, 1, 0, 0, 0); // black
346:
347: switch (setup->streamtype) {
348: default:
349: case stream_none: // unknown stream!
1.14 mocm 350: MDEBUG(0,
1.1 cvs 351: ": Video Decoder Prepare failed: unknown stream type\n");
352: return -ENODEV; // not an MPEG stream!
353: case stream_ES: // Elementary Stream
354: err = DecoderPrepareES(card);
355: break;
356: case stream_PES: // Packetized Elementary Stream
357: err = DecoderPreparePES(card);
358: break;
359: case stream_PS: // MPEG-1 System Stream / MPEG-2 Program Stream
360: err = DecoderPreparePS(card, -1, 0, 0, 0, 0, 0);
361: break;
362: case stream_DVD: // DVD Stream
363: err = DecoderPreparePS(card, 0, 0, 0, 0, 3, 1);
364: break;
365: }
366: if (err) { // insufficient memory
1.14 mocm 367: MDEBUG(0,
1.1 cvs 368: ": Video Decoder Prepare failed: no kernel memory, please reboot if possible\n");
369: CloseCard(card);
370: return -ENODEV;
371: }
372: }
373:
374: // Set up the Video Decoder as we have the stream information
375: if ((!card->FrameBuffersAllocated)
376: && (card->ChannelBuffersAllocated) && (card->stream.sh.valid)) {
377: // Automatic PAL/NTSC-switch according to MPEG-Source
378: h = card->stream.vsize;
379: if (h < 480)
380: h *= 2; // catch quarter sized images
381: printk(KERN_INFO LOGNAME ": Video mode: %s\n",
382: ((h == 480) ? "NTSC" : "PAL"));
383: card->videomode = ((h == 480) ? NTSC : PAL);
384: SetVideoSystem(card);
385: // Open the Video Decoder with the parameters retreived from the stream
386: if (
387: (err =
388: DecoderOpen(card, card->stream.hsize,
389: card->stream.vsize,
390: card->stream.sh.aspectratio,
391: !card->stream.MPEG2, 0,
1.2 rjkm 392: (card->stream.hsize > 480)))) { // TODO: include vbvbuffersize
1.14 mocm 393: MDEBUG(0,
1.1 cvs 394: ": Video Decoder Open failed: %s\n",
395: ((err == 1) ?
396: "Picture size too big (>1440 pixel wide)" :
397: "On-card memory insufficient for frame stores"));
398: CloseCard(card);
399: return -ENODEV; // picture too big or insufficient memory
400: }
1.14 mocm 401: MDEBUG(1, ": Ready to go\n");
1.1 cvs 402: card->startingV = 1; // tell the card to start playing as soon as ES-buffers are sufficiently full
403: card->startingA = 1; // tell the card to start playing as soon as ES-buffers are sufficiently full
404: }
405:
406:
407: return 0;
408: }
409:
1.12 mocm 410: int SetSCRstart(struct cvdv_cards *card, uint32_t SCR_base)
1.1 cvs 411: {
1.12 mocm 412: uint32_t SCR_compare;
413: uint32_t SCR_compareA;
414: uint32_t SCR_compareV;
1.1 cvs 415: if (card->startingV) {
1.14 mocm 416: MDEBUG(0, ": SCR in DVD Pack: 0x%08X\n",
1.1 cvs 417: SCR_base);
418: card->startingV = 0;
419: card->startingA = 0;
420: DecoderMaskByte(card, 0x007, 0xD2, 0xD2); // Set 0x010, halt SCR counter
421: SCR_compare = SCR_base + 000;
422: if (SCR_base < 900)
423: SCR_base = 0;
424: else
425: SCR_base -= 900;
426: //DecoderWriteDWord(card,0x009,SCR_base); // Set SCR counter
427: DecoderWriteByte(card, 0x009, SCR_base & 0xFF); // Set SCR counter
428: DecoderWriteByte(card, 0x00A, (SCR_base >> 8) & 0xFF);
429: DecoderWriteByte(card, 0x00B, (SCR_base >> 16) & 0xFF);
430: DecoderWriteByte(card, 0x00C, (SCR_base >> 24) & 0xFF);
431: DecoderMaskByte(card, 0x011, 0x03, 0x02); // compare, not capture
1.14 mocm 432: MDEBUG(0, ": SCR compare value: 0x%08X\n",
1.1 cvs 433: SCR_compare);
434: //DecoderWriteDWord(card,0x00D,SCR_compare); // Set Compare register
435: DecoderWriteByte(card, 0x00D, SCR_compare & 0xFF); // Set Compare register
436: DecoderWriteByte(card, 0x00E, (SCR_compare >> 8) & 0xFF);
437: DecoderWriteByte(card, 0x00F, (SCR_compare >> 16) & 0xFF);
438: DecoderWriteByte(card, 0x010, (SCR_compare >> 24) & 0xFF);
439: //DecoderWriteDWord(card,0x014,SCR_compare); // Set audio compare reg.
440: DecoderWriteByte(card, 0x014, SCR_compare & 0xFF); // Set audio compare reg.
441: DecoderWriteByte(card, 0x015, (SCR_compare >> 8) & 0xFF);
442: DecoderWriteByte(card, 0x016, (SCR_compare >> 16) & 0xFF);
443: DecoderWriteByte(card, 0x017, (SCR_compare >> 24) & 0xFF);
444: DecoderSetByte(card, 0x013, 0x03); // Video and Audio start on cmp.
445: //DecoderSetVideoPanic(card,0,DecoderGetVideoESSize(card)/4); // video panic at 25 percent
446: VideoSetBackground(card, 1, 0, 0, 0); // black
447: SCR_base = DecoderReadByte(card, 0x009);
448: SCR_base =
1.12 mocm 449: SCR_base | ((uint32_t) DecoderReadByte(card, 0x00A) << 8);
1.1 cvs 450: SCR_base =
1.12 mocm 451: SCR_base | ((uint32_t) DecoderReadByte(card, 0x00B) << 16);
1.1 cvs 452: SCR_base =
1.12 mocm 453: SCR_base | ((uint32_t) DecoderReadByte(card, 0x00C) << 24);
1.1 cvs 454: SCR_compareA = DecoderReadByte(card, 0x014);
455: SCR_compareA =
1.12 mocm 456: SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x015) <<
1.1 cvs 457: 8);
458: SCR_compareA =
1.12 mocm 459: SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x016) <<
1.1 cvs 460: 16);
461: SCR_compareA =
1.12 mocm 462: SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x017) <<
1.1 cvs 463: 24);
464: SCR_compareV = DecoderReadByte(card, 0x00D);
465: SCR_compareV =
1.12 mocm 466: SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x00E) <<
1.1 cvs 467: 8);
468: SCR_compareV =
1.12 mocm 469: SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x00F) <<
1.1 cvs 470: 16);
471: SCR_compareV =
1.12 mocm 472: SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x010) <<
1.1 cvs 473: 24);
474: if (DecoderReadByte(card, 0x013) & 0x03)
1.14 mocm 475: MDEBUG(1,": SCR 0x%08X, videocmp=0x%08X, audiocmp=0x%08X %02X\n",
1.1 cvs 476: SCR_base, SCR_compareV, SCR_compareA,
477: DecoderReadByte(card, 0x013));
478: DecoderMaskByte(card, 0x007, 0xD2, 0xC2); // Del 0x010, SCR counter run
479: }
480: return 0;
481: }
482:
1.12 mocm 483: int DecoderWriteBlock(struct cvdv_cards *card, uint8_t * data, int size,
1.1 cvs 484: int initial, int setSCR)
485: {
486: //int a,v,as,vs,ap,vp;
487: int res;
1.12 mocm 488: uint32_t SCR_base;
1.1 cvs 489: int co = 0;
1.12 mocm 490: // uint32_t SCR_compare;
1.1 cvs 491: res = 0;
1.6 mocm 492:
493: Prepare(card);
1.1 cvs 494:
495: if (size > 0) {
496:
1.14 mocm 497: if (!card->use_ringA)
1.17 mocm 498: MargiSetBuffers(card, NBBUF*CHANNELBUFFERSIZE,0);
1.1 cvs 499:
500: if (card->startingDVDV || card->startingDVDA)
501: setSCR = 1;
502:
503: if (initial) {
504: DecoderStreamReset(card);
505: //TODO stop and start channel interface
506: setSCR = 1;
507: }
508:
509: if (setSCR) {
510: SCR_base = ParseSCR(data);
511: SetSCR(card, SCR_base);
512: }
1.6 mocm 513: card->DMAABusy = 0;
1.14 mocm 514: while (((res = MargiPushA(card, size, data)) < size)
1.6 mocm 515: && co < 1000) {
1.1 cvs 516: data+=res;
517: size-=res;
518: co++;
1.14 mocm 519: MDEBUG(2,
520: ": DecoderWriteBlock - buffers only filled with %d instead of %d bytes\n",res, size);
1.10 mocm 521: if (card->DMAABusy){
1.1 cvs 522: interruptible_sleep_on(&card->wqA);
1.10 mocm 523: }
1.1 cvs 524: }
525:
526: if (card->startingDVDV) {
527: card->startingDVDV = 0;
1.6 mocm 528: card->startingV = 1;
1.1 cvs 529: DecoderStartDecode(card);
530: }
531: if (card->startingDVDA) {
532: card->startingDVDA = 0;
1.6 mocm 533: card->startingA = 1;
534: AudioSetPlayMode(card, MAUDIO_PLAY);
1.1 cvs 535: }
536: }
537: return 0;
538: }
539:
540:
541:
542:
543:
544: //////////////////////////////
545: // //
546: // Char Device Procedures //
547: // //
548: //////////////////////////////
1.11 mocm 549: static long margi_write(struct cvdv_cards *card, const char *data,
1.6 mocm 550: unsigned long count, int nonblock)
1.1 cvs 551: {
1.11 mocm 552:
1.1 cvs 553: int res;
1.10 mocm 554: long int out=0;
1.17 mocm 555: int free;
556:
557: free = ring_write_rest(&(card->rbufA));
1.10 mocm 558:
1.1 cvs 559: if (card != NULL) {
1.21 mocm 560: card->nonblock = nonblock;
1.1 cvs 561: if (count > 0) { // Do we have data?
562: if ((res = Prepare(card)))
563: return res;
1.17 mocm 564: if (!card->use_ringA)
565: MargiSetBuffers(card, NBBUF*CHANNELBUFFERSIZE,
566: 0);
567: if (!nonblock &&
1.21 mocm 568: !wait_event_interruptible(
569: card->wqA,
570: ring_write_rest(&(card->rbufA)) >count )){
571:
1.17 mocm 572: out = MargiPushA(card, count,
573: data);
574: } else {
575: out = MargiPushA(card, count, data);
1.14 mocm 576: }
577: }
578: return out;
579: } else {
580: MDEBUG(0,
581: ": Video Decoder Prepare failed: device with this minor number not found\n");
582: return -ENODEV; // device with this minor number not found
583: }
584: }
585:
1.17 mocm 586:
1.14 mocm 587: static long margi_write_audio(struct cvdv_cards *card, const char *data,
588: unsigned long count, int nonblock)
589: {
590: struct StreamSetup *setup = &card->setup;
1.1 cvs 591:
1.14 mocm 592: int res;
593: long int out=0;
1.17 mocm 594: int free;
595:
596: free = ring_write_rest(&(card->rbufB));
1.1 cvs 597:
1.14 mocm 598: if (card != NULL) {
1.21 mocm 599: card->nonblock = nonblock;
600:
1.14 mocm 601: if (count > 0) { // Do we have data?
602: if ((res = Prepare(card)))
603: return res;
604: if ((setup->streamtype == stream_ES)
1.17 mocm 605: || (setup->streamtype == stream_PES)){
1.14 mocm 606: if (!card->use_ringB)
1.17 mocm 607: MargiSetBuffers(card, NBBUF*
608: CHANNELBUFFERSIZE,1);
609: if (!nonblock &&
1.21 mocm 610: !wait_event_interruptible(
611: card->wqB,
612: ring_write_rest(&(card->rbufB))
613: > count)){
1.17 mocm 614: out = MargiPushB(card, count,
615: data);
616: } else {
1.14 mocm 617: out = MargiPushB(card, count, data);
618: }
1.1 cvs 619: }
620: }
1.10 mocm 621: return out;
1.1 cvs 622: } else {
1.14 mocm 623: MDEBUG(0,
1.1 cvs 624: ": Video Decoder Prepare failed: device with this minor number not found\n");
625: return -ENODEV; // device with this minor number not found
626: }
1.6 mocm 627: }
628:
1.12 mocm 629: void pes_write(uint8_t *buf, int count, void *priv)
630: {
631: struct cvdv_cards *card = (struct cvdv_cards *) priv;
1.14 mocm 632:
633: margi_write(card, buf, count, 0);
1.12 mocm 634: }
635:
1.6 mocm 636:
637: static ssize_t PSwrite(struct file *file, const char *data, size_t count,
638: loff_t * offset)
639: {
640: struct cvdv_cards *card =
641: minorlist[MINOR(file->f_dentry->d_inode->i_rdev) % MAXDEV]; // minor number modulo 16
1.17 mocm 642: return margi_write(card, data, count, file->f_flags&O_NONBLOCK);
1.1 cvs 643: }
644:
645: static unsigned int PSpoll(struct file *file, poll_table * table)
646: {
647: struct cvdv_cards *card =
648: minorlist[MINOR(file->f_dentry->d_inode->i_rdev) % MAXDEV]; // minor number modulo 16
649: if (card != NULL) {
1.9 mocm 650: poll_wait(file, &card->wqA , table);
1.14 mocm 651: if ( !card->rbufA.buffy || ring_write_rest(&(card->rbufA)) )
652: return (POLLOUT | POLLWRNORM);
653: else {
654: return 0;
655: }
1.1 cvs 656: } else
1.8 mocm 657: return POLLERR;
1.1 cvs 658: }
659:
1.17 mocm 660: static unsigned int poll_audio(struct file *file, poll_table * table)
661: {
662: struct cvdv_cards *card =
663: minorlist[MINOR(file->f_dentry->d_inode->i_rdev) % MAXDEV]; // minor number modulo 16
664: if (card != NULL) {
665: poll_wait(file, &card->wqB, table);
666: if ( !card->rbufB.buffy || ring_write_rest(&(card->rbufB)) )
667: return (POLLOUT | POLLWRNORM);
668: else {
669: return 0;
670: }
671: } else
672: return POLLERR;
673: }
674:
1.13 mocm 675: static int
676: OSD_DrawCommand(struct cvdv_cards *card,osd_cmd_t *dc)
677: {
678:
679: switch (dc->cmd) {
680: case OSD_Close:
1.14 mocm 681: MDEBUG(1,": OSD Close\n");
1.13 mocm 682: return OSDClose(card);
683: case OSD_Open: // Open(x0,y0,x1,y1,BitPerPixel(2/4/8),mix(0..15))
684: return OSDOpen(card, dc->x0,
685: dc->y0, dc->x1,
686: dc->y1,
687: dc->color & 0x0F,
688: (dc->color >> 4) &
689: 0x0F);
690: case OSD_Show:
691: return OSDShow(card);
692: case OSD_Hide:
693: return OSDHide(card);
694: case OSD_Clear:
695: return OSDClear(card);
696: case OSD_Fill: // Fill(color)
697: return OSDFill(card, dc->color);
698: case OSD_SetColor: // SetColor(color,R(x0),G(y0),B(x1),opacity(y1))
699: return (OSDSetColor
700: (card, dc->color, dc->x0,
701: dc->y0, dc->x1, 0,
702: (dc->y1 != 255),
703: (dc->y1 == 0)) >= 0);
704: case OSD_SetPalette:// SetPalette(firstcolor{color},lastcolor{x0},data)
705: return OSDSetPalette(card,
706: dc->color,
707: dc->x0, (uint8_t *)
708: dc->data);
709: case OSD_SetTrans: // SetTrans(transparency{color})
710: return OSDSetTrans(card,
711: (dc->color >> 4)
712: & 0x0F);
713: case OSD_SetPixel: // SetPixel(x0,y0,color)
714: return OSDSetPixel(card, dc->x0,
715: dc->y0,
716: dc->color);
717: case OSD_GetPixel: // GetPixel(x0,y0);
718: return OSDGetPixel(card, dc->x0,
719: dc->y0);
720: case OSD_SetRow: // SetRow(x0,y0,x1,(uint8_t*)data)
721: return OSDSetRow(card, dc->x0,
722: dc->y0, dc->x1,
723: (uint8_t *) dc->data);
724: case OSD_SetBlock: // SetBlock(x0,y0,x1,y1,(uint8_t*)data)
725: return OSDSetBlock(card, dc->x0,
726: dc->y0, dc->x1,
727: dc->y1,
728: dc->color,
729: (uint8_t *)
730: dc->data);
731: case OSD_FillRow: // FillRow(x0,y0,x1,color)
732: return OSDFillRow(card, dc->x0,
733: dc->y0, dc->x1,
734: dc->color);
735: case OSD_FillBlock: // FillRow(x0,y0,x1,y1,color)
736: return OSDFillBlock(card, dc->x0,
737: dc->y0, dc->x1,
738: dc->y1,
739: dc->color);
740: case OSD_Line: // Line(x0,y0,x1,y1,color);
741: return OSDLine(card, dc->x0,
742: dc->y0, dc->x1,
743: dc->y1, dc->color);
744: case OSD_Query: // Query(x0,y0,x1,y1,aspect(color:11)
745: return OSDQuery(card, &dc->x0,
746: &dc->y0, &dc->x1,
747: &dc->y1,
748: &dc->color);
749: case OSD_Test:
750: return OSDTest(card);
751: default:
752: return -EINVAL;
753: }
754: }
755:
1.6 mocm 756:
1.1 cvs 757: static int PSioctl(struct inode *inode, struct file *file,
758: unsigned int cmd, unsigned long arg)
759: {
760: struct cvdv_cards *card = minorlist[MINOR(inode->i_rdev) % MAXDEV]; // minor number modulo 16
1.13 mocm 761: osd_cmd_t *dc;
1.1 cvs 762: struct decodercmd *command;
1.12 mocm 763: uint16_t attr;
1.10 mocm 764:
1.1 cvs 765: if (card != NULL) {
766: if (_IOC_TYPE(cmd) == CVDV_IOCTL_MAGIC)
767: switch (_IOC_NR(cmd)) {
768: case IOCTL_DRAW: // Drawing commands
1.13 mocm 769: dc = (osd_cmd_t *) arg;
770: return OSD_DrawCommand(card,dc);
771: break;
1.1 cvs 772: case IOCTL_DECODER:
773: command = (struct decodercmd *) arg;
774: switch (command->cmd) {
1.10 mocm 775:
776: case Decoder_CSS:
1.1 cvs 777: /*
778: return DecoderCSS(card,
779: command->param1,
780: command->data1);
781: */
1.10 mocm 782: break;
783:
1.1 cvs 784: case Decoder_Set_Videosystem:
1.14 mocm 785: MDEBUG(1,": -- Decoder_Set_Videosystem\n");
1.1 cvs 786: card->videomode =
787: (videosystem) command->param1;
788: SetVideoSystem(card);
789: return 0;
1.10 mocm 790: break;
791:
1.1 cvs 792: case Decoder_Set_Streamtype:
1.14 mocm 793: MDEBUG(1,": -- Decoder_Set_Streamtype\n");
1.1 cvs 794: card->setup.streamtype =
795: (stream_type) command->param1;
796: return 0;
1.10 mocm 797: break;
798:
1.1 cvs 799: case Decoder_Set_Audiotype:
1.14 mocm 800: MDEBUG(1,": -- Decoder_Set_Audiotype\n");
1.1 cvs 801: card->setup.audioselect =
802: (audio_type) command->param1;
803: DecoderPrepareAudio(card);
804: return 0;
1.10 mocm 805: break;
806:
1.1 cvs 807: case Decoder_Set_VideoStreamID:
1.14 mocm 808: MDEBUG(1,": -- Decoder_Set_VideoStreamID\n");
1.1 cvs 809: card->setup.videoID =
810: command->param1;
811: DecoderPrepareVideo(card);
812: return 0;
1.10 mocm 813: break;
814:
1.1 cvs 815: case Decoder_Set_AudioStreamID:
1.14 mocm 816: MDEBUG(1,": -- Decoder_Set_AudioStreamID 0x%02X 0x%02X\n",
817: command->param1,command->param2);
1.1 cvs 818: card->setup.audioID =
819: command->param1;
820: card->setup.audioIDext =
821: command->param2;
822: attr = card->lastaattr;
823: DecoderSelectAudioID(card);
824: card->lastaattr = attr;
825: return 0;
1.10 mocm 826: break;
827:
1.1 cvs 828: case Decoder_Still_Put:
829: return DecoderShowStill(card,
830: command->
831: param1,
832: command->
833: param2,
834: command->
835: data1,
836: command->
837: data2);
1.10 mocm 838: break;
839:
1.1 cvs 840: case Decoder_Still_Get:
841: return DecoderGetStill(card,
842: &command->
843: param1,
844: &command->
845: param2,
846: command->
847: data1,
848: command->
849: data2);
1.10 mocm 850: break;
851:
1.1 cvs 852: case Decoder_Pause: // pause{param1} 0=run 1=pause 2=toggle
853: if (command->param1 == 2) {
854: if (card->paused)
855: DecoderUnPause
856: (card);
857: else
858: DecoderPause(card);
859: } else {
860: if (!command->param1)
861: DecoderUnPause
862: (card);
863: else
864: DecoderPause(card);
865: }
866: return 0;
1.10 mocm 867:
868: /* Too buggy
869: case Decoder_FFWD: // pause{param1} =normal 1=ffwd 2=toggle
870: if (command->param1 == 2) {
871: if (card->videoffwd)
872: card->videoffwd = 0;
873: else
1.13 mocm 874: card->videoffwd = 3;
1.10 mocm 875: } else {
876: if (!command->param1)
877: card->videoffwd = 0;
878: else
1.13 mocm 879: card->videoffwd = 3;
1.10 mocm 880: }
881: return 0;
882:
883: case Decoder_Slow: // pause{param1} =normal 1=slow 2=toggle
884: if (command->param1 == 2) {
885: if (card->videoslow)
886: card->videoslow = 0;
887: else
888: card->videoslow = 4;
889: } else {
890: if (!command->param1)
891: card->videoslow = 0;
892: else
893: card->videoslow = 4;
894: }
895: return 0;
896: */
1.1 cvs 897: case Decoder_Highlight: // active{param1}, color information(SL_COLI or AC_COLI){data1[4]}, button position(BTN_POSI){data2[6]}
898: return DecoderHighlight(card,
899: command->
900: param1,
901: command->
902: data1,
903: command->
904: data2);
905: case Decoder_SPU: // stream{param1}, active{param2}
906: return DecoderSPUStream(card,
907: command->
908: param1,
909: command->
910: param2);
911: case Decoder_SPU_Palette: // length{param1}, palette{data1}
912: return DecoderSPUPalette(card,
913: command->
914: param1,
915: command->
916: data1);
917: case Decoder_GetNavi: // data1 will be filled with PCI or DSI pack, and 1024 will be returned
918: return DecoderGetNavi(card,
919: command->
920: data1);
921: case Decoder_SetKaraoke: // Vocal1{param1}, Vocal2{param2}, Melody{param3}
922: return DecoderKaraoke(card,
923: command->
924: param1,
925: command->
926: param2,
927: command->
928: param3);
929: case Decoder_Set_Videoattribute:
1.14 mocm 930: MDEBUG(1,": -- Decoder_Set_Videoattribute\n");
1.1 cvs 931: if (!card->ChannelBuffersAllocated) {
932: DecoderStreamReset(card);
933: MargiFlush(card);
934:
935: card->setup.streamtype =
936: stream_DVD;
937: card->setup.videoID = 0;
938: DecoderPrepareVideo(card);
939: DecoderPreparePS(card, 0,
940: 0, 2, 2,
941: 3, 1);
942: }
943:
944: SetVideoAttr(card,
945: command->param1);
1.6 mocm 946: card->startingDVDV = 1;
947: // tell the card to start playing as soon as ES-buffers are sufficiently full
1.1 cvs 948: return 0;
949: case Decoder_Set_Audioattribute:
1.14 mocm 950: MDEBUG(1,": -- Decoder_Set_Audioattribute\n");
1.1 cvs 951: SetAudioAttr(card,
952: command->param1);
953: card->startingDVDA =
954: ((card->setup.audioselect !=
955: audio_none)
956: && (card->setup.audioselect != audio_disable)); // tell the card to start playing as soon as ES-buffers are sufficiently full
957: return 0;
958: case Decoder_WriteBlock: // DVD-Sector{data1}, sectorsize{param1{2048}}, initialsector{param2{bool}}, set_SCR{param3}
959: return DecoderWriteBlock(card,
960: command->
961: data1,
962: command->
963: param1,
964: command->
965: param2,
966: command->
967: param3);
968: default:
969: return -EINVAL;
970: }
971: default:
972: return -EINVAL;
973: } else
974: return -EINVAL;
975: } else {
1.14 mocm 976: MDEBUG(0,
1.1 cvs 977: ": Video Decoder Prepare failed: device with this minor number not found\n");
978: return -ENODEV; // device with this minor number not found
979: }
980: }
981:
1.6 mocm 982:
1.1 cvs 983: static int PSmmap(struct file *file, struct vm_area_struct *vm)
984: {
985: return -ENODEV;
986: }
987:
1.6 mocm 988:
989:
1.11 mocm 990: static int margi_open(struct cvdv_cards *card, int flags)
1.1 cvs 991: {
1.6 mocm 992: int closed;
1.1 cvs 993: if (card != NULL) {
1.14 mocm 994: MDEBUG(1, ": -- open \n");
1.1 cvs 995: CloseCard(card);
1.5 mocm 996: OSDClose(card);
1.6 mocm 997: #ifdef NOINT
998: card->timer.function = Timerfunction;
999: card->timer.data=(unsigned long) card;
1000: card->timer.expires=jiffies+1;
1001: add_timer(&card->timer);
1002: #endif
1003:
1004: if (card->open)
1.14 mocm 1005: MDEBUG(0,": PSopen - already open\n");
1.1 cvs 1006: closed = 1;
1.6 mocm 1007: if (card->open)
1008: closed = 0;
1.1 cvs 1009: if (closed) { // first open() for this card?
1.19 mocm 1010: MargiFreeBuffers(card);
1.1 cvs 1011: VideoSetBackground(card, 1, 0, 0, 0); // black
1012: }
1.6 mocm 1013: card->open++;
1.11 mocm 1014: MOD_INC_USE_COUNT;
1.1 cvs 1015: return 0;
1016: } else {
1.14 mocm 1017: MDEBUG(0,
1.1 cvs 1018: ": Video Decoder Prepare failed: device with this minor number not found\n");
1019: return -ENODEV; // device with this minor number not found
1020: }
1.6 mocm 1021:
1.1 cvs 1022: }
1023:
1.6 mocm 1024:
1025: static int PSopen(struct inode *inode, struct file *file)
1.1 cvs 1026: {
1.11 mocm 1027: struct cvdv_cards *card = minorlist[MINOR(inode->i_rdev) % MAXDEV];
1.15 mocm 1028: card->audiostate.AVSyncState=true;
1.17 mocm 1029: return margi_open(card, file->f_flags);
1.6 mocm 1030: }
1031:
1032:
1.11 mocm 1033: static int all_margi_close(struct cvdv_cards *card)
1.6 mocm 1034: {
1.11 mocm 1035:
1.1 cvs 1036: if (card != NULL) {
1.14 mocm 1037: MDEBUG(1, ": -- PSrelease\n");
1.11 mocm 1038: if (card->open <= 0)
1.14 mocm 1039: MDEBUG(1,": PSrelease - not open\n");
1.6 mocm 1040: card->open--;
1.4 mocm 1041:
1.11 mocm 1042: MOD_DEC_USE_COUNT;
1.6 mocm 1043: if (!card->open) {
1.14 mocm 1044: MDEBUG(1,": PSrelease - last close\n");
1.11 mocm 1045: CloseCard(card); // close immediately
1.1 cvs 1046: }
1047: return 0;
1048: } else {
1.14 mocm 1049: MDEBUG(0,": Video Decoder Prepare failed:\n");
1.1 cvs 1050: return -ENODEV; // device with this minor number not found
1051: }
1.6 mocm 1052:
1053: }
1054:
1055: static int PSrelease(struct inode *inode, struct file *file)
1056: {
1057: struct cvdv_cards *card = minorlist[MINOR(inode->i_rdev) % MAXDEV]; // minor number modulo 16
1.11 mocm 1058: return all_margi_close(card);
1.1 cvs 1059: }
1060:
1061: //////////////////////////
1062: // //
1063: // Char Device Hookup //
1064: // //
1065: //////////////////////////
1066:
1067: // Hookups for a write-only device, that accepts MPEG-2 Program Stream
1068: struct file_operations cvdv_fileops = {
1069: write: PSwrite,
1070: poll: PSpoll,
1071: ioctl: PSioctl,
1072: mmap: PSmmap,
1073: open: PSopen,
1074: release: PSrelease,
1075: };
1.6 mocm 1076:
1077:
1078: #ifdef DVB
1079:
1080: static inline int
1081: num2type(struct cvdv_cards *card, int num)
1082: {
1083: if (!card->dvb_devs)
1084: return -2;
1085: if (num>=card->dvb_devs->num)
1086: return -2;
1087: return card->dvb_devs->tab[num];
1088: }
1089:
1090: static int
1091: dvbdev_open(struct dvb_device *dvbdev, int num,
1092: struct inode *inode, struct file *file)
1093: {
1094: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1095: int type=num2type(card, num);
1096: int ret=0;
1097:
1098: if (type<0)
1099: return -EINVAL;
1100:
1101: if (card->users[num] >= card->dvb_devs->max_users[num])
1102: return -EBUSY;
1103:
1104: if ((file->f_flags&O_ACCMODE)!=O_RDONLY)
1105: if (card->writers[num] >= card->dvb_devs->max_writers[num])
1106: return -EBUSY;
1107:
1108: switch (type) {
1109: case DVB_DEVICE_VIDEO_0:
1110: card->video_blank=true;
1.9 mocm 1111: card->audiostate.AVSyncState=true;
1.6 mocm 1112: card->videostate.streamSource=VIDEO_SOURCE_DEMUX;
1.17 mocm 1113: margi_open(card, file->f_flags);
1.7 mocm 1114: break;
1.6 mocm 1115:
1116: case DVB_DEVICE_AUDIO_0:
1.17 mocm 1117: card->audiostate.AVSyncState=true;
1.6 mocm 1118: card->audiostate.streamSource=AUDIO_SOURCE_DEMUX;
1119: break;
1120:
1121: case DVB_DEVICE_DEMUX_0:
1122: if ((file->f_flags&O_ACCMODE)!=O_RDWR)
1123: return -EINVAL;
1124: ret=DmxDevFilterAlloc(&card->dmxdev, file);
1125: break;
1.18 mocm 1126:
1.6 mocm 1127: case DVB_DEVICE_DVR_0:
1.17 mocm 1128: card->audiostate.AVSyncState=true;
1.18 mocm 1129: card->setup.streamtype = stream_PES;
1.17 mocm 1130: margi_open(card, file->f_flags);
1.6 mocm 1131: ret=DmxDevDVROpen(&card->dmxdev, file);
1132: break;
1.9 mocm 1133:
1134: case DVB_DEVICE_OSD_0:
1135: break;
1136: default:
1.6 mocm 1137: return -EINVAL;
1138: }
1139: if (ret<0)
1140: return ret;
1141: if ((file->f_flags&O_ACCMODE)!=O_RDONLY)
1142: card->writers[num]++;
1143: card->users[num]++;
1144: return ret;
1145: }
1146:
1147: static int
1148: dvbdev_close(struct dvb_device *dvbdev, int num,
1149: struct inode *inode, struct file *file)
1150: {
1151: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1152: int type=num2type(card, num);
1153: int ret=0;
1154:
1155: if (type<0)
1156: return -EINVAL;
1157:
1158: switch (type) {
1159: case DVB_DEVICE_VIDEO_0:
1.11 mocm 1160: case DVB_DEVICE_AUDIO_0:
1161: if (card->open)
1162: all_margi_close(card);
1.6 mocm 1163: break;
1164:
1165: case DVB_DEVICE_DEMUX_0:
1166: ret=DmxDevFilterFree(&card->dmxdev, file);
1167: break;
1168:
1169: case DVB_DEVICE_DVR_0:
1170: ret=DmxDevDVRClose(&card->dmxdev, file);
1.12 mocm 1171: if (card->open)
1172: all_margi_close(card);
1.6 mocm 1173: break;
1.9 mocm 1174: case DVB_DEVICE_OSD_0:
1175: break;
1176: default:
1.6 mocm 1177: return -EINVAL;
1178: }
1179: if (ret<0)
1180: return ret;
1181: if ((file->f_flags&O_ACCMODE)!=O_RDONLY)
1182: card->writers[num]--;
1183: card->users[num]--;
1184: return ret;
1185: }
1186:
1.13 mocm 1187:
1.6 mocm 1188: static ssize_t
1189: dvbdev_write(struct dvb_device *dvbdev, int num,
1190: struct file *file,
1191: const char *buf, size_t count, loff_t *ppos)
1192: {
1193: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1194: int type=num2type(card, num);
1195:
1196: switch (type) {
1197: case DVB_DEVICE_VIDEO_0:
1198: if (card->videostate.streamSource!=VIDEO_SOURCE_MEMORY)
1199: return -EPERM;
1.11 mocm 1200: return margi_write(card, buf, count,
1.6 mocm 1201: file->f_flags&O_NONBLOCK);
1202:
1203: case DVB_DEVICE_AUDIO_0:
1204: if (card->audiostate.streamSource!=AUDIO_SOURCE_MEMORY)
1205: return -EPERM;
1.14 mocm 1206: if ( card->setup.streamtype != stream_PES )
1207: return -EPERM;
1208:
1.17 mocm 1209: return margi_write_audio(card, buf, count,
1210: file->f_flags&O_NONBLOCK);
1.6 mocm 1211:
1212: case DVB_DEVICE_DVR_0:
1213: return DmxDevDVRWrite(&card->dmxdev, file, buf, count, ppos);
1214: default:
1215: return -EOPNOTSUPP;
1216: }
1217: return 0;
1218: }
1219:
1.12 mocm 1220: static ssize_t
1221: dvbdev_read(struct dvb_device *dvbdev, int num,
1222: struct file *file, char *buf, size_t count, loff_t *ppos)
1223: {
1224: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1225: int type=num2type(card, num);
1226:
1227: switch (type) {
1228: case DVB_DEVICE_VIDEO_0:
1229: break;
1230: case DVB_DEVICE_AUDIO_0:
1231: break;
1232: case DVB_DEVICE_DEMUX_0:
1233: return DmxDevRead(&card->dmxdev, file, buf, count, ppos);
1234: case DVB_DEVICE_DVR_0:
1235: return DmxDevDVRRead(&card->dmxdev, file, buf, count, ppos);
1236: case DVB_DEVICE_CA_0:
1237: break;
1238: default:
1239: return -EOPNOTSUPP;
1240: }
1241: return 0;
1242: }
1243:
1244:
1245:
1.6 mocm 1246:
1247: static int
1248: dvbdev_ioctl(struct dvb_device *dvbdev, int num,
1249: struct file *file, unsigned int cmd, unsigned long arg)
1250: {
1251: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1252: void *parg=(void *)arg;
1253: int type=num2type(card, num);
1.17 mocm 1254: uint16_t attr;
1.6 mocm 1255:
1256: switch (type) {
1257: case DVB_DEVICE_VIDEO_0:
1258: if (((file->f_flags&O_ACCMODE)==O_RDONLY) &&
1259: (cmd!=VIDEO_GET_STATUS))
1260: return -EPERM;
1261:
1262: switch (cmd) {
1263:
1264: case VIDEO_STOP:
1265: DecoderPause(card);
1.9 mocm 1266: card->videostate.playState = VIDEO_STOPPED;
1.10 mocm 1267: if (card->videostate.videoBlank)
1268: VideoSetBackground(card, 1, 0, 0, 0);
1.9 mocm 1269:
1.10 mocm 1270:
1.9 mocm 1271: return 0;
1.6 mocm 1272:
1273: case VIDEO_PLAY:
1274:
1275: if (card->videostate.streamSource==
1276: VIDEO_SOURCE_MEMORY) {
1.9 mocm 1277: if (card->videostate.playState==VIDEO_FREEZED){
1278: DecoderUnPause(card);
1279: } else {
1280: DecoderUnPause(card);
1281: }
1.6 mocm 1282: }
1283: break;
1284:
1285: case VIDEO_FREEZE:
1286: DecoderPause(card);
1287: break;
1288:
1289: case VIDEO_CONTINUE:
1290: if (card->videostate.playState==VIDEO_FREEZED) {
1291: DecoderUnPause(card);
1292: }
1293: break;
1294:
1295: case VIDEO_SELECT_SOURCE:
1296: card->videostate.streamSource=(videoStreamSource_t) arg;
1297: break;
1298:
1299: case VIDEO_SET_BLANK:
1300: card->videostate.videoBlank=(boolean) arg;
1301: break;
1302:
1303: case VIDEO_GET_STATUS:
1304: if(copy_to_user(parg, &card->videostate,
1305: sizeof(struct videoStatus)))
1306: return -EFAULT;
1307: break;
1308:
1309: case VIDEO_GET_EVENT:
1310: return -EOPNOTSUPP;
1311:
1312: case VIDEO_SET_DISPLAY_FORMAT:
1313: {
1314: videoDisplayFormat_t format=(videoDisplayFormat_t) arg;
1.12 mocm 1315: uint16_t val=0;
1.6 mocm 1316:
1317: switch(format) {
1318: case VIDEO_PAN_SCAN:
1319: val=VID_PAN_SCAN_PREF;
1320: break;
1321:
1322: case VIDEO_LETTER_BOX:
1323: val=VID_VC_AND_PS_PREF;
1324: break;
1325:
1326: case VIDEO_CENTER_CUT_OUT:
1327: val=VID_CENTRE_CUT_PREF;
1328: break;
1329:
1330: default:
1331: return -EINVAL;
1332: }
1333:
1334: card->videostate.videoFormat=format;
1335: return 0;
1336: }
1337:
1338: case VIDEO_STILLPICTURE:
1339: {
1340: struct videoDisplayStillPicture pic;
1341:
1342: if(copy_from_user(&pic, parg,
1343: sizeof(struct videoDisplayStillPicture)))
1344: return -EFAULT;
1345:
1346: break;
1347: }
1348:
1349: case VIDEO_FAST_FORWARD:
1.10 mocm 1350: if (card->videostate.streamSource !=
1351: VIDEO_SOURCE_MEMORY)
1352: return -EPERM;
1.13 mocm 1353: card->videoffwd = 3;
1.6 mocm 1354: break;
1355:
1356: case VIDEO_SLOWMOTION:
1357: if (card->videostate.streamSource!=VIDEO_SOURCE_MEMORY)
1358: return -EPERM;
1.10 mocm 1359: card->videoslow = arg;
1.6 mocm 1360:
1361: break;
1362:
1363: case VIDEO_GET_CAPABILITIES:
1364: {
1.8 mocm 1365: int cap=VIDEO_CAP_MPEG1|
1366: VIDEO_CAP_MPEG2|
1367: VIDEO_CAP_SYS|
1368: VIDEO_CAP_PROG|
1369: VIDEO_CAP_SPU|
1370: VIDEO_CAP_NAVI|
1371: VIDEO_CAP_CSS;
1372:
1.6 mocm 1373:
1374: if (copy_to_user(parg, &cap,
1375: sizeof(cap)))
1376: return -EFAULT;
1377: break;
1378: }
1.18 mocm 1379:
1.14 mocm 1380: case VIDEO_SET_STREAMTYPE:
1381: {
1382: int f = -1;
1383: switch(arg){
1384: case VIDEO_CAP_MPEG1:
1385: case VIDEO_CAP_MPEG2:
1386: f = stream_PES;
1387: break;
1388:
1389: case VIDEO_CAP_SYS:
1390: case VIDEO_CAP_PROG:
1391: f = stream_PS;
1392: break;
1393:
1394: case VIDEO_CAP_SPU:
1395: case VIDEO_CAP_NAVI:
1396: case VIDEO_CAP_CSS:
1397: f = stream_DVD;
1398: }
1399: card->setup.streamtype = f;
1.17 mocm 1400:
1.14 mocm 1401: }
1402: break;
1403:
1.17 mocm 1404: case VIDEO_SET_ID:
1405: card->setup.videoID = arg;
1406: DecoderPrepareVideo(card);
1407: break;
1408:
1409: case VIDEO_SET_SYSTEM:
1410: card->videomode = (videosystem) arg;
1411: SetVideoSystem(card);
1412: break;
1413:
1414: case VIDEO_SET_HIGHLIGHT:
1415: {
1416: uint8_t data1[4];
1417: uint8_t data2[6];
1418: videoHighlight_t vh;
1419:
1420: if(copy_from_user(&vh, parg, sizeof(videoHighlight_t)))
1421: return -EFAULT;
1422:
1423: data1[0] = vh.contrast1;
1424: data1[1] = vh.contrast2;
1425: data1[2] = vh.color1;
1426: data1[3] = vh.color2;
1427: data2[0] = vh.ypos & 0xFF;
1428: data2[1] = (uint8_t) ((vh.ypos >> 1) & 0xFF);
1429: data2[2] = (uint8_t) ((vh.ypos >> 2) & 0xFF);
1430: data2[3] = vh.xpos & 0xFF;
1431: data2[4] = (uint8_t) ((vh.xpos >> 1) & 0xFF);
1432: data2[5] = (uint8_t) ((vh.xpos >> 2) & 0xFF);
1433: return DecoderHighlight(card, vh.active, data1, data2);
1434: break;
1435: }
1436:
1437: case VIDEO_SET_SPU:
1438: {
1439: videoSPU_t spu;
1440:
1441: if(copy_from_user(&spu, parg, sizeof(videoSPU_t)))
1442: return -EFAULT;
1443:
1444: return DecoderSPUStream(card, spu.streamID, spu.active);
1445: break;
1446: }
1447:
1.20 mocm 1448: case VIDEO_SET_SPU_PALETTE:
1.17 mocm 1449: {
1450: videoSPUPalette_t spup;
1451:
1452: if(copy_from_user(&spup, parg, sizeof(videoSPUPalette_t)))
1453: return -EFAULT;
1454:
1455: return DecoderSPUPalette(card, spup.length, spup.palette);
1456: break;
1457: }
1458:
1459: case VIDEO_GET_NAVI:
1460: {
1461: videoNaviPack_t navi;
1462:
1.18 mocm 1463: navi.length = DecoderGetNavi(card, (u8 *)&(navi.data));
1.17 mocm 1464: if(copy_to_user(parg, &navi, sizeof(videoNaviPack_t)))
1465: return -EFAULT;
1466: }
1467: break;
1468:
1469: case VIDEO_SET_ATTRIBUTES:
1470: {
1471: if (!card->ChannelBuffersAllocated) {
1472: DecoderStreamReset(card);
1473: MargiFlush(card);
1474:
1475: card->setup.streamtype = stream_DVD;
1476: card->setup.videoID = 0;
1477: DecoderPrepareVideo(card);
1478: DecoderPreparePS(card, 0, 0, 2, 2, 3, 1);
1479: }
1480:
1481: SetVideoAttr(card, arg);
1482: card->startingDVDV = 1;
1483: }
1484: break;
1485:
1.6 mocm 1486: default:
1487: return -ENOIOCTLCMD;
1488: }
1489: return 0;
1.14 mocm 1490:
1.6 mocm 1491: case DVB_DEVICE_AUDIO_0:
1492: if (((file->f_flags&O_ACCMODE)==O_RDONLY) &&
1493: (cmd!=AUDIO_GET_STATUS))
1494: return -EPERM;
1495:
1496: switch (cmd) {
1497:
1498: case AUDIO_STOP:
1499: if (card->audiostate.streamSource!=AUDIO_SOURCE_MEMORY)
1500: break;
1501: AudioStopDecode(card);
1502: card->audiostate.playState=AUDIO_STOPPED;
1503: break;
1504:
1505: case AUDIO_PLAY:
1506: if (card->audiostate.streamSource!=AUDIO_SOURCE_MEMORY)
1507: break;
1508: AudioSetPlayMode(card, MAUDIO_PLAY);
1509: card->audiostate.playState=AUDIO_PLAYING;
1510: break;
1511:
1512: case AUDIO_PAUSE:
1513: card->audiostate.playState=AUDIO_PAUSED;
1514: AudioSetPlayMode(card, MAUDIO_PAUSE);
1515: break;
1516:
1517: case AUDIO_CONTINUE:
1518: if (card->audiostate.playState==AUDIO_PAUSED) {
1519: card->audiostate.playState=AUDIO_PLAYING;
1520: AudioSetPlayMode(card, MAUDIO_PLAY);
1521: }
1522: break;
1523:
1524: case AUDIO_SELECT_SOURCE:
1.14 mocm 1525: card->audiostate.streamSource=
1526: (audioStreamSource_t) arg;
1.6 mocm 1527: break;
1528:
1529: case AUDIO_SET_MUTE:
1530: {
1531: AudioMute(card, arg);
1532: card->audiostate.muteState=(boolean) arg;
1533: break;
1534: }
1535:
1536: case AUDIO_SET_AV_SYNC:
1.9 mocm 1537: card->videosync=(boolean) arg;
1.6 mocm 1538: card->audiostate.AVSyncState=(boolean) arg;
1539: break;
1540:
1541: case AUDIO_SET_BYPASS_MODE:
1542: return -EINVAL;
1543:
1544: case AUDIO_CHANNEL_SELECT:
1545: card->audiostate.channelSelect=(audioChannelSelect_t) arg;
1546:
1547: switch(card->audiostate.channelSelect) {
1548: case AUDIO_STEREO:
1549: break;
1550:
1551: case AUDIO_MONO_LEFT:
1552: break;
1553:
1554: case AUDIO_MONO_RIGHT:
1555: break;
1556:
1557: default:
1558: return -EINVAL;
1559: }
1560: return 0;
1561:
1562: case AUDIO_GET_STATUS:
1563: if(copy_to_user(parg, &card->audiostate,
1564: sizeof(struct audioStatus)))
1565: return -EFAULT;
1566: break;
1567:
1568: case AUDIO_GET_CAPABILITIES:
1569: {
1570: int cap=AUDIO_CAP_LPCM|
1571: AUDIO_CAP_MP1|
1.8 mocm 1572: AUDIO_CAP_MP2|
1573: AUDIO_CAP_AC3;
1.6 mocm 1574:
1575: if (copy_to_user(parg, &cap,
1576: sizeof(cap)))
1577: return -EFAULT;
1578: }
1.14 mocm 1579: break;
1580:
1581:
1582: case AUDIO_SET_STREAMTYPE:
1583: {
1584: int f = -1;
1585:
1586: switch(arg){
1587: case AUDIO_CAP_DTS:
1588: case AUDIO_CAP_MP3:
1589: case AUDIO_CAP_AAC:
1590: case AUDIO_CAP_SDDS:
1591: case AUDIO_CAP_OGG:
1592: f = audio_none;
1593: break;
1594:
1595: case AUDIO_CAP_LPCM:
1596: f = audio_LPCM;
1597: break;
1598:
1599: case AUDIO_CAP_MP1:
1600: case AUDIO_CAP_MP2:
1601: f = audio_MPEG;
1602: break;
1603:
1604: case AUDIO_CAP_AC3:
1605: f = audio_AC3;
1606: break;
1607: }
1608:
1609: card->setup.audioselect = (audio_type) f;
1610: DecoderPrepareAudio(card);
1.17 mocm 1611: break;
1.14 mocm 1612: }
1.17 mocm 1613:
1614: case AUDIO_SET_ID:
1615: if (arg < 0 || arg >32) arg = 0;
1616: card->setup.audioID = arg;
1617: arg = 0;
1618: case AUDIO_SET_EXT_ID:
1619: if (arg < 0 || arg >32) arg = 0;
1620: card->setup.audioIDext = arg;
1621:
1622: attr = card->lastaattr;
1623: DecoderSelectAudioID(card);
1624: card->lastaattr = attr;
1625: break;
1626:
1627: case AUDIO_SET_MIXER:
1628: return -EINVAL;
1629:
1630: case AUDIO_SET_ATTRIBUTES:
1631: SetAudioAttr(card,arg);
1632: card->startingDVDA = ((card->setup.audioselect != audio_none)
1633: && (card->setup.audioselect !=
1634: audio_disable));
1635: break;
1636:
1637:
1638: case AUDIO_SET_KARAOKE:
1639: {
1640: break;
1641: }
1.14 mocm 1642:
1643: default:
1.6 mocm 1644: return -ENOIOCTLCMD;
1645: }
1.14 mocm 1646: break;
1.6 mocm 1647:
1648: case DVB_DEVICE_DEMUX_0:
1649: return DmxDevIoctl(&card->dmxdev, file, cmd, arg);
1.13 mocm 1650: break;
1.6 mocm 1651:
1.9 mocm 1652: case DVB_DEVICE_OSD_0:
1653: {
1.13 mocm 1654: switch (cmd) {
1.9 mocm 1655: case OSD_SEND_CMD:
1.13 mocm 1656: {
1657: osd_cmd_t doc;
1658:
1659: if(copy_from_user(&doc, parg,
1660: sizeof(osd_cmd_t)))
1661: return -EFAULT;
1662: return OSD_DrawCommand(card, &doc);
1663: }
1.9 mocm 1664: default:
1665: return -EINVAL;
1.13 mocm 1666: }
1.9 mocm 1667: break;
1668: }
1669: default:
1.6 mocm 1670: return -EOPNOTSUPP;
1671: }
1672: return 0;
1673: }
1674:
1675: static unsigned int
1676: dvbdev_poll(struct dvb_device *dvbdev, int num,
1677: struct file *file, poll_table * wait)
1678: {
1679: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1680: int type=num2type(card, num);
1681:
1682: switch (type) {
1683: case DVB_DEVICE_DEMUX_0:
1684: return DmxDevPoll(&card->dmxdev, file, wait);
1685:
1686: case DVB_DEVICE_VIDEO_0:
1687: return PSpoll(file, wait);
1688:
1689: case DVB_DEVICE_AUDIO_0:
1.17 mocm 1690: return poll_audio(file, wait);
1.6 mocm 1691:
1692: case DVB_DEVICE_CA_0:
1693: break;
1694:
1695: default:
1696: return -EOPNOTSUPP;
1697: }
1698:
1699: return 0;
1700: }
1701:
1702:
1703: static int
1704: dvbdev_device_type(struct dvb_device *dvbdev, unsigned int num)
1705: {
1706: struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
1707:
1708: return num2type(card, num);
1709: }
1710: #endif
1711:
1712: /******************************************************************************
1713: * driver registration
1714: ******************************************************************************/
1715:
1716:
1717: #ifdef DVB
1718:
1719: #define INFU 32768
1720:
1.9 mocm 1721:
1722:
1.6 mocm 1723: static dvb_devs_t mdvb_devs = {
1.9 mocm 1724: 9,
1.6 mocm 1725: {
1.9 mocm 1726: DVB_DEVICE_VIDEO_0, DVB_DEVICE_AUDIO_0,
1727: -1, -1,
1728: DVB_DEVICE_DEMUX_0, DVB_DEVICE_DVR_0,
1729: -1, -1,
1.13 mocm 1730: DVB_DEVICE_OSD_0,
1.6 mocm 1731: },
1.9 mocm 1732: { INFU, INFU, INFU, INFU, INFU, 1, 1, INFU, 1 },
1733: { 1, 1, 1, 1, INFU, 1, 1, 1, 1}
1.6 mocm 1734: };
1735:
1.12 mocm 1736:
1737: static int
1738: dvb_start_feed(dvb_demux_feed_t *dvbdmxfeed)
1739: {
1740: dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
1741: struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
1742:
1743: if (!dvbdmx->dmx.frontend || !card)
1744: return -EINVAL;
1745:
1746: if (dvbdmxfeed->type == DMX_TYPE_TS) {
1747: if ((dvbdmxfeed->ts_type & TS_DECODER)
1748: && (dvbdmxfeed->pes_type<DMX_TS_PES_OTHER)) {
1749: switch (dvbdmx->dmx.frontend->source) {
1750: case DMX_MEMORY_FE:
1751: if (dvbdmxfeed->ts_type & TS_DECODER)
1752: if (dvbdmxfeed->pes_type<2 &&
1753: dvbdmx->pids[0]!=0xffff &&
1754: dvbdmx->pids[1]!=0xffff) {
1755:
1756: setup_ts2pes( &card->tsa,
1757: &card->tsv,
1758: dvbdmx->pids,
1759: dvbdmx->pids+1,
1760: pes_write,
1761: (void *)card);
1762:
1763: dvbdmx->playing=1;
1764: }
1765: break;
1766: default:
1767: return -EINVAL;
1768: break;
1769: }
1770: }
1771: }
1772:
1773: if (dvbdmxfeed->type == DMX_TYPE_SEC) {
1774: int i;
1775:
1776: for (i=0; i<dvbdmx->filternum; i++) {
1777: if (dvbdmx->filter[i].state!=DMX_STATE_READY)
1778: continue;
1779: if (dvbdmx->filter[i].type!=DMX_TYPE_SEC)
1780: continue;
1781: if (dvbdmx->filter[i].filter.parent!=
1782: &dvbdmxfeed->feed.sec)
1783: continue;
1784:
1785: dvbdmxfeed->feed.sec.is_filtering=1;
1786: dvbdmx->filter[i].state=DMX_STATE_GO;
1787: }
1788: }
1789:
1790: return 0;
1791: }
1792:
1793:
1794: static int
1795: dvb_stop_feed(dvb_demux_feed_t *dvbdmxfeed)
1796: {
1797: dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
1798: struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
1799: if (!card)
1800: return -EINVAL;
1801:
1802: if (dvbdmxfeed->type == DMX_TYPE_TS) {
1803: if ((dvbdmxfeed->ts_type & TS_DECODER)
1804: && (dvbdmxfeed->pes_type<=1)) {
1805: if (dvbdmx->playing) {
1.14 mocm 1806: free_ipack(&card->tsa);
1807: free_ipack(&card->tsv);
1.12 mocm 1808: DecoderPause(card);
1809: dvbdmx->playing=0;
1810: }
1811: }
1812:
1813: }
1814: if (dvbdmxfeed->type == DMX_TYPE_SEC) {
1815: int i;
1816:
1817: for (i=0; i<dvbdmx->filternum; i++)
1818: if (dvbdmx->filter[i].state==DMX_STATE_GO &&
1819: dvbdmx->filter[i].filter.parent==
1820: &dvbdmxfeed->feed.sec) {
1821: dvbdmx->filter[i].state=DMX_STATE_READY;
1822: }
1823:
1824: }
1825: return 0;
1826: }
1827:
1.22 mocm 1828: static uint16_t get_pid(uint8_t *pid)
1829: {
1830: uint16_t pp = 0;
1831:
1832: pp = (pid[0] & PID_MASK_HI)<<8;
1833: pp |= pid[1];
1834:
1835: return pp;
1836: }
1837:
1.12 mocm 1838:
1839: static int
1840: dvb_write_to_decoder(dvb_demux_feed_t *dvbdmxfeed, uint8_t *buf, size_t count)
1841: {
1842: dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
1843: struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
1844: uint16_t pid = 0;
1.18 mocm 1845: int off = 0;
1.12 mocm 1846:
1.14 mocm 1847: ipack *p;
1.12 mocm 1848:
1849: if (!card)
1850: return -EINVAL;
1851:
1852: pid = get_pid(buf+1);
1853:
1854: if (pid == *(card->tsa.pid)) p = &(card->tsa);
1855: else if (pid == *(card->tsv.pid)) p = &(card->tsv);
1856: else return 0;
1857:
1858: if (dvbdmxfeed->pes_type>1)
1859: return -1;
1860: if (!(buf[3]&0x10)) // no payload?
1861: return -1;
1862:
1863: if (count != TS_SIZE) return -1;
1864:
1.18 mocm 1865: if ( buf[3] & ADAPT_FIELD) { // adaptation field?
1866: off = buf[4] + 1;
1867: }
1868:
1869:
1870: if (pid == *(card->tsa.pid)){
1871: MDEBUG(0,"AUDIO count: %d off: %d\n",count,off);
1872: margi_write_audio(card, buf+off+4, TS_SIZE-4-off, 0);
1873: } else {
1874: MDEBUG(0,"VIDEO count: %d off: %d\n",count,off);
1875: margi_write(card, buf+off+4, TS_SIZE-4-off, 0);
1876: }
1877:
1878: // ts_to_pes( p, buf); // don't need count (=188)
1.12 mocm 1879: return 0;
1880: }
1881:
1.6 mocm 1882: int dvb_register(struct cvdv_cards *card)
1883: {
1.12 mocm 1884: int i,ret;
1.6 mocm 1885: struct dvb_device *dvbd=&card->dvb_dev;
1.12 mocm 1886:
1887: dvb_demux_t *dvbdemux = (dvb_demux_t *)&card->demux;
1.6 mocm 1888:
1889: if (card->dvb_registered)
1890: return -1;
1891: card->dvb_registered=1;
1892:
1893: card->audiostate.AVSyncState=0;
1894: card->audiostate.muteState=0;
1895: card->audiostate.playState=AUDIO_STOPPED;
1896: card->audiostate.streamSource=AUDIO_SOURCE_MEMORY;
1897: card->audiostate.channelSelect=AUDIO_STEREO;
1898: card->audiostate.bypassMode=0;
1899:
1900: card->videostate.videoBlank=0;
1901: card->videostate.playState=VIDEO_STOPPED;
1902: card->videostate.streamSource=VIDEO_SOURCE_MEMORY;
1903: card->videostate.videoFormat=VIDEO_FORMAT_4_3;
1904: card->videostate.displayFormat=VIDEO_CENTER_CUT_OUT;
1905:
1906: // init and register demuxes
1.12 mocm 1907: memcpy(card->demux_id, "demux0_0", 9);
1908: card->demux_id[7] = 1+0x30;
1909: dvbdemux->priv = (void *) card;
1910: dvbdemux->filternum = 32;
1911: dvbdemux->feednum = 32;
1912: dvbdemux->start_feed = dvb_start_feed;
1913: dvbdemux->stop_feed = dvb_stop_feed;
1914: dvbdemux->write_to_decoder = dvb_write_to_decoder;
1915:
1916: dvbdemux->dmx.vendor="CIM";
1917: dvbdemux->dmx.model="sw";
1918: dvbdemux->dmx.id=card->demux_id;
1919: dvbdemux->dmx.capabilities=(DMX_TS_FILTERING|
1920: DMX_SECTION_FILTERING|
1921: DMX_MEMORY_BASED_FILTERING);
1922:
1923: DvbDmxInit(&card->demux);
1924:
1925: card->dmxdev.filternum=32;
1926: card->dmxdev.demux=&dvbdemux->dmx;
1927: card->dmxdev.capabilities=0;
1928:
1929: DmxDevInit(&card->dmxdev);
1.6 mocm 1930:
1.12 mocm 1931: card->mem_frontend.id="mem_frontend";
1932: card->mem_frontend.vendor="memory";
1933: card->mem_frontend.model="sw";
1934: card->mem_frontend.source=DMX_MEMORY_FE;
1935: ret=dvbdemux->dmx.add_frontend(&dvbdemux->dmx,
1936: &card->mem_frontend);
1937: if (ret<0)
1938: return ret;
1939: ret=dvbdemux->dmx.connect_frontend(&dvbdemux->dmx,
1940: &card->mem_frontend);
1941: if (ret<0)
1942: return ret;
1.6 mocm 1943:
1944: // init and register dvb device structure
1945: dvbd->priv=(void *) card;
1946: dvbd->open=dvbdev_open;
1947: dvbd->close=dvbdev_close;
1948: dvbd->write=dvbdev_write;
1.12 mocm 1949: dvbd->read=dvbdev_read;
1.6 mocm 1950: dvbd->ioctl=dvbdev_ioctl;
1951: dvbd->poll=dvbdev_poll;
1952: dvbd->device_type=dvbdev_device_type;
1953:
1954: for (i=0; i<DVB_DEVS_MAX; i++)
1955: card->users[i]=card->writers[i]=0;
1956:
1957: card->dvb_devs=0;
1958: card->dvb_devs=&mdvb_devs;
1.12 mocm 1959:
1.6 mocm 1960: return dvb_register_device(dvbd);
1961: }
1962:
1963: void dvb_unregister(struct cvdv_cards *card)
1964: {
1.12 mocm 1965: dvb_demux_t *dvbdemux=&card->demux;
1966:
1967: dvbdemux->dmx.close(&dvbdemux->dmx);
1968: dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &card->mem_frontend);
1969: DmxDevRelease(&card->dmxdev);
1970: DvbDmxRelease(&card->demux);
1.6 mocm 1971: dvb_unregister_device(&card->dvb_dev);
1972: }
1973: #endif