ffmpeg / libavformat / grab_bktr.c @ 5509bffa
History | View | Annotate | Download (8.29 KB)
1 |
/*
|
---|---|
2 |
* *BSD video grab interface
|
3 |
* Copyright (c) 2002 Steve O'Hara-Smith
|
4 |
* based on
|
5 |
* Linux video grab interface
|
6 |
* Copyright (c) 2000,2001 Gerard Lantau.
|
7 |
* and
|
8 |
* simple_grab.c Copyright (c) 1999 Roger Hardiman
|
9 |
*
|
10 |
* This library is free software; you can redistribute it and/or
|
11 |
* modify it under the terms of the GNU Lesser General Public
|
12 |
* License as published by the Free Software Foundation; either
|
13 |
* version 2 of the License, or (at your option) any later version.
|
14 |
*
|
15 |
* This library 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 GNU
|
18 |
* Lesser General Public License for more details.
|
19 |
*
|
20 |
* You should have received a copy of the GNU Lesser General Public
|
21 |
* License along with this library; if not, write to the Free Software
|
22 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
23 |
*/
|
24 |
#include "avformat.h" |
25 |
#if defined(__FreeBSD__)
|
26 |
# if __FreeBSD__ >= 502100 |
27 |
# include <dev/bktr/ioctl_meteor.h> |
28 |
# include <dev/bktr/ioctl_bt848.h> |
29 |
# else
|
30 |
# include <machine/ioctl_meteor.h> |
31 |
# include <machine/ioctl_bt848.h> |
32 |
# endif
|
33 |
#elif defined(__DragonFly__)
|
34 |
# include <dev/video/meteor/ioctl_meteor.h> |
35 |
# include <dev/video/bktr/ioctl_bt848.h> |
36 |
#else
|
37 |
# include <dev/ic/bt8xx.h> |
38 |
#endif
|
39 |
#include <unistd.h> |
40 |
#include <fcntl.h> |
41 |
#include <sys/ioctl.h> |
42 |
#include <sys/mman.h> |
43 |
#include <sys/time.h> |
44 |
#include <signal.h> |
45 |
|
46 |
typedef struct { |
47 |
int video_fd;
|
48 |
int tuner_fd;
|
49 |
int width, height;
|
50 |
int frame_rate;
|
51 |
int frame_rate_base;
|
52 |
u_int64_t per_frame; |
53 |
} VideoData; |
54 |
|
55 |
|
56 |
#define PAL 1 |
57 |
#define PALBDGHI 1 |
58 |
#define NTSC 2 |
59 |
#define NTSCM 2 |
60 |
#define SECAM 3 |
61 |
#define PALN 4 |
62 |
#define PALM 5 |
63 |
#define NTSCJ 6 |
64 |
|
65 |
/* PAL is 768 x 576. NTSC is 640 x 480 */
|
66 |
#define PAL_HEIGHT 576 |
67 |
#define SECAM_HEIGHT 576 |
68 |
#define NTSC_HEIGHT 480 |
69 |
|
70 |
#ifndef VIDEO_FORMAT
|
71 |
#define VIDEO_FORMAT NTSC
|
72 |
#endif
|
73 |
|
74 |
static int bktr_dev[] = { METEOR_DEV0, METEOR_DEV1, METEOR_DEV2, |
75 |
METEOR_DEV3, METEOR_DEV_SVIDEO }; |
76 |
|
77 |
uint8_t *video_buf; |
78 |
size_t video_buf_size; |
79 |
u_int64_t last_frame_time; |
80 |
volatile sig_atomic_t nsignals;
|
81 |
|
82 |
|
83 |
static void catchsignal(int signal) |
84 |
{ |
85 |
nsignals++; |
86 |
return;
|
87 |
} |
88 |
|
89 |
static int bktr_init(const char *video_device, int width, int height, |
90 |
int format, int *video_fd, int *tuner_fd, int idev, double frequency) |
91 |
{ |
92 |
struct meteor_geomet geo;
|
93 |
int h_max;
|
94 |
long ioctl_frequency;
|
95 |
char *arg;
|
96 |
int c;
|
97 |
struct sigaction act, old;
|
98 |
|
99 |
if (idev < 0 || idev > 4) |
100 |
{ |
101 |
arg = getenv ("BKTR_DEV");
|
102 |
if (arg)
|
103 |
idev = atoi (arg); |
104 |
if (idev < 0 || idev > 4) |
105 |
idev = 1;
|
106 |
} |
107 |
|
108 |
if (format < 1 || format > 6) |
109 |
{ |
110 |
arg = getenv ("BKTR_FORMAT");
|
111 |
if (arg)
|
112 |
format = atoi (arg); |
113 |
if (format < 1 || format > 6) |
114 |
format = VIDEO_FORMAT; |
115 |
} |
116 |
|
117 |
if (frequency <= 0) |
118 |
{ |
119 |
arg = getenv ("BKTR_FREQUENCY");
|
120 |
if (arg)
|
121 |
frequency = atof (arg); |
122 |
if (frequency <= 0) |
123 |
frequency = 0.0; |
124 |
} |
125 |
|
126 |
memset(&act, 0, sizeof(act)); |
127 |
sigemptyset(&act.sa_mask); |
128 |
act.sa_handler = catchsignal; |
129 |
sigaction(SIGUSR1, &act, &old); |
130 |
|
131 |
*tuner_fd = open("/dev/tuner0", O_RDONLY);
|
132 |
if (*tuner_fd < 0) |
133 |
perror("Warning: Tuner not opened, continuing");
|
134 |
|
135 |
*video_fd = open(video_device, O_RDONLY); |
136 |
if (*video_fd < 0) { |
137 |
perror(video_device); |
138 |
return -1; |
139 |
} |
140 |
|
141 |
geo.rows = height; |
142 |
geo.columns = width; |
143 |
geo.frames = 1;
|
144 |
geo.oformat = METEOR_GEO_YUV_422 | METEOR_GEO_YUV_12; |
145 |
|
146 |
switch (format) {
|
147 |
case PAL: h_max = PAL_HEIGHT; c = BT848_IFORM_F_PALBDGHI; break; |
148 |
case PALN: h_max = PAL_HEIGHT; c = BT848_IFORM_F_PALN; break; |
149 |
case PALM: h_max = PAL_HEIGHT; c = BT848_IFORM_F_PALM; break; |
150 |
case SECAM: h_max = SECAM_HEIGHT; c = BT848_IFORM_F_SECAM; break; |
151 |
case NTSC: h_max = NTSC_HEIGHT; c = BT848_IFORM_F_NTSCM; break; |
152 |
case NTSCJ: h_max = NTSC_HEIGHT; c = BT848_IFORM_F_NTSCJ; break; |
153 |
default: h_max = PAL_HEIGHT; c = BT848_IFORM_F_PALBDGHI; break; |
154 |
} |
155 |
|
156 |
if (height <= h_max / 2) |
157 |
geo.oformat |= METEOR_GEO_EVEN_ONLY; |
158 |
|
159 |
if (ioctl(*video_fd, METEORSETGEO, &geo) < 0) { |
160 |
perror("METEORSETGEO");
|
161 |
return -1; |
162 |
} |
163 |
|
164 |
if (ioctl(*video_fd, BT848SFMT, &c) < 0) { |
165 |
perror("BT848SFMT");
|
166 |
return -1; |
167 |
} |
168 |
|
169 |
c = bktr_dev[idev]; |
170 |
if (ioctl(*video_fd, METEORSINPUT, &c) < 0) { |
171 |
perror("METEORSINPUT");
|
172 |
return -1; |
173 |
} |
174 |
|
175 |
video_buf_size = width * height * 12 / 8; |
176 |
|
177 |
video_buf = (uint8_t *)mmap((caddr_t)0, video_buf_size,
|
178 |
PROT_READ, MAP_SHARED, *video_fd, (off_t)0);
|
179 |
if (video_buf == MAP_FAILED) {
|
180 |
perror("mmap");
|
181 |
return -1; |
182 |
} |
183 |
|
184 |
if (frequency != 0.0) { |
185 |
ioctl_frequency = (unsigned long)(frequency*16); |
186 |
if (ioctl(*tuner_fd, TVTUNER_SETFREQ, &ioctl_frequency) < 0) |
187 |
perror("TVTUNER_SETFREQ");
|
188 |
} |
189 |
|
190 |
c = AUDIO_UNMUTE; |
191 |
if (ioctl(*tuner_fd, BT848_SAUDIO, &c) < 0) |
192 |
perror("TVTUNER_SAUDIO");
|
193 |
|
194 |
c = METEOR_CAP_CONTINOUS; |
195 |
ioctl(*video_fd, METEORCAPTUR, &c); |
196 |
|
197 |
c = SIGUSR1; |
198 |
ioctl(*video_fd, METEORSSIGNAL, &c); |
199 |
|
200 |
return 0; |
201 |
} |
202 |
|
203 |
static void bktr_getframe(u_int64_t per_frame) |
204 |
{ |
205 |
u_int64_t curtime; |
206 |
|
207 |
curtime = av_gettime(); |
208 |
if (!last_frame_time
|
209 |
|| ((last_frame_time + per_frame) > curtime)) { |
210 |
if (!usleep(last_frame_time + per_frame + per_frame / 8 - curtime)) { |
211 |
if (!nsignals)
|
212 |
av_log(NULL, AV_LOG_INFO,
|
213 |
"SLEPT NO signals - %d microseconds late\n",
|
214 |
(int)(av_gettime() - last_frame_time - per_frame));
|
215 |
} |
216 |
} |
217 |
nsignals = 0;
|
218 |
last_frame_time = curtime; |
219 |
} |
220 |
|
221 |
|
222 |
/* note: we support only one picture read at a time */
|
223 |
static int grab_read_packet(AVFormatContext *s1, AVPacket *pkt) |
224 |
{ |
225 |
VideoData *s = s1->priv_data; |
226 |
|
227 |
if (av_new_packet(pkt, video_buf_size) < 0) |
228 |
return -EIO;
|
229 |
|
230 |
bktr_getframe(s->per_frame); |
231 |
|
232 |
pkt->pts = av_gettime() & ((1LL << 48) - 1); |
233 |
memcpy(pkt->data, video_buf, video_buf_size); |
234 |
|
235 |
return video_buf_size;
|
236 |
} |
237 |
|
238 |
static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap) |
239 |
{ |
240 |
VideoData *s = s1->priv_data; |
241 |
AVStream *st; |
242 |
int width, height;
|
243 |
int frame_rate;
|
244 |
int frame_rate_base;
|
245 |
int format = -1; |
246 |
const char *video_device; |
247 |
|
248 |
if (!ap || ap->width <= 0 || ap->height <= 0 || ap->time_base.den <= 0) |
249 |
return -1; |
250 |
|
251 |
width = ap->width; |
252 |
height = ap->height; |
253 |
frame_rate = ap->time_base.den; |
254 |
frame_rate_base = ap->time_base.num; |
255 |
|
256 |
video_device = ap->device; |
257 |
if (!video_device)
|
258 |
video_device = "/dev/bktr0";
|
259 |
|
260 |
st = av_new_stream(s1, 0);
|
261 |
if (!st)
|
262 |
return -ENOMEM;
|
263 |
av_set_pts_info(st, 48, 1, 1000000); /* 48 bits pts in use */ |
264 |
|
265 |
s->width = width; |
266 |
s->height = height; |
267 |
s->frame_rate = frame_rate; |
268 |
s->frame_rate_base = frame_rate_base; |
269 |
s->per_frame = ((u_int64_t)1000000 * s->frame_rate_base) / s->frame_rate;
|
270 |
|
271 |
st->codec->codec_type = CODEC_TYPE_VIDEO; |
272 |
st->codec->pix_fmt = PIX_FMT_YUV420P; |
273 |
st->codec->codec_id = CODEC_ID_RAWVIDEO; |
274 |
st->codec->width = width; |
275 |
st->codec->height = height; |
276 |
st->codec->time_base.den = frame_rate; |
277 |
st->codec->time_base.num = frame_rate_base; |
278 |
|
279 |
if (ap->standard) {
|
280 |
if (!strcasecmp(ap->standard, "pal")) |
281 |
format = PAL; |
282 |
else if (!strcasecmp(ap->standard, "secam")) |
283 |
format = SECAM; |
284 |
else if (!strcasecmp(ap->standard, "ntsc")) |
285 |
format = NTSC; |
286 |
} |
287 |
|
288 |
if (bktr_init(video_device, width, height, format,
|
289 |
&(s->video_fd), &(s->tuner_fd), -1, 0.0) < 0) |
290 |
return -EIO;
|
291 |
|
292 |
nsignals = 0;
|
293 |
last_frame_time = 0;
|
294 |
|
295 |
return 0; |
296 |
} |
297 |
|
298 |
static int grab_read_close(AVFormatContext *s1) |
299 |
{ |
300 |
VideoData *s = s1->priv_data; |
301 |
int c;
|
302 |
|
303 |
c = METEOR_CAP_STOP_CONT; |
304 |
ioctl(s->video_fd, METEORCAPTUR, &c); |
305 |
close(s->video_fd); |
306 |
|
307 |
c = AUDIO_MUTE; |
308 |
ioctl(s->tuner_fd, BT848_SAUDIO, &c); |
309 |
close(s->tuner_fd); |
310 |
|
311 |
munmap((caddr_t)video_buf, video_buf_size); |
312 |
|
313 |
return 0; |
314 |
} |
315 |
|
316 |
AVInputFormat video_grab_device_format = { |
317 |
"bktr",
|
318 |
"video grab",
|
319 |
sizeof(VideoData),
|
320 |
NULL,
|
321 |
grab_read_header, |
322 |
grab_read_packet, |
323 |
grab_read_close, |
324 |
.flags = AVFMT_NOFILE, |
325 |
}; |
326 |
|
327 |
int video_grab_init(void) |
328 |
{ |
329 |
av_register_input_format(&video_grab_device_format); |
330 |
return 0; |
331 |
} |