2 Vertical Blank Interval support functions
3 Copyright (C) 2004-2007 Hans Verkuil <hverkuil@xs4all.nl>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #include "ivtv-driver.h"
22 #include "ivtv-ioctl.h"
23 #include "ivtv-queue.h"
24 #include "ivtv-cards.h"
27 static void ivtv_set_vps(struct ivtv
*itv
, int enabled
)
29 struct v4l2_sliced_vbi_data data
;
31 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
33 data
.id
= V4L2_SLICED_VPS
;
35 data
.line
= enabled
? 16 : 0;
36 data
.data
[2] = itv
->vbi
.vps_payload
.data
[0];
37 data
.data
[8] = itv
->vbi
.vps_payload
.data
[1];
38 data
.data
[9] = itv
->vbi
.vps_payload
.data
[2];
39 data
.data
[10] = itv
->vbi
.vps_payload
.data
[3];
40 data
.data
[11] = itv
->vbi
.vps_payload
.data
[4];
41 ivtv_call_hw(itv
, IVTV_HW_SAA7127
, vbi
, s_vbi_data
, &data
);
44 static void ivtv_set_cc(struct ivtv
*itv
, int mode
, const struct vbi_cc
*cc
)
46 struct v4l2_sliced_vbi_data data
;
48 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
50 data
.id
= V4L2_SLICED_CAPTION_525
;
52 data
.line
= (mode
& 1) ? 21 : 0;
53 data
.data
[0] = cc
->odd
[0];
54 data
.data
[1] = cc
->odd
[1];
55 ivtv_call_hw(itv
, IVTV_HW_SAA7127
, vbi
, s_vbi_data
, &data
);
57 data
.line
= (mode
& 2) ? 21 : 0;
58 data
.data
[0] = cc
->even
[0];
59 data
.data
[1] = cc
->even
[1];
60 ivtv_call_hw(itv
, IVTV_HW_SAA7127
, vbi
, s_vbi_data
, &data
);
63 static void ivtv_set_wss(struct ivtv
*itv
, int enabled
, int mode
)
65 struct v4l2_sliced_vbi_data data
;
67 if (!(itv
->v4l2_cap
& V4L2_CAP_VIDEO_OUTPUT
))
69 /* When using a 50 Hz system, always turn on the
70 wide screen signal with 4x3 ratio as the default.
71 Turning this signal on and off can confuse certain
72 TVs. As far as I can tell there is no reason not to
73 transmit this signal. */
74 if ((itv
->std_out
& V4L2_STD_625_50
) && !enabled
) {
76 mode
= 0x08; /* 4x3 full format */
78 data
.id
= V4L2_SLICED_WSS_625
;
80 data
.line
= enabled
? 23 : 0;
81 data
.data
[0] = mode
& 0xff;
82 data
.data
[1] = (mode
>> 8) & 0xff;
83 ivtv_call_hw(itv
, IVTV_HW_SAA7127
, vbi
, s_vbi_data
, &data
);
86 static int odd_parity(u8 c
)
95 static void ivtv_write_vbi_line(struct ivtv
*itv
,
96 const struct v4l2_sliced_vbi_data
*d
,
97 struct vbi_cc
*cc
, int *found_cc
)
99 struct vbi_info
*vi
= &itv
->vbi
;
101 if (d
->id
== V4L2_SLICED_CAPTION_525
&& d
->line
== 21) {
103 cc
->even
[0] = d
->data
[0];
104 cc
->even
[1] = d
->data
[1];
106 cc
->odd
[0] = d
->data
[0];
107 cc
->odd
[1] = d
->data
[1];
110 } else if (d
->id
== V4L2_SLICED_VPS
&& d
->line
== 16 && d
->field
== 0) {
113 vps
.data
[0] = d
->data
[2];
114 vps
.data
[1] = d
->data
[8];
115 vps
.data
[2] = d
->data
[9];
116 vps
.data
[3] = d
->data
[10];
117 vps
.data
[4] = d
->data
[11];
118 if (memcmp(&vps
, &vi
->vps_payload
, sizeof(vps
))) {
119 vi
->vps_payload
= vps
;
120 set_bit(IVTV_F_I_UPDATE_VPS
, &itv
->i_flags
);
122 } else if (d
->id
== V4L2_SLICED_WSS_625
&&
123 d
->line
== 23 && d
->field
== 0) {
124 int wss
= d
->data
[0] | d
->data
[1] << 8;
126 if (vi
->wss_payload
!= wss
) {
127 vi
->wss_payload
= wss
;
128 set_bit(IVTV_F_I_UPDATE_WSS
, &itv
->i_flags
);
133 static void ivtv_write_vbi_cc_lines(struct ivtv
*itv
, const struct vbi_cc
*cc
)
135 struct vbi_info
*vi
= &itv
->vbi
;
137 if (vi
->cc_payload_idx
< ARRAY_SIZE(vi
->cc_payload
)) {
138 memcpy(&vi
->cc_payload
[vi
->cc_payload_idx
], cc
,
139 sizeof(struct vbi_cc
));
140 vi
->cc_payload_idx
++;
141 set_bit(IVTV_F_I_UPDATE_CC
, &itv
->i_flags
);
145 static void ivtv_write_vbi(struct ivtv
*itv
,
146 const struct v4l2_sliced_vbi_data
*sliced
,
149 struct vbi_cc cc
= { .odd
= { 0x80, 0x80 }, .even
= { 0x80, 0x80 } };
153 for (i
= 0; i
< cnt
; i
++)
154 ivtv_write_vbi_line(itv
, sliced
+ i
, &cc
, &found_cc
);
157 ivtv_write_vbi_cc_lines(itv
, &cc
);
161 ivtv_write_vbi_from_user(struct ivtv
*itv
,
162 const struct v4l2_sliced_vbi_data __user
*sliced
,
165 struct vbi_cc cc
= { .odd
= { 0x80, 0x80 }, .even
= { 0x80, 0x80 } };
168 struct v4l2_sliced_vbi_data d
;
169 ssize_t ret
= cnt
* sizeof(struct v4l2_sliced_vbi_data
);
171 for (i
= 0; i
< cnt
; i
++) {
172 if (copy_from_user(&d
, sliced
+ i
,
173 sizeof(struct v4l2_sliced_vbi_data
))) {
177 ivtv_write_vbi_line(itv
, &d
, &cc
, &found_cc
);
181 ivtv_write_vbi_cc_lines(itv
, &cc
);
186 static void copy_vbi_data(struct ivtv
*itv
, int lines
, u32 pts_stamp
)
190 u32 linemask
[2] = { 0, 0 };
192 static const u8 mpeg_hdr_data
[] = {
193 0x00, 0x00, 0x01, 0xba, 0x44, 0x00, 0x0c, 0x66,
194 0x24, 0x01, 0x01, 0xd1, 0xd3, 0xfa, 0xff, 0xff,
195 0x00, 0x00, 0x01, 0xbd, 0x00, 0x1a, 0x84, 0x80,
196 0x07, 0x21, 0x00, 0x5d, 0x63, 0xa7, 0xff, 0xff
198 const int sd
= sizeof(mpeg_hdr_data
); /* start of vbi data */
199 int idx
= itv
->vbi
.frame
% IVTV_VBI_FRAMES
;
200 u8
*dst
= &itv
->vbi
.sliced_mpeg_data
[idx
][0];
202 for (i
= 0; i
< lines
; i
++) {
205 if (itv
->vbi
.sliced_data
[i
].id
== 0)
208 l
= itv
->vbi
.sliced_data
[i
].line
- 6;
209 f
= itv
->vbi
.sliced_data
[i
].field
;
213 linemask
[0] |= (1 << l
);
215 linemask
[1] |= (1 << (l
- 32));
216 dst
[sd
+ 12 + line
* 43] =
217 ivtv_service2vbi(itv
->vbi
.sliced_data
[i
].id
);
218 memcpy(dst
+ sd
+ 12 + line
* 43 + 1, itv
->vbi
.sliced_data
[i
].data
, 42);
221 memcpy(dst
, mpeg_hdr_data
, sizeof(mpeg_hdr_data
));
223 /* All lines are used, so there is no space for the linemask
224 (the max size of the VBI data is 36 * 43 + 4 bytes).
225 So in this case we use the magic number 'ITV0'. */
226 memcpy(dst
+ sd
, "ITV0", 4);
227 memcpy(dst
+ sd
+ 4, dst
+ sd
+ 12, line
* 43);
228 size
= 4 + ((43 * line
+ 3) & ~3);
230 memcpy(dst
+ sd
, "itv0", 4);
231 cpu_to_le32s(&linemask
[0]);
232 cpu_to_le32s(&linemask
[1]);
233 memcpy(dst
+ sd
+ 4, &linemask
[0], 8);
234 size
= 12 + ((43 * line
+ 3) & ~3);
236 dst
[4+16] = (size
+ 10) >> 8;
237 dst
[5+16] = (size
+ 10) & 0xff;
238 dst
[9+16] = 0x21 | ((pts_stamp
>> 29) & 0x6);
239 dst
[10+16] = (pts_stamp
>> 22) & 0xff;
240 dst
[11+16] = 1 | ((pts_stamp
>> 14) & 0xff);
241 dst
[12+16] = (pts_stamp
>> 7) & 0xff;
242 dst
[13+16] = 1 | ((pts_stamp
& 0x7f) << 1);
243 itv
->vbi
.sliced_mpeg_size
[idx
] = sd
+ size
;
246 static int ivtv_convert_ivtv_vbi(struct ivtv
*itv
, u8
*p
)
252 if (!memcmp(p
, "itv0", 4)) {
253 memcpy(linemask
, p
+ 4, 8);
255 } else if (!memcmp(p
, "ITV0", 4)) {
256 linemask
[0] = 0xffffffff;
260 /* unknown VBI data, convert to empty VBI frame */
261 linemask
[0] = linemask
[1] = 0;
263 for (i
= 0; i
< 36; i
++) {
266 if (i
< 32 && !(linemask
[0] & (1 << i
)))
268 if (i
>= 32 && !(linemask
[1] & (1 << (i
- 32))))
272 case IVTV_SLICED_TYPE_TELETEXT_B
:
273 id2
= V4L2_SLICED_TELETEXT_B
;
275 case IVTV_SLICED_TYPE_CAPTION_525
:
276 id2
= V4L2_SLICED_CAPTION_525
;
277 err
= !odd_parity(p
[1]) || !odd_parity(p
[2]);
279 case IVTV_SLICED_TYPE_VPS
:
280 id2
= V4L2_SLICED_VPS
;
282 case IVTV_SLICED_TYPE_WSS_625
:
283 id2
= V4L2_SLICED_WSS_625
;
290 l
= (i
< 18) ? i
+ 6 : i
- 18 + 6;
291 itv
->vbi
.sliced_dec_data
[line
].line
= l
;
292 itv
->vbi
.sliced_dec_data
[line
].field
= i
>= 18;
293 itv
->vbi
.sliced_dec_data
[line
].id
= id2
;
294 memcpy(itv
->vbi
.sliced_dec_data
[line
].data
, p
+ 1, 42);
300 itv
->vbi
.sliced_dec_data
[line
].id
= 0;
301 itv
->vbi
.sliced_dec_data
[line
].line
= 0;
302 itv
->vbi
.sliced_dec_data
[line
].field
= 0;
305 return line
* sizeof(itv
->vbi
.sliced_dec_data
[0]);
308 /* Compress raw VBI format, removes leading SAV codes and surplus space after the
310 Returns new compressed size. */
311 static u32
compress_raw_buf(struct ivtv
*itv
, u8
*buf
, u32 size
)
313 u32 line_size
= itv
->vbi
.raw_decoder_line_size
;
314 u32 lines
= itv
->vbi
.count
;
315 u8 sav1
= itv
->vbi
.raw_decoder_sav_odd_field
;
316 u8 sav2
= itv
->vbi
.raw_decoder_sav_even_field
;
321 for (i
= 0; i
< lines
; i
++) {
322 p
= buf
+ i
* line_size
;
324 /* Look for SAV code */
325 if (p
[0] != 0xff || p
[1] || p
[2] || (p
[3] != sav1
&& p
[3] != sav2
)) {
328 memcpy(q
, p
+ 4, line_size
- 4);
331 return lines
* (line_size
- 4);
335 /* Compressed VBI format, all found sliced blocks put next to one another
336 Returns new compressed size */
337 static u32
compress_sliced_buf(struct ivtv
*itv
, u32 line
, u8
*buf
, u32 size
, u8 sav
)
339 u32 line_size
= itv
->vbi
.sliced_decoder_line_size
;
340 struct v4l2_decode_vbi_line vbi
;
344 /* find the first valid line */
345 for (i
= 0; i
< size
; i
++, buf
++) {
346 if (buf
[0] == 0xff && !buf
[1] && !buf
[2] && buf
[3] == sav
)
351 if (size
< line_size
) {
354 for (i
= 0; i
< size
/ line_size
; i
++) {
355 u8
*p
= buf
+ i
* line_size
;
357 /* Look for SAV code */
358 if (p
[0] != 0xff || p
[1] || p
[2] || p
[3] != sav
) {
362 v4l2_subdev_call(itv
->sd_video
, vbi
, decode_vbi_line
, &vbi
);
363 if (vbi
.type
&& !(lines
& (1 << vbi
.line
))) {
364 lines
|= 1 << vbi
.line
;
365 itv
->vbi
.sliced_data
[line
].id
= vbi
.type
;
366 itv
->vbi
.sliced_data
[line
].field
= vbi
.is_second_field
;
367 itv
->vbi
.sliced_data
[line
].line
= vbi
.line
;
368 memcpy(itv
->vbi
.sliced_data
[line
].data
, vbi
.p
, 42);
375 void ivtv_process_vbi_data(struct ivtv
*itv
, struct ivtv_buffer
*buf
,
376 u64 pts_stamp
, int streamtype
)
378 u8
*p
= (u8
*) buf
->buf
;
379 u32 size
= buf
->bytesused
;
383 if (streamtype
== IVTV_ENC_STREAM_TYPE_VBI
&& ivtv_raw_vbi(itv
)) {
390 size
= buf
->bytesused
= compress_raw_buf(itv
, p
, size
);
392 /* second field of the frame? */
393 if (type
== itv
->vbi
.raw_decoder_sav_even_field
) {
394 /* Dirty hack needed for backwards
395 compatibility of old VBI software. */
397 memcpy(p
, &itv
->vbi
.frame
, 4);
403 /* Sliced VBI data with data insertion */
404 if (streamtype
== IVTV_ENC_STREAM_TYPE_VBI
) {
410 lines
= compress_sliced_buf(itv
, 0, p
, size
/ 2,
411 itv
->vbi
.sliced_decoder_sav_odd_field
);
413 /* experimentation shows that the second half does not always begin
414 at the exact address. So start a bit earlier (hence 32). */
415 lines
= compress_sliced_buf(itv
, lines
, p
+ size
/ 2 - 32, size
/ 2 + 32,
416 itv
->vbi
.sliced_decoder_sav_even_field
);
417 /* always return at least one empty line */
419 itv
->vbi
.sliced_data
[0].id
= 0;
420 itv
->vbi
.sliced_data
[0].line
= 0;
421 itv
->vbi
.sliced_data
[0].field
= 0;
424 buf
->bytesused
= size
= lines
* sizeof(itv
->vbi
.sliced_data
[0]);
425 memcpy(p
, &itv
->vbi
.sliced_data
[0], size
);
427 if (itv
->vbi
.insert_mpeg
) {
428 copy_vbi_data(itv
, lines
, pts_stamp
);
434 /* Sliced VBI re-inserted from an MPEG stream */
435 if (streamtype
== IVTV_DEC_STREAM_TYPE_VBI
) {
436 /* If the size is not 4-byte aligned, then the starting address
437 for the swapping is also shifted. After swapping the data the
438 real start address of the VBI data is exactly 4 bytes after the
439 original start. It's a bit fiddly but it works like a charm.
440 Non-4-byte alignment happens when an lseek is done on the input
441 mpeg file to a non-4-byte aligned position. So on arrival here
442 the VBI data is also non-4-byte aligned. */
443 int offset
= size
& 3;
450 for (y
= 0; y
< size
; y
+= 4) {
451 swab32s((u32
*)(p
+ y
));
454 cnt
= ivtv_convert_ivtv_vbi(itv
, p
+ offset
);
455 memcpy(buf
->buf
, itv
->vbi
.sliced_dec_data
, cnt
);
456 buf
->bytesused
= cnt
;
458 ivtv_write_vbi(itv
, itv
->vbi
.sliced_dec_data
,
459 cnt
/ sizeof(itv
->vbi
.sliced_dec_data
[0]));
464 void ivtv_disable_cc(struct ivtv
*itv
)
466 struct vbi_cc cc
= { .odd
= { 0x80, 0x80 }, .even
= { 0x80, 0x80 } };
468 clear_bit(IVTV_F_I_UPDATE_CC
, &itv
->i_flags
);
469 ivtv_set_cc(itv
, 0, &cc
);
470 itv
->vbi
.cc_payload_idx
= 0;
474 void ivtv_vbi_work_handler(struct ivtv
*itv
)
476 struct vbi_info
*vi
= &itv
->vbi
;
477 struct v4l2_sliced_vbi_data data
;
478 struct vbi_cc cc
= { .odd
= { 0x80, 0x80 }, .even
= { 0x80, 0x80 } };
481 if (itv
->output_mode
== OUT_PASSTHROUGH
) {
483 data
.id
= V4L2_SLICED_WSS_625
;
486 if (v4l2_subdev_call(itv
->sd_video
, vbi
, g_vbi_data
, &data
) == 0) {
487 ivtv_set_wss(itv
, 1, data
.data
[0] & 0xf);
488 vi
->wss_missing_cnt
= 0;
489 } else if (vi
->wss_missing_cnt
== 4) {
490 ivtv_set_wss(itv
, 1, 0x8); /* 4x3 full format */
492 vi
->wss_missing_cnt
++;
498 data
.id
= V4L2_SLICED_CAPTION_525
;
500 if (v4l2_subdev_call(itv
->sd_video
, vbi
, g_vbi_data
, &data
) == 0) {
502 cc
.odd
[0] = data
.data
[0];
503 cc
.odd
[1] = data
.data
[1];
506 if (v4l2_subdev_call(itv
->sd_video
, vbi
, g_vbi_data
, &data
) == 0) {
508 cc
.even
[0] = data
.data
[0];
509 cc
.even
[1] = data
.data
[1];
512 vi
->cc_missing_cnt
= 0;
513 ivtv_set_cc(itv
, mode
, &cc
);
514 } else if (vi
->cc_missing_cnt
== 4) {
515 ivtv_set_cc(itv
, 0, &cc
);
517 vi
->cc_missing_cnt
++;
523 if (test_and_clear_bit(IVTV_F_I_UPDATE_WSS
, &itv
->i_flags
)) {
524 ivtv_set_wss(itv
, 1, vi
->wss_payload
& 0xf);
527 if (test_bit(IVTV_F_I_UPDATE_CC
, &itv
->i_flags
)) {
528 if (vi
->cc_payload_idx
== 0) {
529 clear_bit(IVTV_F_I_UPDATE_CC
, &itv
->i_flags
);
530 ivtv_set_cc(itv
, 3, &cc
);
532 while (vi
->cc_payload_idx
) {
533 cc
= vi
->cc_payload
[0];
535 memcpy(vi
->cc_payload
, vi
->cc_payload
+ 1,
536 sizeof(vi
->cc_payload
) - sizeof(vi
->cc_payload
[0]));
537 vi
->cc_payload_idx
--;
538 if (vi
->cc_payload_idx
&& cc
.odd
[0] == 0x80 && cc
.odd
[1] == 0x80)
541 ivtv_set_cc(itv
, 3, &cc
);
546 if (test_and_clear_bit(IVTV_F_I_UPDATE_VPS
, &itv
->i_flags
)) {
547 ivtv_set_vps(itv
, 1);