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