1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "cx18-driver.h"
25#include "cx18-vbi.h"
26#include "cx18-ioctl.h"
27#include "cx18-queue.h"
28
29
30
31
32
33
34
35
36static const u8 raw_vbi_sav_rp[2] = { 0x20, 0x60 };
37static const u8 sliced_vbi_eav_rp[2] = { 0xb0, 0xf0 };
38
39static void copy_vbi_data(struct cx18 *cx, int lines, u32 pts_stamp)
40{
41 int line = 0;
42 int i;
43 u32 linemask[2] = { 0, 0 };
44 unsigned short size;
45 static const u8 mpeg_hdr_data[] = {
46
47 0x00, 0x00, 0x01, 0xba,
48 0x44, 0x00, 0x0c, 0x66, 0x24, 0x01,
49 0x01, 0xd1, 0xd3,
50 0xfa, 0xff, 0xff,
51
52 0x00, 0x00, 0x01, 0xbd,
53 0x00, 0x1a,
54 0x84, 0x80, 0x07,
55 0x21, 0x00, 0x5d, 0x63, 0xa7,
56 0xff, 0xff
57 };
58 const int sd = sizeof(mpeg_hdr_data);
59 int idx = cx->vbi.frame % CX18_VBI_FRAMES;
60 u8 *dst = &cx->vbi.sliced_mpeg_data[idx][0];
61
62 for (i = 0; i < lines; i++) {
63 struct v4l2_sliced_vbi_data *sdata = cx->vbi.sliced_data + i;
64 int f, l;
65
66 if (sdata->id == 0)
67 continue;
68
69 l = sdata->line - 6;
70 f = sdata->field;
71 if (f)
72 l += 18;
73 if (l < 32)
74 linemask[0] |= (1 << l);
75 else
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);
79 line++;
80 }
81 memcpy(dst, mpeg_hdr_data, sizeof(mpeg_hdr_data));
82 if (line == 36) {
83
84
85
86 memcpy(dst + sd, "ITV0", 4);
87 memcpy(dst + sd + 4, dst + sd + 12, line * 43);
88 size = 4 + ((43 * line + 3) & ~3);
89 } else {
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);
95 }
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;
104}
105
106
107
108static u32 compress_raw_buf(struct cx18 *cx, u8 *buf, u32 size, u32 hdr_size)
109{
110 u32 line_size = vbi_active_samples;
111 u32 lines = cx->vbi.count * 2;
112 u8 *q = buf;
113 u8 *p;
114 int i;
115
116
117 buf += hdr_size;
118
119 for (i = 0; i < lines; i++) {
120 p = buf + i * line_size;
121
122
123 if (p[0] != 0xff || p[1] || p[2] ||
124 (p[3] != raw_vbi_sav_rp[0] &&
125 p[3] != raw_vbi_sav_rp[1]))
126 break;
127 if (i == lines - 1) {
128
129 memcpy(q, p + 4, line_size - 4 - hdr_size);
130 q += line_size - 4 - hdr_size;
131 p += line_size - hdr_size - 1;
132 memset(q, (int) *p, hdr_size);
133 } else {
134 memcpy(q, p + 4, line_size - 4);
135 q += line_size - 4;
136 }
137 }
138 return lines * (line_size - 4);
139}
140
141static u32 compress_sliced_buf(struct cx18 *cx, u8 *buf, u32 size,
142 const u32 hdr_size)
143{
144 struct v4l2_decode_vbi_line vbi;
145 int i;
146 u32 line = 0;
147 u32 line_size = cx->is_60hz ? vbi_hblank_samples_60Hz
148 : vbi_hblank_samples_50Hz;
149
150
151 for (i = hdr_size, buf += hdr_size; i < size; i++, buf++) {
152 if (buf[0] == 0xff && !buf[1] && !buf[2] &&
153 (buf[3] == sliced_vbi_eav_rp[0] ||
154 buf[3] == sliced_vbi_eav_rp[1]))
155 break;
156 }
157
158
159
160
161
162
163 size -= (i - hdr_size);
164 if (size < line_size)
165 return line;
166
167 for (i = 0; i < size / line_size; i++) {
168 u8 *p = buf + i * line_size;
169
170
171 if (p[0] != 0xff || p[1] || p[2] ||
172 (p[3] != sliced_vbi_eav_rp[0] &&
173 p[3] != sliced_vbi_eav_rp[1]))
174 continue;
175 vbi.p = p + 4;
176 v4l2_subdev_call(cx->sd_av, video, decode_vbi_line, &vbi);
177 if (vbi.type) {
178 cx->vbi.sliced_data[line].id = vbi.type;
179 cx->vbi.sliced_data[line].field = vbi.is_second_field;
180 cx->vbi.sliced_data[line].line = vbi.line;
181 memcpy(cx->vbi.sliced_data[line].data, vbi.p, 42);
182 line++;
183 }
184 }
185 return line;
186}
187
188void cx18_process_vbi_data(struct cx18 *cx, struct cx18_buffer *buf,
189 int streamtype)
190{
191
192
193
194
195 struct vbi_data_hdr {
196 __be32 magic;
197 __be32 unknown;
198 __be32 pts;
199 } *hdr = (struct vbi_data_hdr *) buf->buf;
200
201 u8 *p = (u8 *) buf->buf;
202 u32 size = buf->bytesused;
203 u32 pts;
204 int lines;
205
206 if (streamtype != CX18_ENC_STREAM_TYPE_VBI)
207 return;
208
209
210
211
212
213
214 cx18_buf_swap(buf);
215
216
217 if (cx18_raw_vbi(cx)) {
218
219 size = buf->bytesused =
220 compress_raw_buf(cx, p, size, sizeof(struct vbi_data_hdr));
221
222
223
224
225
226 p += size - 4;
227 memcpy(p, &cx->vbi.frame, 4);
228 cx->vbi.frame++;
229 return;
230 }
231
232
233
234 pts = (be32_to_cpu(hdr->magic) == 0x3fffffff) ? be32_to_cpu(hdr->pts)
235 : 0;
236
237 lines = compress_sliced_buf(cx, p, size, sizeof(struct vbi_data_hdr));
238
239
240 if (lines == 0) {
241 cx->vbi.sliced_data[0].id = 0;
242 cx->vbi.sliced_data[0].line = 0;
243 cx->vbi.sliced_data[0].field = 0;
244 lines = 1;
245 }
246 buf->bytesused = size = lines * sizeof(cx->vbi.sliced_data[0]);
247 memcpy(p, &cx->vbi.sliced_data[0], size);
248
249 if (cx->vbi.insert_mpeg)
250 copy_vbi_data(cx, lines, pts);
251 cx->vbi.frame++;
252}
253