diff options
Diffstat (limited to 'drivers/media/video/ivtv/ivtv-vbi.c')
-rw-r--r-- | drivers/media/video/ivtv/ivtv-vbi.c | 549 |
1 files changed, 549 insertions, 0 deletions
diff --git a/drivers/media/video/ivtv/ivtv-vbi.c b/drivers/media/video/ivtv/ivtv-vbi.c new file mode 100644 index 00000000000..293db806d93 --- /dev/null +++ b/drivers/media/video/ivtv/ivtv-vbi.c | |||
@@ -0,0 +1,549 @@ | |||
1 | /* | ||
2 | Vertical Blank Interval support functions | ||
3 | Copyright (C) 2004-2007 Hans Verkuil <hverkuil@xs4all.nl> | ||
4 | |||
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. | ||
9 | |||
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. | ||
14 | |||
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 | ||
18 | */ | ||
19 | |||
20 | #include "ivtv-driver.h" | ||
21 | #include "ivtv-i2c.h" | ||
22 | #include "ivtv-ioctl.h" | ||
23 | #include "ivtv-queue.h" | ||
24 | #include "ivtv-cards.h" | ||
25 | #include "ivtv-vbi.h" | ||
26 | |||
27 | static void ivtv_set_vps(struct ivtv *itv, int enabled) | ||
28 | { | ||
29 | struct v4l2_sliced_vbi_data data; | ||
30 | |||
31 | if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) | ||
32 | return; | ||
33 | data.id = V4L2_SLICED_VPS; | ||
34 | data.field = 0; | ||
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); | ||
42 | } | ||
43 | |||
44 | static void ivtv_set_cc(struct ivtv *itv, int mode, const struct vbi_cc *cc) | ||
45 | { | ||
46 | struct v4l2_sliced_vbi_data data; | ||
47 | |||
48 | if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) | ||
49 | return; | ||
50 | data.id = V4L2_SLICED_CAPTION_525; | ||
51 | data.field = 0; | ||
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); | ||
56 | data.field = 1; | ||
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); | ||
61 | } | ||
62 | |||
63 | static void ivtv_set_wss(struct ivtv *itv, int enabled, int mode) | ||
64 | { | ||
65 | struct v4l2_sliced_vbi_data data; | ||
66 | |||
67 | if (!(itv->v4l2_cap & V4L2_CAP_VIDEO_OUTPUT)) | ||
68 | return; | ||
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) { | ||
75 | enabled = 1; | ||
76 | mode = 0x08; /* 4x3 full format */ | ||
77 | } | ||
78 | data.id = V4L2_SLICED_WSS_625; | ||
79 | data.field = 0; | ||
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); | ||
84 | } | ||
85 | |||
86 | static int odd_parity(u8 c) | ||
87 | { | ||
88 | c ^= (c >> 4); | ||
89 | c ^= (c >> 2); | ||
90 | c ^= (c >> 1); | ||
91 | |||
92 | return c & 1; | ||
93 | } | ||
94 | |||
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) | ||
98 | { | ||
99 | struct vbi_info *vi = &itv->vbi; | ||
100 | |||
101 | if (d->id == V4L2_SLICED_CAPTION_525 && d->line == 21) { | ||
102 | if (d->field) { | ||
103 | cc->even[0] = d->data[0]; | ||
104 | cc->even[1] = d->data[1]; | ||
105 | } else { | ||
106 | cc->odd[0] = d->data[0]; | ||
107 | cc->odd[1] = d->data[1]; | ||
108 | } | ||
109 | *found_cc = 1; | ||
110 | } else if (d->id == V4L2_SLICED_VPS && d->line == 16 && d->field == 0) { | ||
111 | struct vbi_vps vps; | ||
112 | |||
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); | ||
121 | } | ||
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; | ||
125 | |||
126 | if (vi->wss_payload != wss) { | ||
127 | vi->wss_payload = wss; | ||
128 | set_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags); | ||
129 | } | ||
130 | } | ||
131 | } | ||
132 | |||
133 | static void ivtv_write_vbi_cc_lines(struct ivtv *itv, const struct vbi_cc *cc) | ||
134 | { | ||
135 | struct vbi_info *vi = &itv->vbi; | ||
136 | |||
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); | ||
142 | } | ||
143 | } | ||
144 | |||
145 | static void ivtv_write_vbi(struct ivtv *itv, | ||
146 | const struct v4l2_sliced_vbi_data *sliced, | ||
147 | size_t cnt) | ||
148 | { | ||
149 | struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } }; | ||
150 | int found_cc = 0; | ||
151 | size_t i; | ||
152 | |||
153 | for (i = 0; i < cnt; i++) | ||
154 | ivtv_write_vbi_line(itv, sliced + i, &cc, &found_cc); | ||
155 | |||
156 | if (found_cc) | ||
157 | ivtv_write_vbi_cc_lines(itv, &cc); | ||
158 | } | ||
159 | |||
160 | ssize_t | ||
161 | ivtv_write_vbi_from_user(struct ivtv *itv, | ||
162 | const struct v4l2_sliced_vbi_data __user *sliced, | ||
163 | size_t cnt) | ||
164 | { | ||
165 | struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } }; | ||
166 | int found_cc = 0; | ||
167 | size_t i; | ||
168 | struct v4l2_sliced_vbi_data d; | ||
169 | ssize_t ret = cnt * sizeof(struct v4l2_sliced_vbi_data); | ||
170 | |||
171 | for (i = 0; i < cnt; i++) { | ||
172 | if (copy_from_user(&d, sliced + i, | ||
173 | sizeof(struct v4l2_sliced_vbi_data))) { | ||
174 | ret = -EFAULT; | ||
175 | break; | ||
176 | } | ||
177 | ivtv_write_vbi_line(itv, &d, &cc, &found_cc); | ||
178 | } | ||
179 | |||
180 | if (found_cc) | ||
181 | ivtv_write_vbi_cc_lines(itv, &cc); | ||
182 | |||
183 | return ret; | ||
184 | } | ||
185 | |||
186 | static void copy_vbi_data(struct ivtv *itv, int lines, u32 pts_stamp) | ||
187 | { | ||
188 | int line = 0; | ||
189 | int i; | ||
190 | u32 linemask[2] = { 0, 0 }; | ||
191 | unsigned short size; | ||
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 | ||
197 | }; | ||
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]; | ||
201 | |||
202 | for (i = 0; i < lines; i++) { | ||
203 | int f, l; | ||
204 | |||
205 | if (itv->vbi.sliced_data[i].id == 0) | ||
206 | continue; | ||
207 | |||
208 | l = itv->vbi.sliced_data[i].line - 6; | ||
209 | f = itv->vbi.sliced_data[i].field; | ||
210 | if (f) | ||
211 | l += 18; | ||
212 | if (l < 32) | ||
213 | linemask[0] |= (1 << l); | ||
214 | else | ||
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); | ||
219 | line++; | ||
220 | } | ||
221 | memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data)); | ||
222 | if (line == 36) { | ||
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); | ||
229 | } else { | ||
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); | ||
235 | } | ||
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; | ||
244 | } | ||
245 | |||
246 | static int ivtv_convert_ivtv_vbi(struct ivtv *itv, u8 *p) | ||
247 | { | ||
248 | u32 linemask[2]; | ||
249 | int i, l, id2; | ||
250 | int line = 0; | ||
251 | |||
252 | if (!memcmp(p, "itv0", 4)) { | ||
253 | memcpy(linemask, p + 4, 8); | ||
254 | p += 12; | ||
255 | } else if (!memcmp(p, "ITV0", 4)) { | ||
256 | linemask[0] = 0xffffffff; | ||
257 | linemask[1] = 0xf; | ||
258 | p += 4; | ||
259 | } else { | ||
260 | /* unknown VBI data, convert to empty VBI frame */ | ||
261 | linemask[0] = linemask[1] = 0; | ||
262 | } | ||
263 | for (i = 0; i < 36; i++) { | ||
264 | int err = 0; | ||
265 | |||
266 | if (i < 32 && !(linemask[0] & (1 << i))) | ||
267 | continue; | ||
268 | if (i >= 32 && !(linemask[1] & (1 << (i - 32)))) | ||
269 | continue; | ||
270 | id2 = *p & 0xf; | ||
271 | switch (id2) { | ||
272 | case IVTV_SLICED_TYPE_TELETEXT_B: | ||
273 | id2 = V4L2_SLICED_TELETEXT_B; | ||
274 | break; | ||
275 | case IVTV_SLICED_TYPE_CAPTION_525: | ||
276 | id2 = V4L2_SLICED_CAPTION_525; | ||
277 | err = !odd_parity(p[1]) || !odd_parity(p[2]); | ||
278 | break; | ||
279 | case IVTV_SLICED_TYPE_VPS: | ||
280 | id2 = V4L2_SLICED_VPS; | ||
281 | break; | ||
282 | case IVTV_SLICED_TYPE_WSS_625: | ||
283 | id2 = V4L2_SLICED_WSS_625; | ||
284 | break; | ||
285 | default: | ||
286 | id2 = 0; | ||
287 | break; | ||
288 | } | ||
289 | if (err == 0) { | ||
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); | ||
295 | line++; | ||
296 | } | ||
297 | p += 43; | ||
298 | } | ||
299 | while (line < 36) { | ||
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; | ||
303 | line++; | ||
304 | } | ||
305 | return line * sizeof(itv->vbi.sliced_dec_data[0]); | ||
306 | } | ||
307 | |||
308 | /* Compress raw VBI format, removes leading SAV codes and surplus space after the | ||
309 | field. | ||
310 | Returns new compressed size. */ | ||
311 | static u32 compress_raw_buf(struct ivtv *itv, u8 *buf, u32 size) | ||
312 | { | ||
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; | ||
317 | u8 *q = buf; | ||
318 | u8 *p; | ||
319 | int i; | ||
320 | |||
321 | for (i = 0; i < lines; i++) { | ||
322 | p = buf + i * line_size; | ||
323 | |||
324 | /* Look for SAV code */ | ||
325 | if (p[0] != 0xff || p[1] || p[2] || (p[3] != sav1 && p[3] != sav2)) { | ||
326 | break; | ||
327 | } | ||
328 | memcpy(q, p + 4, line_size - 4); | ||
329 | q += line_size - 4; | ||
330 | } | ||
331 | return lines * (line_size - 4); | ||
332 | } | ||
333 | |||
334 | |||
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) | ||
338 | { | ||
339 | u32 line_size = itv->vbi.sliced_decoder_line_size; | ||
340 | struct v4l2_decode_vbi_line vbi; | ||
341 | int i; | ||
342 | unsigned lines = 0; | ||
343 | |||
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) | ||
347 | break; | ||
348 | } | ||
349 | |||
350 | size -= i; | ||
351 | if (size < line_size) { | ||
352 | return line; | ||
353 | } | ||
354 | for (i = 0; i < size / line_size; i++) { | ||
355 | u8 *p = buf + i * line_size; | ||
356 | |||
357 | /* Look for SAV code */ | ||
358 | if (p[0] != 0xff || p[1] || p[2] || p[3] != sav) { | ||
359 | continue; | ||
360 | } | ||
361 | vbi.p = p + 4; | ||
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); | ||
369 | line++; | ||
370 | } | ||
371 | } | ||
372 | return line; | ||
373 | } | ||
374 | |||
375 | void ivtv_process_vbi_data(struct ivtv *itv, struct ivtv_buffer *buf, | ||
376 | u64 pts_stamp, int streamtype) | ||
377 | { | ||
378 | u8 *p = (u8 *) buf->buf; | ||
379 | u32 size = buf->bytesused; | ||
380 | int y; | ||
381 | |||
382 | /* Raw VBI data */ | ||
383 | if (streamtype == IVTV_ENC_STREAM_TYPE_VBI && ivtv_raw_vbi(itv)) { | ||
384 | u8 type; | ||
385 | |||
386 | ivtv_buf_swap(buf); | ||
387 | |||
388 | type = p[3]; | ||
389 | |||
390 | size = buf->bytesused = compress_raw_buf(itv, p, size); | ||
391 | |||
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. */ | ||
396 | p += size - 4; | ||
397 | memcpy(p, &itv->vbi.frame, 4); | ||
398 | itv->vbi.frame++; | ||
399 | } | ||
400 | return; | ||
401 | } | ||
402 | |||
403 | /* Sliced VBI data with data insertion */ | ||
404 | if (streamtype == IVTV_ENC_STREAM_TYPE_VBI) { | ||
405 | int lines; | ||
406 | |||
407 | ivtv_buf_swap(buf); | ||
408 | |||
409 | /* first field */ | ||
410 | lines = compress_sliced_buf(itv, 0, p, size / 2, | ||
411 | itv->vbi.sliced_decoder_sav_odd_field); | ||
412 | /* second 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 */ | ||
418 | if (lines == 0) { | ||
419 | itv->vbi.sliced_data[0].id = 0; | ||
420 | itv->vbi.sliced_data[0].line = 0; | ||
421 | itv->vbi.sliced_data[0].field = 0; | ||
422 | lines = 1; | ||
423 | } | ||
424 | buf->bytesused = size = lines * sizeof(itv->vbi.sliced_data[0]); | ||
425 | memcpy(p, &itv->vbi.sliced_data[0], size); | ||
426 | |||
427 | if (itv->vbi.insert_mpeg) { | ||
428 | copy_vbi_data(itv, lines, pts_stamp); | ||
429 | } | ||
430 | itv->vbi.frame++; | ||
431 | return; | ||
432 | } | ||
433 | |||
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; | ||
444 | int cnt; | ||
445 | |||
446 | if (offset) { | ||
447 | p += 4 - offset; | ||
448 | } | ||
449 | /* Swap Buffer */ | ||
450 | for (y = 0; y < size; y += 4) { | ||
451 | swab32s((u32 *)(p + y)); | ||
452 | } | ||
453 | |||
454 | cnt = ivtv_convert_ivtv_vbi(itv, p + offset); | ||
455 | memcpy(buf->buf, itv->vbi.sliced_dec_data, cnt); | ||
456 | buf->bytesused = cnt; | ||
457 | |||
458 | ivtv_write_vbi(itv, itv->vbi.sliced_dec_data, | ||
459 | cnt / sizeof(itv->vbi.sliced_dec_data[0])); | ||
460 | return; | ||
461 | } | ||
462 | } | ||
463 | |||
464 | void ivtv_disable_cc(struct ivtv *itv) | ||
465 | { | ||
466 | struct vbi_cc cc = { .odd = { 0x80, 0x80 }, .even = { 0x80, 0x80 } }; | ||
467 | |||
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; | ||
471 | } | ||
472 | |||
473 | |||
474 | void ivtv_vbi_work_handler(struct ivtv *itv) | ||
475 | { | ||
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 } }; | ||
479 | |||
480 | /* Lock */ | ||
481 | if (itv->output_mode == OUT_PASSTHROUGH) { | ||
482 | if (itv->is_50hz) { | ||
483 | data.id = V4L2_SLICED_WSS_625; | ||
484 | data.field = 0; | ||
485 | |||
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 */ | ||
491 | } else { | ||
492 | vi->wss_missing_cnt++; | ||
493 | } | ||
494 | } | ||
495 | else { | ||
496 | int mode = 0; | ||
497 | |||
498 | data.id = V4L2_SLICED_CAPTION_525; | ||
499 | data.field = 0; | ||
500 | if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) { | ||
501 | mode |= 1; | ||
502 | cc.odd[0] = data.data[0]; | ||
503 | cc.odd[1] = data.data[1]; | ||
504 | } | ||
505 | data.field = 1; | ||
506 | if (v4l2_subdev_call(itv->sd_video, vbi, g_vbi_data, &data) == 0) { | ||
507 | mode |= 2; | ||
508 | cc.even[0] = data.data[0]; | ||
509 | cc.even[1] = data.data[1]; | ||
510 | } | ||
511 | if (mode) { | ||
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); | ||
516 | } else { | ||
517 | vi->cc_missing_cnt++; | ||
518 | } | ||
519 | } | ||
520 | return; | ||
521 | } | ||
522 | |||
523 | if (test_and_clear_bit(IVTV_F_I_UPDATE_WSS, &itv->i_flags)) { | ||
524 | ivtv_set_wss(itv, 1, vi->wss_payload & 0xf); | ||
525 | } | ||
526 | |||
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); | ||
531 | } | ||
532 | while (vi->cc_payload_idx) { | ||
533 | cc = vi->cc_payload[0]; | ||
534 | |||
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) | ||
539 | continue; | ||
540 | |||
541 | ivtv_set_cc(itv, 3, &cc); | ||
542 | break; | ||
543 | } | ||
544 | } | ||
545 | |||
546 | if (test_and_clear_bit(IVTV_F_I_UPDATE_VPS, &itv->i_flags)) { | ||
547 | ivtv_set_vps(itv, 1); | ||
548 | } | ||
549 | } | ||