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