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