← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/media/video/gspca/pac_common.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/video/gspca/pac_common.h
 
1
/*
 
2
 * Pixart PAC207BCA / PAC73xx common functions
 
3
 *
 
4
 * Copyright (C) 2008 Hans de Goede <j.w.r.degoede@hhs.nl>
 
5
 * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
 
6
 * Copyleft (C) 2005 Michel Xhaard mxhaard@magic.fr
 
7
 *
 
8
 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
 
9
 *
 
10
 * This program is free software; you can redistribute it and/or modify
 
11
 * it under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation; either version 2 of the License, or
 
13
 * (at your option) any later version.
 
14
 *
 
15
 * This program is distributed in the hope that it will be useful,
 
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
18
 * GNU General Public License for more details.
 
19
 *
 
20
 * You should have received a copy of the GNU General Public License
 
21
 * along with this program; if not, write to the Free Software
 
22
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
23
 *
 
24
 */
 
25
 
 
26
/* We calculate the autogain at the end of the transfer of a frame, at this
 
27
   moment a frame with the old settings is being captured and transmitted. So
 
28
   if we adjust the gain or exposure we must ignore atleast the next frame for
 
29
   the new settings to come into effect before doing any other adjustments. */
 
30
#define PAC_AUTOGAIN_IGNORE_FRAMES      2
 
31
 
 
32
static const unsigned char pac_sof_marker[5] =
 
33
                { 0xff, 0xff, 0x00, 0xff, 0x96 };
 
34
 
 
35
/*
 
36
   The following state machine finds the SOF marker sequence
 
37
   0xff, 0xff, 0x00, 0xff, 0x96 in a byte stream.
 
38
 
 
39
           +----------+
 
40
           | 0: START |<---------------\
 
41
           +----------+<-\             |
 
42
             |       \---/otherwise    |
 
43
             v 0xff                    |
 
44
           +----------+ otherwise      |
 
45
           |     1    |--------------->*
 
46
           |          |                ^
 
47
           +----------+                |
 
48
             |                         |
 
49
             v 0xff                    |
 
50
           +----------+<-\0xff         |
 
51
        /->|          |--/             |
 
52
        |  |     2    |--------------->*
 
53
        |  |          | otherwise      ^
 
54
        |  +----------+                |
 
55
        |    |                         |
 
56
        |    v 0x00                    |
 
57
        |  +----------+                |
 
58
        |  |     3    |                |
 
59
        |  |          |--------------->*
 
60
        |  +----------+ otherwise      ^
 
61
        |    |                         |
 
62
   0xff |    v 0xff                    |
 
63
        |  +----------+                |
 
64
        \--|     4    |                |
 
65
           |          |----------------/
 
66
           +----------+ otherwise
 
67
             |
 
68
             v 0x96
 
69
           +----------+
 
70
           |  FOUND   |
 
71
           +----------+
 
72
*/
 
73
 
 
74
static unsigned char *pac_find_sof(u8 *sof_read,
 
75
                                        unsigned char *m, int len)
 
76
{
 
77
        int i;
 
78
 
 
79
        /* Search for the SOF marker (fixed part) in the header */
 
80
        for (i = 0; i < len; i++) {
 
81
                switch (*sof_read) {
 
82
                case 0:
 
83
                        if (m[i] == 0xff)
 
84
                                *sof_read = 1;
 
85
                        break;
 
86
                case 1:
 
87
                        if (m[i] == 0xff)
 
88
                                *sof_read = 2;
 
89
                        else
 
90
                                *sof_read = 0;
 
91
                        break;
 
92
                case 2:
 
93
                        switch (m[i]) {
 
94
                        case 0x00:
 
95
                                *sof_read = 3;
 
96
                                break;
 
97
                        case 0xff:
 
98
                                /* stay in this state */
 
99
                                break;
 
100
                        default:
 
101
                                *sof_read = 0;
 
102
                        }
 
103
                        break;
 
104
                case 3:
 
105
                        if (m[i] == 0xff)
 
106
                                *sof_read = 4;
 
107
                        else
 
108
                                *sof_read = 0;
 
109
                        break;
 
110
                case 4:
 
111
                        switch (m[i]) {
 
112
                        case 0x96:
 
113
                                /* Pattern found */
 
114
                                PDEBUG(D_FRAM,
 
115
                                        "SOF found, bytes to analyze: %u."
 
116
                                        " Frame starts at byte #%u",
 
117
                                        len, i + 1);
 
118
                                *sof_read = 0;
 
119
                                return m + i + 1;
 
120
                                break;
 
121
                        case 0xff:
 
122
                                *sof_read = 2;
 
123
                                break;
 
124
                        default:
 
125
                                *sof_read = 0;
 
126
                        }
 
127
                        break;
 
128
                default:
 
129
                        *sof_read = 0;
 
130
                }
 
131
        }
 
132
 
 
133
        return NULL;
 
134
}