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