1 /*
2 *
3 *
4 * Copyright (C) 2005 Mike Isely <isely@pobox.com>
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
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
21 #include "pvrusb2-std.h"
22 #include "pvrusb2-debug.h"
23 #include <asm/string.h>
24 #include <linux/slab.h>
25
26 struct std_name {
27 const char *name;
28 v4l2_std_id id;
29 };
30
31
32 #define CSTD_PAL \
33 (V4L2_STD_PAL_B| \
34 V4L2_STD_PAL_B1| \
35 V4L2_STD_PAL_G| \
36 V4L2_STD_PAL_H| \
37 V4L2_STD_PAL_I| \
38 V4L2_STD_PAL_D| \
39 V4L2_STD_PAL_D1| \
40 V4L2_STD_PAL_K| \
41 V4L2_STD_PAL_M| \
42 V4L2_STD_PAL_N| \
43 V4L2_STD_PAL_Nc| \
44 V4L2_STD_PAL_60)
45
46 #define CSTD_NTSC \
47 (V4L2_STD_NTSC_M| \
48 V4L2_STD_NTSC_M_JP| \
49 V4L2_STD_NTSC_M_KR| \
50 V4L2_STD_NTSC_443)
51
52 #define CSTD_ATSC \
53 (V4L2_STD_ATSC_8_VSB| \
54 V4L2_STD_ATSC_16_VSB)
55
56 #define CSTD_SECAM \
57 (V4L2_STD_SECAM_B| \
58 V4L2_STD_SECAM_D| \
59 V4L2_STD_SECAM_G| \
60 V4L2_STD_SECAM_H| \
61 V4L2_STD_SECAM_K| \
62 V4L2_STD_SECAM_K1| \
63 V4L2_STD_SECAM_L| \
64 V4L2_STD_SECAM_LC)
65
66 #define TSTD_B (V4L2_STD_PAL_B|V4L2_STD_SECAM_B)
67 #define TSTD_B1 (V4L2_STD_PAL_B1)
68 #define TSTD_D (V4L2_STD_PAL_D|V4L2_STD_SECAM_D)
69 #define TSTD_D1 (V4L2_STD_PAL_D1)
70 #define TSTD_G (V4L2_STD_PAL_G|V4L2_STD_SECAM_G)
71 #define TSTD_H (V4L2_STD_PAL_H|V4L2_STD_SECAM_H)
72 #define TSTD_I (V4L2_STD_PAL_I)
73 #define TSTD_K (V4L2_STD_PAL_K|V4L2_STD_SECAM_K)
74 #define TSTD_K1 (V4L2_STD_SECAM_K1)
75 #define TSTD_L (V4L2_STD_SECAM_L)
76 #define TSTD_M (V4L2_STD_PAL_M|V4L2_STD_NTSC_M)
77 #define TSTD_N (V4L2_STD_PAL_N)
78 #define TSTD_Nc (V4L2_STD_PAL_Nc)
79 #define TSTD_60 (V4L2_STD_PAL_60)
80
81 #define CSTD_ALL (CSTD_PAL|CSTD_NTSC|CSTD_ATSC|CSTD_SECAM)
82
83 /* Mapping of standard bits to color system */
84 static const struct std_name std_groups[] = {
85 {"PAL",CSTD_PAL},
86 {"NTSC",CSTD_NTSC},
87 {"SECAM",CSTD_SECAM},
88 {"ATSC",CSTD_ATSC},
89 };
90
91 /* Mapping of standard bits to modulation system */
92 static const struct std_name std_items[] = {
93 {"B",TSTD_B},
94 {"B1",TSTD_B1},
95 {"D",TSTD_D},
96 {"D1",TSTD_D1},
97 {"G",TSTD_G},
98 {"H",TSTD_H},
99 {"I",TSTD_I},
100 {"K",TSTD_K},
101 {"K1",TSTD_K1},
102 {"L",TSTD_L},
103 {"LC",V4L2_STD_SECAM_LC},
104 {"M",TSTD_M},
105 {"Mj",V4L2_STD_NTSC_M_JP},
106 {"443",V4L2_STD_NTSC_443},
107 {"Mk",V4L2_STD_NTSC_M_KR},
108 {"N",TSTD_N},
109 {"Nc",TSTD_Nc},
110 {"60",TSTD_60},
111 {"8VSB",V4L2_STD_ATSC_8_VSB},
112 {"16VSB",V4L2_STD_ATSC_16_VSB},
113 };
114
115
116 // Search an array of std_name structures and return a pointer to the
117 // element with the matching name.
118 static const struct std_name *find_std_name(const struct std_name *arrPtr,
119 unsigned int arrSize,
120 const char *bufPtr,
121 unsigned int bufSize)
122 {
123 unsigned int idx;
124 const struct std_name *p;
125 for (idx = 0; idx < arrSize; idx++) {
126 p = arrPtr + idx;
127 if (strlen(p->name) != bufSize) continue;
128 if (!memcmp(bufPtr,p->name,bufSize)) return p;
129 }
130 return NULL;
131 }
132
133
134 int pvr2_std_str_to_id(v4l2_std_id *idPtr,const char *bufPtr,
135 unsigned int bufSize)
136 {
137 v4l2_std_id id = 0;
138 v4l2_std_id cmsk = 0;
139 v4l2_std_id t;
140 int mMode = 0;
141 unsigned int cnt;
142 char ch;
143 const struct std_name *sp;
144
145 while (bufSize) {
146 if (!mMode) {
147 cnt = 0;
148 while ((cnt < bufSize) && (bufPtr[cnt] != '-')) cnt++;
149 if (cnt >= bufSize) return 0; // No more characters
150 sp = find_std_name(std_groups, ARRAY_SIZE(std_groups),
151 bufPtr,cnt);
152 if (!sp) return 0; // Illegal color system name
153 cnt++;
154 bufPtr += cnt;
155 bufSize -= cnt;
156 mMode = !0;
157 cmsk = sp->id;
158 continue;
159 }
160 cnt = 0;
161 while (cnt < bufSize) {
162 ch = bufPtr[cnt];
163 if (ch == ';') {
164 mMode = 0;
165 break;
166 }
167 if (ch == '/') break;
168 cnt++;
169 }
170 sp = find_std_name(std_items, ARRAY_SIZE(std_items),
171 bufPtr,cnt);
172 if (!sp) return 0; // Illegal modulation system ID
173 t = sp->id & cmsk;
174 if (!t) return 0; // Specific color + modulation system illegal
175 id |= t;
176 if (cnt < bufSize) cnt++;
177 bufPtr += cnt;
178 bufSize -= cnt;
179 }
180
181 if (idPtr) *idPtr = id;
182 return !0;
183 }
184
185
186 unsigned int pvr2_std_id_to_str(char *bufPtr, unsigned int bufSize,
187 v4l2_std_id id)
188 {
189 unsigned int idx1,idx2;
190 const struct std_name *ip,*gp;
191 int gfl,cfl;
192 unsigned int c1,c2;
193 cfl = 0;
194 c1 = 0;
195 for (idx1 = 0; idx1 < ARRAY_SIZE(std_groups); idx1++) {
196 gp = std_groups + idx1;
197 gfl = 0;
198 for (idx2 = 0; idx2 < ARRAY_SIZE(std_items); idx2++) {
199 ip = std_items + idx2;
200 if (!(gp->id & ip->id & id)) continue;
201 if (!gfl) {
202 if (cfl) {
203 c2 = scnprintf(bufPtr,bufSize,";");
204 c1 += c2;
205 bufSize -= c2;
206 bufPtr += c2;
207 }
208 cfl = !0;
209 c2 = scnprintf(bufPtr,bufSize,
210 "%s-",gp->name);
211 gfl = !0;
212 } else {
213 c2 = scnprintf(bufPtr,bufSize,"/");
214 }
215 c1 += c2;
216 bufSize -= c2;
217 bufPtr += c2;
218 c2 = scnprintf(bufPtr,bufSize,
219 ip->name);
220 c1 += c2;
221 bufSize -= c2;
222 bufPtr += c2;
223 }
224 }
225 return c1;
226 }
227
228
229 // Template data for possible enumerated video standards. Here we group
230 // standards which share common frame rates and resolution.
231 static struct v4l2_standard generic_standards[] = {
232 {
233 .id = (TSTD_B|TSTD_B1|
234 TSTD_D|TSTD_D1|
235 TSTD_G|
236 TSTD_H|
237 TSTD_I|
238 TSTD_K|TSTD_K1|
239 TSTD_L|
240 V4L2_STD_SECAM_LC |
241 TSTD_N|TSTD_Nc),
242 .frameperiod =
243 {
244 .numerator = 1,
245 .denominator= 25
246 },
247 .framelines = 625,
248 .reserved = {0,0,0,0}
249 }, {
250 .id = (TSTD_M|
251 V4L2_STD_NTSC_M_JP|
252 V4L2_STD_NTSC_M_KR),
253 .frameperiod =
254 {
255 .numerator = 1001,
256 .denominator= 30000
257 },
258 .framelines = 525,
259 .reserved = {0,0,0,0}
260 }, { // This is a total wild guess
261 .id = (TSTD_60),
262 .frameperiod =
263 {
264 .numerator = 1001,
265 .denominator= 30000
266 },
267 .framelines = 525,
268 .reserved = {0,0,0,0}
269 }, { // This is total wild guess
270 .id = V4L2_STD_NTSC_443,
271 .frameperiod =
272 {
273 .numerator = 1001,
274 .denominator= 30000
275 },
276 .framelines = 525,
277 .reserved = {0,0,0,0}
278 }
279 };
280
281 #define generic_standards_cnt ARRAY_SIZE(generic_standards)
282
283 static struct v4l2_standard *match_std(v4l2_std_id id)
284 {
285 unsigned int idx;
286 for (idx = 0; idx < generic_standards_cnt; idx++) {
287 if (generic_standards[idx].id & id) {
288 return generic_standards + idx;
289 }
290 }
291 return NULL;
292 }
293
294 static int pvr2_std_fill(struct v4l2_standard *std,v4l2_std_id id)
295 {
296 struct v4l2_standard *template;
297 int idx;
298 unsigned int bcnt;
299 template = match_std(id);
300 if (!template) return 0;
301 idx = std->index;
302 memcpy(std,template,sizeof(*template));
303 std->index = idx;
304 std->id = id;
305 bcnt = pvr2_std_id_to_str(std->name,sizeof(std->name)-1,id);
306 std->name[bcnt] = 0;
307 pvr2_trace(PVR2_TRACE_STD,"Set up standard idx=%u name=%s",
308 std->index,std->name);
309 return !0;
310 }
311
312 /* These are special cases of combined standards that we should enumerate
313 separately if the component pieces are present. */
314 static v4l2_std_id std_mixes[] = {
315 V4L2_STD_PAL_B | V4L2_STD_PAL_G,
316 V4L2_STD_PAL_D | V4L2_STD_PAL_K,
317 V4L2_STD_SECAM_B | V4L2_STD_SECAM_G,
318 V4L2_STD_SECAM_D | V4L2_STD_SECAM_K,
319 };
320
321 struct v4l2_standard *pvr2_std_create_enum(unsigned int *countptr,
322 v4l2_std_id id)
323 {
324 unsigned int std_cnt = 0;
325 unsigned int idx,bcnt,idx2;
326 v4l2_std_id idmsk,cmsk,fmsk;
327 struct v4l2_standard *stddefs;
328
329 if (pvrusb2_debug & PVR2_TRACE_STD) {
330 char buf[100];
331 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),id);
332 pvr2_trace(
333 PVR2_TRACE_STD,"Mapping standards mask=0x%x (%.*s)",
334 (int)id,bcnt,buf);
335 }
336
337 *countptr = 0;
338 std_cnt = 0;
339 fmsk = 0;
340 for (idmsk = 1, cmsk = id; cmsk; idmsk <<= 1) {
341 if (!(idmsk & cmsk)) continue;
342 cmsk &= ~idmsk;
343 if (match_std(idmsk)) {
344 std_cnt++;
345 continue;
346 }
347 fmsk |= idmsk;
348 }
349
350 for (idx2 = 0; idx2 < ARRAY_SIZE(std_mixes); idx2++) {
351 if ((id & std_mixes[idx2]) == std_mixes[idx2]) std_cnt++;
352 }
353
354 /* Don't complain about ATSC standard values */
355 fmsk &= ~CSTD_ATSC;
356
357 if (fmsk) {
358 char buf[100];
359 bcnt = pvr2_std_id_to_str(buf,sizeof(buf),fmsk);
360 pvr2_trace(
361 PVR2_TRACE_ERROR_LEGS,
362 "WARNING:"
363 " Failed to classify the following standard(s): %.*s",
364 bcnt,buf);
365 }
366
367 pvr2_trace(PVR2_TRACE_STD,"Setting up %u unique standard(s)",
368 std_cnt);
369 if (!std_cnt) return NULL; // paranoia
370
371 stddefs = kzalloc(sizeof(struct v4l2_standard) * std_cnt,
372 GFP_KERNEL);
373 for (idx = 0; idx < std_cnt; idx++) stddefs[idx].index = idx;
374
375 idx = 0;
376
377 /* Enumerate potential special cases */
378 for (idx2 = 0; (idx2 < ARRAY_SIZE(std_mixes)) && (idx < std_cnt);
379 idx2++) {
380 if (!(id & std_mixes[idx2])) continue;
381 if (pvr2_std_fill(stddefs+idx,std_mixes[idx2])) idx++;
382 }
383 /* Now enumerate individual pieces */
384 for (idmsk = 1, cmsk = id; cmsk && (idx < std_cnt); idmsk <<= 1) {
385 if (!(idmsk & cmsk)) continue;
386 cmsk &= ~idmsk;
387 if (!pvr2_std_fill(stddefs+idx,idmsk)) continue;
388 idx++;
389 }
390
391 *countptr = std_cnt;
392 return stddefs;
393 }
394
395 v4l2_std_id pvr2_std_get_usable(void)
396 {
397 return CSTD_ALL;
398 }
399
400
401 /*
402 Stuff for Emacs to see, in order to encourage consistent editing style:
403 *** Local Variables: ***
404 *** mode: c ***
405 *** fill-column: 75 ***
406 *** tab-width: 8 ***
407 *** c-basic-offset: 8 ***
408 *** End: ***
409 */
410
|
This page was automatically generated by the
LXR engine.
|