]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - drivers/media/video/cx18/cx18-vbi.c
2 * cx18 Vertical Blank Interval support functions
4 * Derived from ivtv-vbi.c
6 * Copyright (C) 2007 Hans Verkuil <hverkuil@xs4all.nl>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
24 #include "cx18-driver.h"
26 #include "cx18-ioctl.h"
27 #include "cx18-queue.h"
30 * Raster Reference/Protection (RP) bytes, used in Start/End Active
31 * Video codes emitted from the digitzer in VIP 1.x mode, that flag the start
32 * of VBI sample or VBI ancillary data regions in the digitial ratser line.
34 * Task FieldEven VerticalBlank HorizontalBlank 0 0 0 0
36 static const u8 raw_vbi_sav_rp
[2] = { 0x20, 0x60 }; /* __V_, _FV_ */
37 static const u8 sliced_vbi_eav_rp
[2] = { 0xb0, 0xf0 }; /* T_VH, TFVH */
39 static void copy_vbi_data(struct cx18
*cx
, int lines
, u32 pts_stamp
)
43 u32 linemask
[2] = { 0, 0 };
45 static const u8 mpeg_hdr_data
[] = {
46 /* MPEG-2 Program Pack */
47 0x00, 0x00, 0x01, 0xba, /* Prog Pack start code */
48 0x44, 0x00, 0x0c, 0x66, 0x24, 0x01, /* SCR, SCR Ext, markers */
49 0x01, 0xd1, 0xd3, /* Mux Rate, markers */
50 0xfa, 0xff, 0xff, /* Res, Suff cnt, Stuff */
51 /* MPEG-2 Private Stream 1 PES Packet */
52 0x00, 0x00, 0x01, 0xbd, /* Priv Stream 1 start */
53 0x00, 0x1a, /* length */
54 0x84, 0x80, 0x07, /* flags, hdr data len */
55 0x21, 0x00, 0x5d, 0x63, 0xa7, /* PTS, markers */
56 0xff, 0xff /* stuffing */
58 const int sd
= sizeof(mpeg_hdr_data
); /* start of vbi data */
59 int idx
= cx
->vbi
.frame
% CX18_VBI_FRAMES
;
60 u8
*dst
= &cx
->vbi
.sliced_mpeg_data
[idx
][0];
62 for (i
= 0; i
< lines
; i
++) {
63 struct v4l2_sliced_vbi_data
*sdata
= cx
->vbi
.sliced_data
+ i
;
74 linemask
[0] |= (1 << l
);
76 linemask
[1] |= (1 << (l
- 32));
77 dst
[sd
+ 12 + line
* 43] = cx18_service2vbi(sdata
->id
);
78 memcpy(dst
+ sd
+ 12 + line
* 43 + 1, sdata
->data
, 42);
81 memcpy(dst
, mpeg_hdr_data
, sizeof(mpeg_hdr_data
));
83 /* All lines are used, so there is no space for the linemask
84 (the max size of the VBI data is 36 * 43 + 4 bytes).
85 So in this case we use the magic number 'ITV0'. */
86 memcpy(dst
+ sd
, "ITV0", 4);
87 memcpy(dst
+ sd
+ 4, dst
+ sd
+ 12, line
* 43);
88 size
= 4 + ((43 * line
+ 3) & ~3);
90 memcpy(dst
+ sd
, "itv0", 4);
91 cpu_to_le32s(&linemask
[0]);
92 cpu_to_le32s(&linemask
[1]);
93 memcpy(dst
+ sd
+ 4, &linemask
[0], 8);
94 size
= 12 + ((43 * line
+ 3) & ~3);
96 dst
[4+16] = (size
+ 10) >> 8;
97 dst
[5+16] = (size
+ 10) & 0xff;
98 dst
[9+16] = 0x21 | ((pts_stamp
>> 29) & 0x6);
99 dst
[10+16] = (pts_stamp
>> 22) & 0xff;
100 dst
[11+16] = 1 | ((pts_stamp
>> 14) & 0xff);
101 dst
[12+16] = (pts_stamp
>> 7) & 0xff;
102 dst
[13+16] = 1 | ((pts_stamp
& 0x7f) << 1);
103 cx
->vbi
.sliced_mpeg_size
[idx
] = sd
+ size
;
106 /* Compress raw VBI format, removes leading SAV codes and surplus space
107 after the frame. Returns new compressed size. */
108 /* FIXME - this function ignores the input size. */
109 static u32
compress_raw_buf(struct cx18
*cx
, u8
*buf
, u32 size
, u32 hdr_size
)
111 u32 line_size
= vbi_active_samples
;
112 u32 lines
= cx
->vbi
.count
* 2;
117 /* Skip the header */
120 for (i
= 0; i
< lines
; i
++) {
121 p
= buf
+ i
* line_size
;
123 /* Look for SAV code */
124 if (p
[0] != 0xff || p
[1] || p
[2] ||
125 (p
[3] != raw_vbi_sav_rp
[0] &&
126 p
[3] != raw_vbi_sav_rp
[1]))
128 if (i
== lines
- 1) {
129 /* last line is hdr_size bytes short - extrapolate it */
130 memcpy(q
, p
+ 4, line_size
- 4 - hdr_size
);
131 q
+= line_size
- 4 - hdr_size
;
132 p
+= line_size
- hdr_size
- 1;
133 memset(q
, (int) *p
, hdr_size
);
135 memcpy(q
, p
+ 4, line_size
- 4);
139 return lines
* (line_size
- 4);
142 static u32
compress_sliced_buf(struct cx18
*cx
, u8
*buf
, u32 size
,
145 struct v4l2_decode_vbi_line vbi
;
148 u32 line_size
= cx
->is_60hz
? vbi_hblank_samples_60Hz
149 : vbi_hblank_samples_50Hz
;
151 /* find the first valid line */
152 for (i
= hdr_size
, buf
+= hdr_size
; i
< size
; i
++, buf
++) {
153 if (buf
[0] == 0xff && !buf
[1] && !buf
[2] &&
154 (buf
[3] == sliced_vbi_eav_rp
[0] ||
155 buf
[3] == sliced_vbi_eav_rp
[1]))
160 * The last line is short by hdr_size bytes, but for the remaining
161 * checks against size, we pretend that it is not, by counting the
162 * header bytes we knowingly skipped
164 size
-= (i
- hdr_size
);
165 if (size
< line_size
)
168 for (i
= 0; i
< size
/ line_size
; i
++) {
169 u8
*p
= buf
+ i
* line_size
;
171 /* Look for EAV code */
172 if (p
[0] != 0xff || p
[1] || p
[2] ||
173 (p
[3] != sliced_vbi_eav_rp
[0] &&
174 p
[3] != sliced_vbi_eav_rp
[1]))
177 v4l2_subdev_call(cx
->sd_av
, vbi
, decode_vbi_line
, &vbi
);
179 cx
->vbi
.sliced_data
[line
].id
= vbi
.type
;
180 cx
->vbi
.sliced_data
[line
].field
= vbi
.is_second_field
;
181 cx
->vbi
.sliced_data
[line
].line
= vbi
.line
;
182 memcpy(cx
->vbi
.sliced_data
[line
].data
, vbi
.p
, 42);
189 static void _cx18_process_vbi_data(struct cx18
*cx
, struct cx18_buffer
*buf
)
192 * The CX23418 provides a 12 byte header in its raw VBI buffers to us:
193 * 0x3fffffff [4 bytes of something] [4 byte presentation time stamp]
195 struct vbi_data_hdr
{
199 } *hdr
= (struct vbi_data_hdr
*) buf
->buf
;
201 u8
*p
= (u8
*) buf
->buf
;
202 u32 size
= buf
->bytesused
;
207 * The CX23418 sends us data that is 32 bit little-endian swapped,
208 * but we want the raw VBI bytes in the order they were in the raster
209 * line. This has a side effect of making the header big endian
214 if (cx18_raw_vbi(cx
)) {
216 size
= buf
->bytesused
=
217 compress_raw_buf(cx
, p
, size
, sizeof(struct vbi_data_hdr
));
220 * Hack needed for compatibility with old VBI software.
221 * Write the frame # at the last 4 bytes of the frame
224 memcpy(p
, &cx
->vbi
.frame
, 4);
229 /* Sliced VBI data with data insertion */
231 pts
= (be32_to_cpu(hdr
->magic
) == 0x3fffffff) ? be32_to_cpu(hdr
->pts
)
234 lines
= compress_sliced_buf(cx
, p
, size
, sizeof(struct vbi_data_hdr
));
236 /* always return at least one empty line */
238 cx
->vbi
.sliced_data
[0].id
= 0;
239 cx
->vbi
.sliced_data
[0].line
= 0;
240 cx
->vbi
.sliced_data
[0].field
= 0;
243 buf
->bytesused
= size
= lines
* sizeof(cx
->vbi
.sliced_data
[0]);
244 memcpy(p
, &cx
->vbi
.sliced_data
[0], size
);
246 if (cx
->vbi
.insert_mpeg
)
247 copy_vbi_data(cx
, lines
, pts
);
251 void cx18_process_vbi_data(struct cx18
*cx
, struct cx18_mdl
*mdl
,
254 struct cx18_buffer
*buf
;
257 if (streamtype
!= CX18_ENC_STREAM_TYPE_VBI
)
261 * Big assumption here:
262 * Every buffer hooked to the MDL's buf_list is a complete VBI frame
263 * that ends at the end of the buffer.
265 * To assume anything else would make the code in this file
266 * more complex, or require extra memcpy()'s to make the
267 * buffers satisfy the above assumption. It's just simpler to set
268 * up the encoder buffer transfers to make the assumption true.
270 list_for_each_entry(buf
, &mdl
->buf_list
, list
) {
271 orig_used
= buf
->bytesused
;
274 _cx18_process_vbi_data(cx
, buf
);
275 mdl
->bytesused
-= (orig_used
- buf
->bytesused
);