![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to decoder.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [DVB] / margi2|
Return to decoder.c CVS log | Up to [DVB] / margi2 |
1.1 cvs 1: /*
2: decoder.c
3:
4: Copyright (C) Christian Wolff for convergence integrated media.
5:
6: This program is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2 of the License, or
9: (at your option) any later version.
10:
11: This program is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with this program; if not, write to the Free Software
18: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19: */
20:
21: #define __NO_VERSION__
22:
23: #include "decoder.h"
24: #include "l64021.h"
25: #include "video.h"
26: #include "audio.h"
27: #include "streams.h"
28: #include "osd.h"
29: #include "dram.h"
1.5 mocm 30: #include "cvdv.h"
1.1 cvs 31:
32: int DecoderGetNavi(struct cvdv_cards *card, u8 *navidata)
33: {
34: if (card->navihead == card->navitail) return 0;
35: // printk(KERN_DEBUG LOGNAME ": Retreiving NaviPack\n");
36: memcpy(navidata, &card->navibuffer[card->navitail], NAVISIZE);
37: card->navitail += NAVISIZE;
38: if (card->navitail >= NAVIBUFFERSIZE) card->navitail = 0;
39: return NAVISIZE;
40: }
41:
42: // returns 1 on overrun, 0 on no error
43: int DecoderQueueNavi(struct cvdv_cards *card, u8 *navidata)
44: {
45: memcpy(&card->navibuffer[card->navihead], navidata, NAVISIZE);
46: card->navihead += NAVISIZE;
47: if (card->navihead >= NAVIBUFFERSIZE) card->navihead = 0;
48: if (card->navihead == card->navitail) {
49: // printk(KERN_DEBUG LOGNAME ": NaviPack buffer overflow\n");
50: card->navitail += NAVISIZE;
51: if (card->navitail >= NAVIBUFFERSIZE) card->navitail = 0;
52: return 1;
53: }
54: return 0;
55: }
56:
1.6 mocm 57: u32 ParseSCR(const u8 *data)
1.1 cvs 58: {
59: u32 SCR_base=0;
1.6 mocm 60: u8 scrdata[9];
61: copy_from_user (scrdata, data, 9);
62:
1.1 cvs 63: if ((!scrdata[0]) && (!scrdata[1]) && (scrdata[2]==1)
64: && (scrdata[3]==0xBA) && ((scrdata[4]&0xC0)==0x40)) {
65: SCR_base=((scrdata[4]>>3)&0x07);
66: SCR_base=(SCR_base<<2) | (scrdata[4]&0x03);
67: SCR_base=(SCR_base<<8) | scrdata[5];
68: SCR_base=(SCR_base<<5) | ((scrdata[6]>>3)&0x1F);
69: SCR_base=(SCR_base<<2) | (scrdata[6]&0x03);
70: SCR_base=(SCR_base<<8) | scrdata[7];
71: SCR_base=(SCR_base<<5) | ((scrdata[8]>>3)&0x1F);
72: }
73: return SCR_base;
74: }
75:
76: u32 SetSCR(struct cvdv_cards *card, u32 SCR_base)
77: {
78: // printk(KERN_ERR LOGNAME ": SCR in DVD Pack: 0x%08X\n",SCR_base);
79: if (DecoderReadByte(card, 0x007) & 0x10) { // SCR already stopped
80: DecoderWriteByte(card,0x009,SCR_base&0xFF); // Set SCR counter
81: DecoderWriteByte(card,0x00A,(SCR_base>>8)&0xFF);
82: DecoderWriteByte(card,0x00B,(SCR_base>>16)&0xFF);
83: DecoderWriteByte(card,0x00C,(SCR_base>>24)&0xFF);
84: } else {
85: DecoderMaskByte(card,0x007,0xD2,0xD2);
86: // Set 0x10, halt SCR counter
87: DecoderWriteByte(card,0x009,SCR_base&0xFF); // Set SCR counter
88: DecoderWriteByte(card,0x00A,(SCR_base>>8)&0xFF);
89: DecoderWriteByte(card,0x00B,(SCR_base>>16)&0xFF);
90: DecoderWriteByte(card,0x00C,(SCR_base>>24)&0xFF);
91: DecoderMaskByte(card,0x007,0xD2,0xC2);
92: // Del 0x10, SCR counter run
93: }
94: return SCR_base;
95: }
96:
97: void DecoderPause(struct cvdv_cards *card)
98: {
99: DecoderMaskByte(card, 0x007, 0xD2, 0xD2);
100: // Set 0x010, halt SCR counter
1.6 mocm 101: AudioSetPlayMode(card, MAUDIO_PAUSE);
1.1 cvs 102: DecoderStopDecode(card);
1.7 mocm 103: card->videostate.playState=VIDEO_FREEZED;
1.8 mocm 104: card->videoffwd = 0;
105: card->videoslow = 0;
1.1 cvs 106: }
107:
108: void DecoderUnPause(struct cvdv_cards *card)
109: {
110: DecoderStartDecode(card);
1.8 mocm 111: card->videoffwd = 0;
1.6 mocm 112: AudioSetPlayMode(card, MAUDIO_PLAY);
1.1 cvs 113: DecoderMaskByte(card, 0x007, 0xD2, 0xC2);
114: // Del 0x010, SCR counter run
1.7 mocm 115: card->videostate.playState=VIDEO_PLAYING;;
1.8 mocm 116: card->videoslow = 0;
1.1 cvs 117: }
118:
119: void CloseCard(struct cvdv_cards *card)
120: {
1.6 mocm 121: #ifdef NOINT
122: spin_lock(&card->timelock);
1.9 ! mocm 123: del_timer(&card->timer);
1.6 mocm 124: spin_unlock(&card->timelock);
125: #endif
1.4 mocm 126: MargiFlush(card);
1.1 cvs 127: printk(KERN_DEBUG LOGNAME ": Closing card\n");
1.3 rjkm 128: card->DecoderOpen = 1;
129: DecoderClose(card);
130: DecoderUnPrepare(card);
1.1 cvs 131: DecoderStreamReset(card);
132: DecoderSetupReset(card);
1.8 mocm 133: VideoSetBackground(card, 1, 0, 0, 0);
1.1 cvs 134:
135: AudioClose(card);
136: OSDClose(card);
1.4 mocm 137: L64021Init(card);
1.6 mocm 138:
1.5 mocm 139: OSDOpen(card, 50, 50, 150, 150, 2, 1);
140: OSDTest(card);
1.1 cvs 141: }
142:
143:
144: void DecoderReadAudioInfo(struct cvdv_cards *card)
145: {
146: u8 data;
147: static int bitrates[17] = {0, 32, 40, 48, 56, 64, 80, 96, 112,
148: 128, 160, 192, 224, 256, 320, 384, 0};
149: struct AudioParam *audio = &card->stream.audio;
150: data = DecoderReadByte(card, 0x150);
151: audio->mpeg.present = data & 0x60;
152: // MPEG Layer Code 00 reserverd, we can assume valid MPEG params
153: if (audio->mpeg.present) {
154: audio->mpeg.MPEG2 = data & 0x80;
155: audio->mpeg.layer = 4 - ((data >> 5) & 0x03);
156: if (data & 0x0F) {
157: if ((data & 0x0F) == 1) audio->mpeg.bitrate = 32;
158: else switch (audio->mpeg.layer) {
159: case 1:
160: audio->mpeg.bitrate = 32 * (data & 0x0F);
161: break; // Layer I
162: case 2:
163: audio->mpeg.bitrate = bitrates[(data & 0x0F) +
164: 1];
165: break; // Layer II
166: default:
167: audio->mpeg.bitrate = bitrates[data & 0x0F];
168: // Layer III
169: }
170: } else audio->mpeg.bitrate = 0;
171: data = DecoderReadByte(card, 0x151);
172: switch ((data >> 6) & 0x03) {
173: case 0:
174: audio->mpeg.samplefreq = 44;
175: break;
176: case 1:
177: audio->mpeg.samplefreq = 48;
178: break;
179: case 2:
180: audio->mpeg.samplefreq = 32;
181: break;
182: default:
183: audio->mpeg.samplefreq = 0; // invalid
184: }
185: audio->mpeg.mode = (data >> 3) & 0x03;
186: audio->mpeg.modeext = (data >> 1) & 0x03;
187: audio->mpeg.copyright = data & 0x01;
188: data=DecoderReadByte(card, 0x152);
189: audio->mpeg.original = data & 0x80;
190: audio->mpeg.emphasis = (data >> 5) & 0x03;
191: }
192: data = DecoderReadByte(card, 0x153);
193: audio->ac3.present = (data != 0);
194: // value 0 for bits 0..5 forbidden, we can assume valid ac3 params
195: if (audio->ac3.present) {
196: audio->ac3.acmod = (data >> 5) & 0x07;
197: audio->ac3.dialnorm = data & 0x1F;
198: data = DecoderReadByte(card, 0x154);
199: audio->ac3.bsmod = (data >> 5) & 0x07;
200: audio->ac3.dialnorm2 = data > 0x1F;
201: data = DecoderReadByte(card, 0x155);
202: audio->ac3.surmixlev = (data >> 6) & 0x03;
203: audio->ac3.mixlevel = (data >> 1) & 0x1F;
204: data = DecoderReadByte(card, 0x156);
205: audio->ac3.cmixlev = (data >> 6) & 0x03;
206: audio->ac3.mixlevel2 = (data >> 1) & 0x1F;
207: data = DecoderReadByte(card, 0x157);
208: audio->ac3.fscod = (data >> 6) & 0x03;
209: audio->ac3.lfeon = (data >> 5) & 0x01;
210: audio->ac3.bsid = data & 0x1F;
211: data = DecoderReadByte(card, 0x158);
212: audio->ac3.dsurmod = (data >> 6) & 0x03;
213: audio->ac3.frmsizecod = data & 0x3F;
214: audio->ac3.langcod = DecoderReadByte(card, 0x159);
215: audio->ac3.langcod2 = DecoderReadByte(card, 0x15A);
216: audio->ac3.timecod = DecoderReadByte(card, 0x15B);
217: data = DecoderReadByte(card, 0x15C);
218: audio->ac3.timecod = (audio->ac3.timecod << 6) |
219: ((data >> 2) & 0x3F);
220: audio->ac3.roomtyp = data & 0x03;
221: audio->ac3.timecod2 = DecoderReadByte(card, 0x15D);
222: data = DecoderReadByte(card, 0x15E);
223: audio->ac3.timecod2 = (audio->ac3.timecod2 << 6) |
224: ((data >> 2) & 0x3F);
225: audio->ac3.roomtyp2 = data & 0x03;
226: }
227: audio->pcm.present =! (DecoderReadByte(card, 0x161) & 0x20);
228: // PCM FIFO not empty? Then, we can assume valid LPCM params
229: if (audio->pcm.present) {
230: data = DecoderReadByte(card, 0x15F);
231: audio->pcm.audio_frm_num = (data >> 3) & 0x1F;
232: audio->pcm.num_of_audio_ch = data & 0x07;
233: data = DecoderReadByte(card, 0x160);
234: audio->pcm.Fs = (data >> 6) & 0x03;
235: audio->pcm.quantization = (data >> 4) & 0x03;
236: audio->pcm.emphasis = (data >> 2) & 0x03;
237: audio->pcm.mute_bit = (data >> 1) & 0x01;
238: }
239: switch (card->setup.audioselect) {
240: case audio_disable:
241: audio->valid = 0;
242: break;
243: case audio_none:
244: case audio_DTS:
245: case audio_SDDS:
246: if ((audio->valid = (audio->ac3.present ||
247: audio->pcm.present ||
248: audio->mpeg.present))) {
249: if (audio->mpeg.present) {
250: card->setup.audioselect = audio_MPEG;
251: } else if (audio->pcm.present) {
252: card->setup.audioselect = audio_LPCM;
253: } else if (audio->ac3.present) {
254: card->setup.audioselect = audio_AC3;
255: }
256: } else {
257: audio->valid = 0;
258: card->setup.audioselect = audio_none;
259: }
260: break;
261: case audio_MPEG: // MPEG Audio
262: case audio_MPEG_EXT: // MPEG Audio with extension stream
263: audio->valid = audio->mpeg.present;
264: break;
265: case audio_LPCM: // Linear Pulse Code Modulation LPCM
266: audio->valid = audio->pcm.present;
267: break;
268: case audio_AC3: // AC-3
269: audio->valid = audio->ac3.present;
270: break;
271: }
272: printk(KERN_DEBUG LOGNAME ": -- DecoderReadAudioInfo - type/valid %d/%d:\n", card->setup.audioselect, audio->valid);
273: if (audio->mpeg.present || audio->ac3.present || audio->pcm.present)
274: printk(KERN_DEBUG LOGNAME ": Audio - Decoded parameters:\n");
275: if (audio->mpeg.present) printk(KERN_DEBUG LOGNAME ": MPEG%s Layer %d, %d kHz, %d kbps, %s, %s%s, %s emphasis\n",
276: ((audio->mpeg.MPEG2) ? "2" : "1"),
277: audio->mpeg.layer,
278: audio->mpeg.samplefreq,
279: audio->mpeg.bitrate,
280: ((audio->mpeg.mode == 0) ? "stereo" : ((audio->mpeg.mode == 1) ? "joint stereo" : ((audio->mpeg.mode == 2) ? "dual channel" : "single channel"))),
281: ((audio->mpeg.copyright) ? "copyrighted " : ""),
282: ((audio->mpeg.original) ? "original" : "copy"),
283: ((audio->mpeg.emphasis == 0) ? "no" : ((audio->mpeg.emphasis == 1) ? "50/15 usec." : ((audio->mpeg.emphasis == 2) ? "invalid" : "J.17")))
284: );
285: if (audio->ac3.present) printk(KERN_DEBUG LOGNAME ": AC3 acmod=%d bsmod=%d dialnorm=%d dialnorm2=%d surmixlev=%d mixlevel=%d cmixlev=%d mixlevel2=%d fscod=%d lfeon=%d bsid=%d dsurmod=%d frmsizecod=%d langcod=%d langcod2=%d timecod=%d roomtyp=%d timecod2=%d roomtyp2=%d\n",
286: audio->ac3.acmod,
287: audio->ac3.bsmod,
288: audio->ac3.dialnorm,
289: audio->ac3.dialnorm2,
290: audio->ac3.surmixlev,
291: audio->ac3.mixlevel,
292: audio->ac3.cmixlev,
293: audio->ac3.mixlevel2,
294: audio->ac3.fscod,
295: audio->ac3.lfeon,
296: audio->ac3.bsid,
297: audio->ac3.dsurmod,
298: audio->ac3.frmsizecod,
299: audio->ac3.langcod,
300: audio->ac3.langcod2,
301: audio->ac3.timecod,
302: audio->ac3.roomtyp,
303: audio->ac3.timecod2,
304: audio->ac3.roomtyp2);
305: if (audio->pcm.present) printk(KERN_DEBUG LOGNAME ": LPCM audio_frm_num=%d num_of_audio_ch=%d Fs=%d quantization=%d emphasis=%d mute_bit=%d\n",
306: audio->pcm.audio_frm_num,
307: audio->pcm.num_of_audio_ch,
308: audio->pcm.Fs,
309: audio->pcm.quantization,
310: audio->pcm.emphasis,
311: audio->pcm.mute_bit);
312: }
313:
314: void DecoderReadAuxFifo(struct cvdv_cards *card)
315: {
316: int i = 0;
317: u8 data;
318: int layer;
319:
320: struct StreamInfo *stream = &card->stream;
321: // printk(KERN_DEBUG LOGNAME ": AUX - ");
322: // printk("%03X ", card->AuxFifo[card->AuxFifoTail]);
323: while (card->AuxFifoHead != card->AuxFifoTail) {
324:
325: layer = (card->AuxFifo[card->AuxFifoTail] >> 8) & 0x07;
326: data = card->AuxFifo[card->AuxFifoTail] & 0xFF;
327: card->AuxFifoTail = (card->AuxFifoTail + 1) & FIFO_MASK;
328: if (layer != card->AuxFifoLayer) { // start of a new layer?
329: i = 0;
330: card->AuxFifoLayer = layer;
331: } else i++;
332: switch (layer) { // layer code
333: case 0: // sequence header
334: if (! stream->sh.valid) switch (i) {
335: case 0:
336: stream->sh.hsize = data & 0x0F;
337: break;
338: case 1:
339: stream->sh.hsize = (stream->sh.hsize << 8)
340: | data;
341: stream->hsize = stream->sh.hsize;
342: break;
343: case 2:
344: stream->sh.vsize = data & 0x0F;
345: break;
346: case 3:
347: stream->sh.vsize = (stream->sh.vsize << 8) |
348: data;
349: stream->vsize = stream->sh.vsize;
350: break;
351: case 4:
352: stream->sh.aspectratio = data & 0x0F;
353: break;
354: case 5:
355: stream->sh.frameratecode = data & 0x0F;
356: break;
357: case 6:
358: stream->sh.bitrate = data & 0x03;
359: break;
360: case 7:
361: stream->sh.bitrate = (stream->sh.bitrate << 8)
362: | data;
363: break;
364: case 8:
365: stream->sh.bitrate = (stream->sh.bitrate << 8)
366: | data;
367: stream->bitrate = stream->sh.bitrate;
368: break;
369: case 9:
370: stream->sh.vbvbuffersize = data & 0x03;
371: break;
372: case 10:
373: stream->sh.vbvbuffersize =
374: (stream->sh.vbvbuffersize << 8) |
375: data;
376: stream->vbvbuffersize =
377: stream->sh.vbvbuffersize;
378: break;
379: case 11:
380: stream->sh.constrained = data & 0x01;
381: stream->sh.valid = 1;
382: printk(KERN_DEBUG LOGNAME ": AUX - MPEG1 - %dx%d %s %s fps, %d bps, %d kByte vbv%s\n", stream->sh.hsize, stream->sh.vsize,
383: ((stream->sh.aspectratio == 1) ? "1:1" :
384: ((stream->sh.aspectratio == 2) ? "3:4" :
385: ((stream->sh.aspectratio == 3) ? "9:16" :
386: ((stream->sh.aspectratio == 4) ? "1:2.21" :
387: "?:?")))),
388: ((stream->sh.frameratecode == 1) ? "23.976" :
389: ((stream->sh.frameratecode == 2) ? "24" :
390: ((stream->sh.frameratecode == 3) ? "25" :
391: ((stream->sh.frameratecode == 4) ? "29.97" :
392: ((stream->sh.frameratecode == 5) ? "30" :
393: ((stream->sh.frameratecode == 6) ? "50" :
394: ((stream->sh.frameratecode == 7) ? "59.94" :
395: ((stream->sh.frameratecode == 8) ? "60" :
396: "?")))))))),
397: stream->sh.bitrate * 400,
398: stream->sh.vbvbuffersize * 16,
399: ((stream->sh.constrained) ? ", constrained" : "")
400: );
401: break;
402: }
403: break;
404: case 1: // group of pictures
405: if (! stream->gop.valid)
406: switch (i) {
407: case 0:
408: stream->gop.timecode = data & 0x01;
409: break;
410: case 1:
411: stream->gop.timecode =
412: (stream->gop.timecode << 8) |
413: data;
414: break;
415: case 2:
416: stream->gop.timecode =
417: (stream->gop.timecode << 8) |
418: data;
419: break;
420: case 3:
421: stream->gop.timecode =
422: (stream->gop.timecode << 8) |
423: data;
424: break;
425: case 4:
426: stream->gop.closedgop = data & 0x01;
427: break;
428: case 5:
429: stream->gop.brokenlink = data & 0x01;
430: stream->gop.valid = 1;
431: break;
432: }
433: break;
434: case 2: // picture
435: if (0)
436: switch (i) {
437: case 0:
438: break;
439: }
440: break;
441: case 7: // extension layer
442: if (i == 0) card->AuxFifoExt = data;
443: else
444: switch (card->AuxFifoExt) { // extension code
445: case 1: // sequence extension
446: if ((stream->sh.valid) &&
447: (! stream->se.valid))
448: switch (i) {
449: case 1:
450: stream->se.profilelevel
451: = data;
452: break;
453: case 2:
454: stream->se.progressive
455: = data & 0x01;
456: break;
457: case 3:
458: stream->se.chroma =
459: (data >> 4) &
460: 0x03;
461: stream->se.hsizeext =
462: (data >> 2) &
463: 0x03;
464: stream->se.vsizeext =
465: data & 0x03;
466: stream->hsize |=
467: (stream->se.hsizeext << 12);
468: stream->vsize |=
469: (stream->se.vsizeext << 12);
470: break;
471: case 4:
472: stream->se.bitrateext =
473: data & 0x0F;
474: break;
475: case 5:
476: stream->se.bitrateext =
477: (stream->se.bitrateext << 8) | data;
478: stream->bitrate |=
479: (stream->se.bitrateext << 18);
480: break;
481: case 6:
482: stream->se.vbvbuffersizeext = data;
483: stream->vbvbuffersize |= (stream->se.vbvbuffersizeext << 10);
484: break;
485: case 7:
486: stream->se.lowdelay =
487: (data >> 7) &
488: 0x01;
489: stream->se.frextn =
490: (data >> 5) &
491: 0x03;
492: stream->se.frextd =
493: data & 0x1F;
494: stream->se.valid = 1;
495: stream->MPEG2 = 1;
496: printk(KERN_DEBUG LOGNAME ": AUX - MPEG2 - %dx%d %s %s*%d/%d fps, %d bps, %d kByte vbv%s%s\n", stream->hsize, stream->vsize,
497: ((stream->sh.aspectratio == 1) ? "1:1" :
498: ((stream->sh.aspectratio == 2) ? "3:4" :
499: ((stream->sh.aspectratio == 3) ? "9:16" :
500: ((stream->sh.aspectratio == 4) ? "1:2.21" :
501: "?:?")))),
502: ((stream->sh.frameratecode == 1) ? "23.976" :
503: ((stream->sh.frameratecode == 2) ? "24" :
504: ((stream->sh.frameratecode == 3) ? "25" :
505: ((stream->sh.frameratecode == 4) ? "29.97" :
506: ((stream->sh.frameratecode == 5) ? "30" :
507: ((stream->sh.frameratecode == 6) ? "50" :
508: ((stream->sh.frameratecode == 7) ? "59.94" :
509: ((stream->sh.frameratecode == 8) ? "60" :
510: "?")))))))),
511: stream->se.frextn + 1,
512: stream->se.frextd + 1,
513: stream->bitrate * 400,
514: stream->vbvbuffersize * 16,
515: ((stream->sh.constrained) ? ", constrained" : ""),
516: ((stream->se.lowdelay) ? ", low delay" : "")
517: );
518: break;
519: }
520: break;
521: case 2: // sequence display extension
522: if (0)
523: switch (i) {
524: case 0:
525: break;
526: }
527: break;
528: case 3: // quant matrix extension
529: if (0)
530: switch (i) {
531: case 0:
532: break;
533: }
534: break;
535: case 4: // copyright extension
536: if (0)
537: switch (i) {
538: case 0:
539: break;
540: }
541: break;
542: case 7: // picture display extension
543: if (0) switch (i) {
544: case 0:
545: break;
546: }
547: break;
548: case 8: // picture coding extension
549: if (0)
550: switch (i) {
551: case 0:
552: break;
553: }
554: break;
555: default:
556: break;
557: }
558: break;
559: default:break;
560: }
561:
562: }
563: }
564:
565: void DecoderReadDataFifo(struct cvdv_cards *card)
566: {
567: // printk(KERN_DEBUG LOGNAME ": DATA - ");
568: while (card->DataFifoHead != card->DataFifoTail) {
569: // printk("%03X ", card->DataFifo[card->DataFifoTail]);
570: card->DataFifoTail = (card->DataFifoTail + 1) & FIFO_MASK;
571: }
572: // printk("\n");
573: }
574:
575: int DecoderReadNavipack(struct cvdv_cards *card)
576: {
577: u32 startaddr, endaddr, writeaddr;
578: u8 navipack[1024];
579: u16 PacketLength;
580: u8 SubStreamID;
581: //struct Navi navi;
582: int i;
583: startaddr = (DecoderReadWord(card, 0x05C) & 0x3FFF) << 7;
584: // 21 bit word address
585: endaddr = (DecoderReadWord(card, 0x05E) & 0x3FFF) << 7;
586: // 21 bit word address
587: writeaddr = DecoderReadByte(card, 0x075) & 0xFF;
588: writeaddr |= (DecoderReadWord(card, 0x077) & 0x0FFF) << 8;
589: //writeaddr <<= 3;
590: //printk(KERN_DEBUG LOGNAME ": -- DecoderReadNavipack 0x%08X-0x%08X, ->0x%08X <-0x%08X\n", startaddr, endaddr, writeaddr, card->NaviPackAddress);
591:
592: if (DecoderReadByte(card, 0x07B) & 0xC0) { // navi pack available?
593: DRAMReadByte(card, card->NaviPackAddress, 1024, navipack, 0);
594: card->reg07B |= 0x20; // decrement navi counter
595: DecoderWriteByte(card, 0x07B, card->reg07B);
596: card->reg07B &= ~0x20;
597: //DecoderSetByte(card, 0x07B, 0x20); // decrement navi counter
598: card->NaviPackAddress += 512; // increment in words
599: if (card->NaviPackAddress >= endaddr)
600: card->NaviPackAddress = startaddr;
601: //printk(KERN_DEBUG LOGNAME ": Navipack %02X %02X %02X %02X %02X %02X %02X %02X\n",
602: // navipack[0], navipack[1], navipack[2], navipack[3], navipack[4], navipack[5], navipack[6], navipack[7]);
603: if ((!navipack[0]) && (!navipack[1]) && (navipack[2] == 1) && (navipack[3] == 0xBF)) {
604: PacketLength = (navipack[4] << 8) | navipack[5];
605: SubStreamID = navipack[6];
606: //printk(KERN_DEBUG LOGNAME ": Navipack Len=%d, ID=%d\n", PacketLength, SubStreamID);
607: i = 7; // start of payload data in navipack[]
608: switch (SubStreamID) {
609: case 0: // Presentation Control Information (PCI)
610: if (PacketLength < 980) return 1; // Packet too small
611: DecoderQueueNavi(card, navipack);
612: break;
613: case 1: // Data Search Information (DSI)
614: if (PacketLength < 1018) return 1; // Packet too small
615: DecoderQueueNavi(card, navipack);
616: break;
617: default:
618: break;
619: }
620: // } else {
621: // printk(KERN_DEBUG LOGNAME ": navi pack format error: %02X %02X %02X %02X %02X %02X %02X %02X.\n",
622: // navipack[0], navipack[1], navipack[2], navipack[3], navipack[4], navipack[5], navipack[6], navipack[7]);
623: }
624: // } else {
625: // printk(KERN_DEBUG LOGNAME ": no navi pack avail.\n");
626: }
627: return 0;
628: }
629:
630: int AudioStart(struct cvdv_cards *card)
631: {
632: DecoderReadAudioInfo(card); // detect audio type
633: if (card->stream.audio.valid) {
634: printk(KERN_DEBUG LOGNAME ": Audio Init in delayed decoder start\n");
635: if (card->AudioInitialized) AudioClose(card);
636: switch (card->setup.audioselect) {
637: case audio_MPEG: // MPEG Audio
638: case audio_MPEG_EXT: // MPEG Audio with ext.
639: printk(KERN_DEBUG LOGNAME ": Using MPEG Audio\n");
640: AudioInit(card, card->stream.audio.mpeg.samplefreq, 0);
641: if (card->stream.audio.mpeg.mode == 3) AudioDualMono(card, 2); // left channel only
642: else AudioDualMono(card, 0);
643: break;
644: case audio_DTS:
645: case audio_LPCM: // Linear Pulse Code Modulation LPCM
646: printk(KERN_DEBUG LOGNAME ": Using LPCM Audio\n");
647: AudioInit(card, 48, 0); // or 96
648: break;
649: case audio_AC3: // AC-3
650: printk(KERN_DEBUG LOGNAME ": Using AC-3 Audio\n");
651: switch (card->stream.audio.ac3.fscod) {
652: case 0:AudioInit(card, 48, 0); break;
653: case 1:AudioInit(card, 44, 0); break;
654: case 2:AudioInit(card, 32, 0); break;
655: }
656: break;
657: case audio_none:
658: case audio_disable:
659: case audio_SDDS:
660: }
661: } else return 1;
662: return 0;
663: }
664:
665: u32 DecoderReadSCR(struct cvdv_cards *card, u16 address)
666: {
667: u32 SCR;
668: SCR = DecoderReadByte(card, address);
669: SCR |= ((u32)DecoderReadByte(card, address+1) << 8);
670: SCR |= ((u32)DecoderReadByte(card, address+2) << 16);
671: SCR |= ((u32)DecoderReadByte(card, address+3) << 24);
672: return SCR;
673: }
674:
675: u32 DecoderReadRWAddr(struct cvdv_cards *card, u16 address)
676: {
677: u32 addr;
678: addr = DecoderReadByte(card, address) & 0xFF;
679: addr |= (((u32)DecoderReadByte(card, address+1) & 0xFF) << 8);
680: addr |= (((u32)DecoderReadByte(card, address+2) & 0x0F) << 16);
681: return addr;
682: }
683:
684: int PTSGetFirstPTS(PTSStorage *store, u32 *PTS)
685: {
686: if ( store->end == store->begin ) {
687: return 0;
688: } else {
689: *PTS = store->PTS[store->begin];
690: return 1;
691: }
692: }
693:
694: void PTSStoreAdd(PTSStorage *store, u32 PTS, u32 AddrB, u32 AddrE)
695: {
696: int new;
697:
698: //printk(KERN_DEBUG LOGNAME ": PTSStoreAdd - store in [%d] %08X - %08X\n", store->end, AddrB, AddrE);
699:
700: // cheap fix: don't store if address rollover
701: if ((AddrB & 0x00080000) != (AddrE & 0x00080000)) return;
702:
703: new = store->end;
704:
705: store->end++;
706: if (store->end >= store->size) store->end = 0;
707: if (store->end == store->begin) {
708: store->begin++;
709: if (store->begin >= store->size) store->begin = 0;
710: }
711:
712: store->AddrB[new] = AddrB;
713: store->AddrE[new] = AddrE;
714: store->PTS[new] = PTS;
715: }
716:
717: int PTSGetPTS (PTSStorage *store, u32 Addr, u32 *PTS )
718: {
719: u32 AddrB;
720: u32 AddrE;
721: int i;
722: int found;
723: int search;
724:
725: //printk(KERN_DEBUG LOGNAME ": PTSGetPTS - search %08X\n", Addr);
726:
727: if (store->end == store->begin) {
728: store->LastAddr = Addr;
729: return 0;
730: }
731:
732: // Search for the PTS in the array
733: found = 0;
734: search = 1;
735: while (search && !found) {
736: // Get the first value
737: i = store->begin;
738: AddrB = store->AddrB[i];
739: AddrE = store->AddrE[i];
740:
741: //printk(KERN_DEBUG LOGNAME ": PTSGetPTS - search in [%d] %08X - %08X\n", i, AddrB, AddrE);
742:
743: //If in range, keep it
744: if ((Addr >= AddrB) && (Addr <= AddrE)) {
745: *PTS = store->PTS[i];
746: found = 1;
747: } else {
748: if ((Addr & 0x00080000) == (AddrB & 0x00080000)) {
749: if (Addr < AddrB ) search = 0;
750: } else {
751: if ((store->LastAddr & 0x00080000) == (Addr & 0x00080000)) search = 0;
752: }
753: }
754: if (search) {
755: store->begin++;
756: if (store->begin >= store->size) store->begin = 0;
757: if (store->end == store->begin ) search = 0;
758: }
759: }
760: store->LastAddr = Addr;
761: return found;
762: }
763:
764:
765: u32 GetPTS(u8 *data, u32* MediaPointer, int mpeg, int hlength,int off)
766: {
767: u32 PTS = 0xFFFFFFFFUL;
768: int p = 0;
769:
770: // Read PTS, if present
771: if ((mpeg == 2 && data[p + 7] & 0x80) ||
772: (mpeg == 1 && off)) {
773: if (mpeg == 1) p = off-9;
774: PTS = (data[p + 9] >> 1) & 0x03UL;
775: PTS = (PTS << 8) | (data[p + 10] & 0xFFUL);
776: PTS = (PTS << 7) | ((data[p + 11] >> 1) & 0x7FUL);
777: PTS = (PTS << 8) | (data[p + 12] & 0xFFULL);
778: PTS = (PTS << 7) | ((data[p + 13] >> 1) & 0x7FUL);
779: }
780: // Now, skip rest of PES header and stuffing
781: if (mpeg == 2){
782: p += (9 + (data[p + 8] & 0xFF));
783: p = ((p + 7) / 8) * 8;
784: } else p = hlength+7;
785: if (!(data[p++] | data[p++] | data[p++] | data[p++])) {
786: *MediaPointer = (u32)data[p++] & 0xFF;
787: *MediaPointer = (*MediaPointer << 8) | ((u32)data[p++] & 0xFF);
788: *MediaPointer = (*MediaPointer << 8) | ((u32)data[p++] & 0xFF);
789: *MediaPointer = (*MediaPointer << 8) | ((u32)data[p++] & 0xFF);
790: } else {
791: *MediaPointer = 0xFFFFFFFFUL;
792: }
793: return PTS;
794: }
795:
796: int ReadPESChunk(struct cvdv_cards *card, u32 *addr, u8 *data, u32 start, u32 end)
797: {
798: int i = 5, err = -1;
799: while (err && (i--)) err &= DRAMReadByte(card, *addr << 2, 8, &data[0], 0);
800: if (err) return 1;
801: (*addr)++;
802: if (*addr >= end) *addr = start;
803: return 0;
804: }
805:
806: void ReadPESHeaders(struct cvdv_cards *card)
807: {
808: u8 startcode[] = {0x00, 0x00, 0x01};
809: int LoopCount;
810: u32 LastVAddr; // Current Video Address
811: u32 LastAAddr; // Current Audio Address
812: u32 Addr; // Current Header Address
813: u32 PESAddr; // Pointer from Header Block
814: u32 PTS; // PTS from Header Block
815: u8 Data[32];
816: u32 AudioPESStart;
817: u32 AudioPESEnd;
818: int i, j, p, fail;
819: u32 FailAddr;
820: int hlength=0;
821: int mpeg=0;
822: int check;
823: int mp=0;
824: int off=0;
825:
826: AudioPESStart = (DecoderReadWord(card, 0x058) & 0x3FFF) << 5;
827: AudioPESEnd = ((DecoderReadWord(card, 0x05A) & 0x3FFF) + 1) << 5;
828:
829: LastVAddr = DecoderReadRWAddr(card, 0x060);
830: LastAAddr = DecoderReadRWAddr(card, 0x063);
831:
832: if (card->LastAddr == 0) card->LastAddr = AudioPESStart;
833:
834: //Read the PES header buffer
835: Addr = DecoderReadRWAddr(card, 0x072) & 0x0007FFFF;
836: if (Addr >= AudioPESEnd) {
837: Addr = card->LastAddr = AudioPESStart;
838: }
839:
840: LoopCount = 0;
841: while ((card->LastAddr != Addr) && (LoopCount++ < 200)) {
842: FailAddr = card->LastAddr;
843: fail = 0;
844: p = 0;
845:
1.9 ! mocm 846: if (ReadPESChunk(card, &card->LastAddr, &Data[p],
! 847: AudioPESStart, AudioPESEnd)) continue;
1.1 cvs 848: p+=8;
849: j=1;
850:
851: if (memcmp(Data, startcode, 3)) continue;
852: if ((Data[3] == 0xE0) || (Data[3] == 0xBD)
853: || ((Data[3] & 0xE0) == 0xC0)) {
854:
855: fail |= ReadPESChunk(card, &card->LastAddr,
856: &Data[p], AudioPESStart,
857: AudioPESEnd);
858:
859:
860: p+=8;
861: j++;
862: if ( (Data[6] & 0xC0) == 0x80 ){
863: hlength = 9+Data[8];
864: mpeg = 2;
865: } else {
866: mpeg = 1;
867: mp = 6;
868: check = Data[mp];
869: mp++;
870: while (check == 0xFF){
871: if (!fail && mp == p) {
872: fail |= ReadPESChunk(
873: card,
874: &card->LastAddr,
875: &Data[p],
876: AudioPESStart,
877: AudioPESEnd);
878: p+=8;
879: j++;
880: }
881: check = Data[mp];
882: mp++;
883: }
884: if (!fail && mp == p) {
885: fail |= ReadPESChunk(
886: card,
887: &card->LastAddr,
888: &Data[p],
889: AudioPESStart,
890: AudioPESEnd);
891: p+=8;
892: j++;
893: }
894:
895: if ( !fail && (check & 0xC0) == 0x40){
896: check = Data[mp];
897: mp++;
898: if (!fail && mp == p) {
899: fail |= ReadPESChunk(
900: card,
901: &card->LastAddr,
902: &Data[p],
903: AudioPESStart,
904: AudioPESEnd);
905: p+=8;
906: j++;
907: }
908: check = Data[mp];
909: mp++;
910: }
911: if ( !fail && (check & 0x20)){
912: if (check & 0x30) hlength = mp+10;
913: else hlength = mp+5;
914: off = mp-1;
915: }
916: }
917:
918: for (i = 1; (i < ((hlength+7) / 8)) && (!fail);
919: i++) {
1.9 ! mocm 920: fail |= ReadPESChunk(card, &card->LastAddr,
! 921: &Data[p], AudioPESStart,
! 922: AudioPESEnd);
1.1 cvs 923: p+=8;
924: j++;
925: }
926:
927: if (!fail) {
928: PTS = GetPTS(Data, &PESAddr,
929: mpeg, hlength,off);
1.9 ! mocm 930: if ((PTS != 0xFFFFFFFF) &&
! 931: (PESAddr != 0xFFFFFFFF)) {
1.1 cvs 932: if (Data[3] == 0xE0) { // Video
933: PTSStoreAdd(&card->VideoPTSStore, PTS, PESAddr, LastVAddr);
934: } else { // Audio
935: PTSStoreAdd(&card->AudioPTSStore, PTS, PESAddr, LastAAddr);
936: }
937: }
938: }
939: } else {
940: //card->LastAddr = Addr;
941: }
942: // In case of error, rewind and try again
943: if (fail) card->LastAddr = FailAddr;
944: }
945: }
946:
947: void L64021Intr(struct cvdv_cards *card)
948: {
949: u32 SCR_base, SCR_compareV, SCR_compareA;
950: u32 VideoAddr, AudioAddr, PTS;
951: int i, a, v, as, vs, ap, vp;
952: u8 intr[5];
953: u8 layer;
1.8 mocm 954: u8 reg;
1.1 cvs 955: long ISRTime, DeltaSyncTime, Offset;
956:
957: int used = 0;
958: u8 err;
959:
960: err = DecoderReadByte(card, 0x095);
961: if (err & 0x17) {
962: printk(KERN_DEBUG LOGNAME ": Packet Error: 0x%02X\n", err);
963: }
964:
965: ISRTime = 0; // TODO system time
966:
967: for (i = 0; i < 5; i++)
968: if ((intr[i] = DecoderReadByte(card, i))) used = 1;
969: if (used) {
970: if (intr[0] & 0x80) { // new field
971: card->fields++;
972:
1.8 mocm 973: if (card->videoffwd){
974: AudioStopDecode(card);
975: card->videosync = 0;
976: card->videodelay = 0;
977: card->videoskip = 0;
978: reg = DecoderReadByte(card, 0x0EC);
979: if ((reg & 0x07) == 0x00) {
980: DecoderWriteByte(card, 0x0EC,
981: (card->videoffwd&
982: 0x03) |0x04);
983: }
1.9 ! mocm 984: } else if ((DecoderReadByte(card, 0x0EC) & 0x07)
! 985: && !card->videoskip){
1.8 mocm 986: if (card->audiostate.AVSyncState)
987: card->videosync = 1;
988: DecoderWriteByte(card, 0x0EC, 0x00);
989: AudioStartDecode(card);
1.1 cvs 990: }
1.8 mocm 991:
992: if (card->videoslow){
993: if (!card->videoslow_last){
994: AudioStopDecode(card);
995: card->videosync = 0;
1.9 ! mocm 996: card->videodelay = card->videoslow;
1.8 mocm 997: card->videoskip = 0;
998: card->videoslow_last = 1;
999: card->videodelay_last = 0;
1000: } else {
1001: if (card->videodelay_last == -1){
1002: card->videodelay =
1003: card->videoslow;
1004: }
1005:
1006: if (!card->videodelay)
1007: card->videodelay_last = -1;
1008: else
1009: card->videodelay_last =
1010: card->videodelay;
1011: }
1012: } else if( card->videoslow_last ){
1013: card->videoslow_last = 0;
1014: if (card->audiostate.AVSyncState)
1015: card->videosync = 1;
1016: AudioStartDecode(card);
1017: }
1.9 ! mocm 1018:
1.1 cvs 1019:
1020: if (card->videodelay > 0) {
1.8 mocm 1021: if( (DecoderReadByte(card, 0x0ED) & 0x03)
1022: == 0x00) {
1.1 cvs 1023: card->videodelay--;
1024: if(card->videodelay){
1.8 mocm 1025: DecoderWriteByte(card, 0x0ED,
1026: 0x01);
1.1 cvs 1027: } else {
1.8 mocm 1028: DecoderWriteByte(card, 0x0ED,
1029: 0x00);
1030: }
1031: } else {
1032: card->videodelay--;
1033: if(!card->videodelay){
1034: DecoderWriteByte(card, 0x0ED,
1035: 0x00);
1.1 cvs 1036: }
1037: }
1.8 mocm 1038: } else if (card->videoskip > 0) {
1039: if ((DecoderReadByte(card, 0x0EC) & 0x03)
1040: == 0x00) {
1041: if (DecoderReadWord(card, 0x096) > 5) {
1042: // pictures in video ES channel
1043: card->videoskip--;
1044: if(card->videoskip) {
1045: DecoderWriteByte(card,
1046: 0x0EC
1047: ,0x05);
1.1 cvs 1048: } else {
1.8 mocm 1049: DecoderWriteByte(card,
1050: 0x0EC
1.9 ! mocm 1051: ,0x00);
1.1 cvs 1052: }
1053: } else {
1.8 mocm 1054: card->videoskip = 0;
1.9 ! mocm 1055: DecoderWriteByte (card, 0x0EC,
! 1056: 0x00);
1.1 cvs 1057: }
1058: }
1059: }
1060:
1061:
1.9 ! mocm 1062: i = (DecoderReadByte(card, 0x113) & 0xFC) |
! 1063: (DecoderReadByte(card, 0x114) & 0x01);
1.1 cvs 1064: v = DecoderGetVideoESLevel(card);
1065: if (card->startingV) {
1066: vs = card->VideoESSize;
1067: if (vs > 0) vp = (100 * v) / vs;
1068: else vp = 0;
1.4 mocm 1069: if (vp > 40) {
1.9 ! mocm 1070: printk(KERN_DEBUG LOGNAME
! 1071: ": Delayed Video Decoder start\n");
1.1 cvs 1072: card->startingV = 0;
1073: DecoderStartDecode(card);
1.9 ! mocm 1074: DecoderSetVideoPanic(card, 1, 3);
! 1075: // video panic at 3 pictures
1.1 cvs 1076: //DecoderSetVideoPanic(card, 0, DecoderGetVideoESSize(card) / 4); // video panic at 25 percent
1077: }
1078: }
1079: a = DecoderGetAudioESLevel(card);
1080: if (card->startingA) {
1081: as = card->AudioESSize;
1082: if (as > 0) ap = (100 * a) / as;
1083: else ap = 0;
1.4 mocm 1084: if (ap > 40) {
1.9 ! mocm 1085: printk(KERN_DEBUG LOGNAME
! 1086: ": Delayed Audio Decoder start\n");
1.6 mocm 1087: AudioSetPlayMode(card, MAUDIO_PLAY);
1.1 cvs 1088: if (!AudioStart(card)) {
1089: card->startingA = 0;
1090: }
1091: }
1092: }
1093: if (card->fields >= 250) { // 5 seconds (PAL)
1094: SCR_base = DecoderReadSCR(card, 0x009);
1095: SCR_compareA = DecoderReadSCR(card, 0x014);
1096: SCR_compareV = DecoderReadSCR(card, 0x00D);
1097: if (DecoderReadByte(card, 0x013) & 0x03)
1098: card->fields = 0;
1099: }
1100: }
1101:
1102: if (intr[0] & 0x04) { // First Slice Start Code
1103: if (card->showvideo) {
1104: // Unmute card video if first picture slice detected
1105: VideoSetBackground(card, 0, 0, 0, 0); // Video on black
1106: card->showvideo = 0;
1107: }
1108: }
1109:
1110: if (intr[0] & 0x02 ) { // Aux/User Data Fifo
1111: used = 0;
1112: while ( (used++ < 1000) &&
1113: (layer = DecoderReadByte(card, 0x040)) & 0x03){
1.9 ! mocm 1114: card->AuxFifo[card->AuxFifoHead] =
! 1115: ((layer << 6) & 0x0700) |
! 1116: DecoderReadByte(card, 0x043);
! 1117: card->AuxFifoHead = (card->AuxFifoHead + 1) &
! 1118: FIFO_MASK;
1.1 cvs 1119: }
1120: if (used < 1000) DecoderReadAuxFifo(card);
1121: used = 0;
1122:
1123: while ( (used++ < 1000) &&
1124: (layer = DecoderReadByte(card, 0x041)) & 0x03){
1.9 ! mocm 1125: card->DataFifo[card->DataFifoHead] =
! 1126: ((layer << 6) & 0x0300) |
! 1127: DecoderReadByte(card, 0x043);
! 1128: card->DataFifoHead = (card->DataFifoHead + 1)
! 1129: & FIFO_MASK;
1.1 cvs 1130: }
1131: if (used < 1000 ) DecoderReadDataFifo(card);
1132: }
1133:
1.9 ! mocm 1134: if ((intr[0] & 0x01) != card->intdecodestatus) {
! 1135: // decode status
1.1 cvs 1136: card->intdecodestatus = intr[0] & 0x01;
1.9 ! mocm 1137: printk(KERN_DEBUG LOGNAME
! 1138: ": Int - decode status now %s\n",
! 1139: ((card->intdecodestatus) ?
! 1140: "running" : "stopped"));
1.1 cvs 1141: if (card->intdecodestatus) { // now running
1.9 ! mocm 1142: DecoderSetVideoPanic(card, 1, 3);
! 1143: // video panic at 3 pictures
! 1144: card->showvideo = 1;
1.1 cvs 1145: } else { // now stopped
1146: if (card->closing) {
1147: card->closing = 0;
1148: CloseCard(card);
1149: }
1150: }
1151:
1152: }
1153:
1154: if (intr[1] & 0x10) { // Begin Active Video
1155: if (card->highlight_valid) {
1.9 ! mocm 1156: for (i = 0; i < 10; i++)
! 1157: DecoderWriteByte(card, 0x1C0 + i,
! 1158: card->highlight[i]);
1.1 cvs 1159: card->highlight_valid = 0;
1160: }
1161: }
1.9 ! mocm 1162: if (intr[1] & 0x08) { // SPU Start Code Detected
! 1163: printk(KERN_DEBUG LOGNAME
! 1164: ": Int - SPU Start Code Detected\n");
! 1165: }
! 1166:
1.1 cvs 1167: if (intr[1] & 0x04) { // SCR compare audio
1.9 ! mocm 1168: printk(KERN_DEBUG LOGNAME
! 1169: ": Int - SCR compare audio\n");
1.1 cvs 1170: DecoderDelByte(card, 0x013, 0x01);
1171: AudioStart(card);
1172: }
1173:
1174: if (intr[2] & 0x20) { // DSI PES data ready
1175: DecoderReadNavipack(card);
1176: }
1177:
1178: if (intr[2] & 0x06) { // Audio / Video PES data ready
1.9 ! mocm 1179: ReadPESHeaders(card);
1.1 cvs 1180: }
1181:
1182: if (intr[3] & 0x40) { // CSS
1183: card->css.status = DecoderReadByte(card, 0x0B0);
1.9 ! mocm 1184: if (card->css.status&0x01)
! 1185: card->css.ChallengeReady = 1;
! 1186: // challenge ready
! 1187: if (card->css.status&0x02)
! 1188: card->css.ResponseReady = 1;
! 1189: // response ready
! 1190: if (card->css.status&0x04)
! 1191: card->css.DiskKey = 1;
! 1192: // Disk key ready
! 1193: if (card->css.status&0x08)
! 1194: card->css.Error = 1;
! 1195: // Disk key error
! 1196: if (card->css.status&0x10)
! 1197: card->css.TitleKey = 1;
! 1198: // Title key ready
! 1199: if (card->css.status&0x20)
! 1200: card->css.TitleKeyDiff = 1;
! 1201: // Title key error
1.1 cvs 1202: }
1203:
1204:
1.9 ! mocm 1205: if (intr[3] & 0x30) {
! 1206: // Audio/Video ES channel buffer underflow
! 1207: printk(KERN_DEBUG LOGNAME
! 1208: ": Int - ES channel buffer underflow\n");
1.1 cvs 1209: if (card->closing) {
1210: card->closing = 0;
1211: CloseCard(card);
1.9 ! mocm 1212: }
1.1 cvs 1213: }
1214:
1215: if (intr[4] & 0x10 ) { // SPU decode error
1.9 ! mocm 1216: printk(KERN_DEBUG LOGNAME
! 1217: ": Int - SPU decode error: (1CA)=0x%02X\n",
! 1218: DecoderReadByte(card, 0x1CA));
1.1 cvs 1219: DecoderDelByte(card, 0x1A0, 0x01); // SPU decode stop
1220: DecoderSetByte(card, 0x1A0, 0x01); // SPU decode start
1221: }
1222:
1223: // Audio / Video Syncronisation
1224:
1.8 mocm 1225: if (card->videosync && !card->videoskip && !card->videodelay) {
1.1 cvs 1226: SCR_base = DecoderReadSCR(card, 0x009);
1227: SCR_compareV = DecoderReadSCR(card, 0x00D);
1228: if (intr[1] & 0x02) { // picture start code detected
1.9 ! mocm 1229: DecoderMaskByte(card, 0x011, 0x03, 0x01);
! 1230: // Set SCR compare/capture mode to capture
! 1231: DecoderSetByte(card, 0x11, 0x04);
! 1232: // Set "capture on picture start"
! 1233: if (intr[1] & 0x01) {
! 1234: // audio sync code detected
! 1235: DecoderSetByte(card, 0x11, 0x08);
! 1236: // Set "capture on audio sync code"
1.1 cvs 1237: }
1238: VideoAddr = DecoderReadRWAddr(card,0x080);
1.9 ! mocm 1239: if (PTSGetPTS(&card->VideoPTSStore, VideoAddr,
! 1240: &PTS)) {
1.1 cvs 1241: card->oldVPTS = card->VPTS;
1242: card->VPTS = PTS;
1.9 ! mocm 1243: card->VSCR = ((long)SCR_compareV
! 1244: - (long)PTS) / 2;
1.1 cvs 1245: // card->VideoTime = ISRTime;
1246: }
1.9 ! mocm 1247: } else if (intr[1] & 0x01) {
! 1248: // audio sync code detected
! 1249: DecoderMaskByte(card, 0x011, 0x03, 0x01);
! 1250: // Set SCR compare/capture mode to capture
! 1251: DecoderSetByte(card, 0x11, 0x08);
! 1252: // Set "capture on audio sync code"
1.1 cvs 1253: AudioAddr = DecoderReadRWAddr(card,0x083);
1.9 ! mocm 1254: if (PTSGetPTS(&card->AudioPTSStore, AudioAddr,
! 1255: &PTS)) {
1.1 cvs 1256: card->oldAPTS = card->APTS;
1257: card->APTS = PTS;
1.9 ! mocm 1258: card->ASCR = ((long)SCR_compareV -
! 1259: (long)PTS) / 2;
1.1 cvs 1260: } else {
1261: card->ASCR = 0x7FFFFFFF;
1262: }
1.9 ! mocm 1263:
1.1 cvs 1264: if (card->VSCR != 0x7FFFFFFF) {
1265: if (card->ASCR != 0x7FFFFFFF) {
1.9 ! mocm 1266: DeltaSyncTime = ISRTime -
! 1267: card->SyncTime;
1.1 cvs 1268: card->SyncTime = ISRTime;
1269:
1.9 ! mocm 1270: // Calculate Audio and Video SCR difference
! 1271: Offset = (card->ASCR -
! 1272: card->VSCR -
! 1273: (10 * 736)) / 736;
1.1 cvs 1274:
1.9 ! mocm 1275: // if the APTS and SCR are off update SCR to keep SubPic synced
! 1276: if ((SCR_compareV > card->APTS)
! 1277: || ((card->APTS -
! 1278: SCR_compareV) >
! 1279: 10000)) {
1.1 cvs 1280: Offset = 0;
1.9 ! mocm 1281: SetSCR(card,
! 1282: card->APTS);
1.1 cvs 1283: }
1284:
1285: // if more than 3 frames away
1.9 ! mocm 1286: if ((Offset > 3) ||
! 1287: (Offset < -3)) {
1.1 cvs 1288: if (Offset > 0 ) {
1289: card->videodelay = 0;
1290: if (Offset < 100) {
1291: if (Offset < 10) {
1292: card->videodelay = 1;
1293: } else {
1294: card->videodelay = Offset / 2;
1295: if (card->videodelay > 20) {
1296: card->videodelay = 20;
1297: }
1298: }
1.9 ! mocm 1299: printk(KERN_DEBUG LOGNAME ": <<< Pausing %d\n", card->videodelay);
1.1 cvs 1300: } else {
1301: }
1302: } else {
1.8 mocm 1303: card->videoskip = 0;
1.1 cvs 1304: if (Offset > -100) {
1305: if (Offset < -10) {
1.8 mocm 1306: card->videoskip = 10;
1.1 cvs 1307: } else {
1.8 mocm 1308: card->videoskip = 3;
1.1 cvs 1309: }
1.8 mocm 1310: printk(KERN_DEBUG LOGNAME ": >>> FForward %d\n", card->videoskip);
1.1 cvs 1311: }
1312: }
1313: } else {
1314: }
1315: card->VSCR = 0x7FFFFFFF;
1316: }
1317: }
1318: }
1319: }
1320: }
1321: DecoderWriteByte(card, 0x006, 0x01); // Clear Interrupt Pin
1322: }
1323:
1324: // Enable the IRQ Masks
1325: void L64021InstallIntr(struct cvdv_cards *card) {
1326: u8 data;
1327:
1328: data=0;
1329: data |= 0x80; // new field
1330: data |= 0x40; // audio sync recovery
1331: data |= 0x20; // SPU SCR compare
1332: // data |= 0x10; // SDRAM Transfer Done
1333: // data |= 0x08; // Sequence End Code Detect
1334: data |= 0x04; // First Slice Start Code
1335: data |= 0x02; // Aux/User Data Fifo
1336: data |= 0x01; // decode status
1337: DecoderWriteByte(card, 0x000, (~data) & 0xFF);
1338:
1339: data = 0;
1340: // data |= 0x80; // SCR compare
1341: // data |= 0x40; // SCR Overflow
1342: // data |= 0x20; // Begin Vertical Blank
1343: data |= 0x10; // Begin Active Video
1344: data |= 0x08; // SPU Start Code Detected
1345: data |= 0x04; // SCR compare audio
1346: data |= 0x02; // picture start code detected
1347: data |= 0x01; // audio sync code detected
1348: DecoderWriteByte(card, 0x001, (~data) & 0xFF);
1349:
1350: data = 0;
1351: // data |= 0x80; // DTS video event
1352: // data |= 0x40; // DTS audio event
1353: data |= 0x20; // DSI PES data ready
1354: // data |= 0x10; // Seq end code in video channel
1355: data |= 0x08; // SPU PES data ready
1356: data |= 0x04; // Video PES data ready
1357: data |= 0x02; // Audio PES data ready
1358: // data |= 0x01; // Pack data ready
1359: DecoderWriteByte(card, 0x002, (~data) & 0xFF);
1360:
1361: data = 0;
1362: // data |= 0x80; // Reserved
1363: data |= 0x40; // CSS
1364: data |= 0x20; // Video ES channel buffer underflow
1365: data |= 0x10; // Audio ES channel buffer underflow
1366: // data |= 0x08; // Data Dump channel PES data ready
1367: data |= 0x04; // SPU channel buffer overflow
1.9 ! mocm 1368: //data |= 0x02; // Video ES channel buffer overflow
! 1369: //data |= 0x01; // Audio ES channel buffer overflow
1.1 cvs 1370: DecoderWriteByte(card, 0x003, (~data) & 0xFF);
1371:
1372: data = 0;
1373: // data |= 0x80; // S/PDIF channel buffer underflow
1374: // data |= 0x40; // packet error
1375: // data |= 0x20; // reserved
1376: data |= 0x10; // SPU decode error
1377: // data |= 0x08; // Audio Sync error
1378: // data |= 0x04; // Audio CRC or illegal bit error
1379: // data |= 0x02; // context error
1380: // data |= 0x01; // VLC or Run length error
1381: DecoderWriteByte(card, 0x004, (~data) & 0xFF);
1382: card->IntInstalled = 1;
1383: }
1384:
1385: int L64021RemoveIntr(struct cvdv_cards *card) {
1386: // Disable the IRQ Masks
1387: DecoderWriteByte(card, 0x000, 0xFF); // No ints
1388: DecoderWriteByte(card, 0x001, 0xFF); // No ints
1389: DecoderWriteByte(card, 0x002, 0xFF); // No ints
1390: DecoderWriteByte(card, 0x003, 0xFF); // No ints
1391: DecoderWriteByte(card, 0x004, 0xFF); // No ints
1392: card->IntInstalled = 0;
1393: return 0;
1394: }
1395:
1396: int L64021Reset(struct cvdv_cards *card) {
1397: L64021RemoveIntr(card); // Stop interrupts
1398: // Reset
1399: printk(KERN_DEBUG LOGNAME ": L64021 Software reset...\n");
1400: //DecoderSetByte(card, 0x007, 0x20); // reset on
1401: DecoderMaskByte(card, 0x007, 0xE2, 0xE2); // reset on
1402: while (!(DecoderReadByte(card, 0x007) & 0x02)) ; // wait until reset is done
1403: //DecoderDelByte(card, 0x007, 0x20); // reset off
1404: DecoderMaskByte(card, 0x007, 0xE2, 0xC2); // reset off
1405: printk(KERN_DEBUG LOGNAME ": L64021 Software reset done.\n");
1406: DecoderStopChannel(card);
1407: DecoderStopDecode(card);
1408: DecoderStreamReset(card);
1409: DecoderSetupReset(card);
1410: printk(KERN_INFO LOGNAME ": L64021 Rev. 0x%02X reset successfully.\n", DecoderReadByte(card, 0x0F5));
1411: return 0;
1412: }
1413:
1414: int L64021Setup(struct cvdv_cards *card) {
1415: printk(KERN_DEBUG LOGNAME ": -- L64021Setup\n");
1416: DecoderWriteByte(card, 0x0C1, 0x88); //
1417: switch (card->videomode) {
1418: case NTSC: // NTSC M, N. America, Taiwan, Japan
1419: DecoderMaskByte(card, 0x122, 0x03, 0x01); // Television Standard: NTSC
1420: /* Default values:
1421: DecoderWriteByte(card, 0x116, 90); // Main Reads per Line
1422: DecoderWriteByte(card, 0x11A, 4); // Vline Count Init
1423: DecoderWriteByte(card, 0x11C, 0x13); // Pixel State Reset Value / BT.656 Mode / Sync Active Low
1424: DecoderWriteByte(card, 0x129, 23); // Start- and End Row
1425: DecoderWriteByte(card, 0x12A, 262 & 0xFF);
1426: DecoderWriteByte(card, 0x12B, (262>>4)&0x70);
1427: DecoderWriteByte(card, 0x12C, 244 & 0xFF); // Start- and End Column
1428: DecoderWriteByte(card, 0x12D, 1683 & 0xFF);
1429: DecoderWriteByte(card, 0x12E, ((1683>>4)&0x70)|((244>>8)&0x07));
1430: DecoderWriteByte(card, 0x132, 240 & 0xFF); // SAV Column
1431: DecoderWriteByte(card, 0x133, 1684 & 0xFF); // EAV Column
1432: DecoderWriteByte(card, 0x134, ((1684>>4)&0x70)|((240>>8)&0x07));
1433: DecoderWriteByte(card, 0x12F, (21&0x1F)|((262>>3)&0x20)|(1<<6)|((265>>1)&0x80)); // VCode Zero...
1434: DecoderWriteByte(card, 0x130, 262&0xFF); // ... and VCode Even
1435: DecoderWriteByte(card, 0x131, 265&0xFF); // ... and FCode
1436: */
1437: break;
1438: case PAL: // PAL-B, D, G, H, I, Europe, Asia
1439: DecoderMaskByte(card, 0x122, 0x03, 0x02); // Television Standard: PAL
1440: /* Default values:
1441: DecoderWriteByte(card, 0x116, 90); // Main Reads per Line
1442: DecoderWriteByte(card, 0x11A, 1); // Vline Count Init
1443: DecoderWriteByte(card, 0x11C, 0x13); // Pixel State Reset Value / BT.656 Mode / Sync Active Low
1444: DecoderWriteByte(card, 0x129, 23); // Start- and End Row
1445: DecoderWriteByte(card, 0x12A, 310 & 0xFF);
1446: DecoderWriteByte(card, 0x12B, (310>>4)&0x70);
1447: DecoderWriteByte(card, 0x12C, 264 & 0xFF); // Start- and End Column
1448: DecoderWriteByte(card, 0x12D, 1703 & 0xFF);
1449: DecoderWriteByte(card, 0x12E, ((1703>>4)&0x70)|((264>>8)&0x07));
1450: DecoderWriteByte(card, 0x132, 260 & 0xFF); // SAV Column
1451: DecoderWriteByte(card, 0x133, 1704 & 0xFF); // EAV Column
1452: DecoderWriteByte(card, 0x134, ((1704>>4)&0x70)|((260>>8)&0x07));
1453: DecoderWriteByte(card, 0x12F, (21&0x1F)|((310>>3)&0x20)|(0<<6)|((312>>1)&0x80)); // VCode Zero...
1454: DecoderWriteByte(card, 0x130, 310&0xFF); // ... and VCode Even
1455: DecoderWriteByte(card, 0x131, 312&0xFF); // ... and FCode
1456: */
1457: break;
1458: case PAL60: // PAL 60Hz
1459: case NTSC60: // NTSC 60Hz, USA HDTV
1460: case PALM: // PAL-M normal, Brazil
1461: case PALM60: // PAL-M HDTV, Brazil
1462: case PALN: // PAL-N, Uruguay, Paraguay
1463: case PALNc: // PAL-Nc, Argentinia
1464: default: // TODO: set mode according to other standards
1465: DecoderMaskByte(card, 0x122, 0x03, 0x00); // Television Standard: User programmed
1466: DecoderWriteByte(card, 0x116, 90); // Main Reads per Line
1467: DecoderWriteByte(card, 0x11A, 1); // Vline Count Init
1468: DecoderWriteByte(card, 0x11C, 0x13); // Pixel State Reset Value / BT.656 Mode / Sync Active Low
1469: DecoderWriteByte(card, 0x129, 23); // Start- and End Row
1470: DecoderWriteByte(card, 0x12A, 310 & 0xFF);
1471: DecoderWriteByte(card, 0x12B, (310>>4)&0x70);
1472: DecoderWriteByte(card, 0x12C, 264 & 0xFF); // Start- and End Column
1473: DecoderWriteByte(card, 0x12D, 1703 & 0xFF);
1474: DecoderWriteByte(card, 0x12E, ((1703>>4)&0x70)|((264>>8)&0x07));
1475: DecoderWriteByte(card, 0x132, 260 & 0xFF); // SAV Column
1476: DecoderWriteByte(card, 0x133, 1704 & 0xFF); // EAV Column
1477: DecoderWriteByte(card, 0x134, ((1704>>4)&0x70)|((260>>8)&0x07));
1478: DecoderWriteByte(card, 0x12F, (21&0x1F)|((310>>3)&0x20)|(0<<6)|((312>>1)&0x80)); // VCode Zero...
1479: DecoderWriteByte(card, 0x130, 310&0xFF); // ... and VCode Even
1480: DecoderWriteByte(card, 0x131, 312&0xFF); // ... and FCode
1481: break;
1482: }
1483: DecoderWriteByte(card, 0x045, 0x00); // disable compares and panic mode
1484: DecoderWriteByte(card, 0x094, 0x00); // disable TOS Detect
1485: DecoderMaskByte(card, 0x109, 0x30, 0x00); // Display Override off, don't change OSD, Background
1486: DecoderWriteByte(card, 0x112, 0x00); // Disable Horizontal 2:1 Filter
1487: DecoderWriteByte(card, 0x113, 0x14); // FreezeMode 1 / 3:2 Pulldown / Repeat First Field / Top Field First
1488: DecoderWriteByte(card, 0x114, ( 5 <<3)|( 0 <<1)|( 0 <<2)|( 1 <<7)); // VideoMode/FilterEnable/FilterAB/FieldSyncEnable
1489: DecoderWriteByte(card, 0x115, 0); // Horizontal Filter Scale
1490: DecoderWriteByte(card, 0x117, 0x80); // Automatic Field Inversion Correction
1491: // DecoderWriteByte(card, 0x117, 0x00); // no Automatic Field Inversion Correction
1492: DecoderWriteByte(card, 0x118, 0); // Horizontal Pan and Scan Word Offset (signed)
1493: DecoderWriteByte(card, 0x119, 0); // Vertical Pan and Scan Line Offset
1494: DecoderWriteByte(card, 0x11B, 0x00); // Override Picture Width
1495: // if (0) { // letterbox
1496: // DecoderWriteByte(card, 0x114, (DecoderReadByte(card, 0x114) & ~0x78) | 0x40); // mode 8
1497: // DecoderWriteByte(card, 0x129, 0x35);
1498: // DecoderWriteByte(card, 0x12A, 0xE7);
1499: // DecoderWriteByte(card, 0x114, DecoderReadByte(card, 0x114) & ~0x77); // ???
1500: // } else {
1501: // if (0) { // MPEG-1
1502: // DecoderWriteByte(card, 0x114, (DecoderReadByte(card, 0x114) & ~0x78) | 0x10); // mode 2
1503: // } else { // MPEG-2
1504: // DecoderWriteByte(card, 0x114, (DecoderReadByte(card, 0x114) & ~0x78) | 0x28); // mode 5
1505: // }
1506: // }
1507: L64021InstallIntr(card); // Set the interrupt masks, again
1508:
1509: return 0;
1510: }
1511:
1512: int L64021Init(struct cvdv_cards *card) {
1513: printk(KERN_DEBUG LOGNAME ": -- L64021Init\n");
1514: L64021Reset(card);
1515: L64021Setup(card);
1516: VideoSetBackground(card, 1, 0, 0, 0); // black
1517: DecoderWriteByte(card, 0x135, 0x01); // Enable Video Out, Disable SPU Mix
1518: DecoderWriteByte(card,0x11C,0x13); // Pixel State Reset Value / BT.656 Mode / Sync Active Low
1519: L64021InstallIntr(card);
1520: return 0;
1521: }
1522:
1523: