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