Statistics
| Branch: | Revision:

ffmpeg / libavformat / os_support.c @ 19f4ceca

History | View | Annotate | Download (4.78 KB)

1
/*
2
 * Various utilities for ffmpeg system
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 * copyright (c) 2002 Francois Revol
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg 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 GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
#include "config.h"
23
#include "avformat.h"
24
#if defined(__MINGW32__)
25
#include <sys/types.h>
26
#include <sys/timeb.h>
27
#elif defined(CONFIG_OS2)
28
#include <string.h>
29
#include <sys/time.h>
30
#else
31
#include <unistd.h>
32
#include <fcntl.h>
33
#include <sys/time.h>
34
#endif
35
#include <time.h>
36

    
37
#ifndef HAVE_SYS_POLL_H
38
#if defined(__MINGW32__)
39
#include <winsock2.h>
40
#else
41
#include <sys/select.h>
42
#endif
43
#endif
44

    
45
/**
46
 * gets the current time in micro seconds.
47
 */
48
int64_t av_gettime(void)
49
{
50
#if defined(__MINGW32__)
51
    struct timeb tb;
52
    _ftime(&tb);
53
    return ((int64_t)tb.time * INT64_C(1000) + (int64_t)tb.millitm) * INT64_C(1000);
54
#else
55
    struct timeval tv;
56
    gettimeofday(&tv,NULL);
57
    return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
58
#endif
59
}
60

    
61
#if !defined(HAVE_LOCALTIME_R)
62
struct tm *localtime_r(const time_t *t, struct tm *tp)
63
{
64
    struct tm *l;
65

    
66
    l = localtime(t);
67
    if (!l)
68
        return 0;
69
    *tp = *l;
70
    return tp;
71
}
72
#endif /* !defined(HAVE_LOCALTIME_R) */
73

    
74
#ifdef CONFIG_NETWORK
75
#include "network.h"
76

    
77
#if !defined(HAVE_INET_ATON)
78
#include <stdlib.h>
79
#include <strings.h>
80

    
81
int inet_aton (const char * str, struct in_addr * add)
82
{
83
    const char * pch = str;
84
    unsigned int add1 = 0, add2 = 0, add3 = 0, add4 = 0;
85

    
86
    add1 = atoi(pch);
87
    pch = strpbrk(pch,".");
88
    if (pch == 0 || ++pch == 0) goto done;
89
    add2 = atoi(pch);
90
    pch = strpbrk(pch,".");
91
    if (pch == 0 || ++pch == 0) goto done;
92
    add3 = atoi(pch);
93
    pch = strpbrk(pch,".");
94
    if (pch == 0 || ++pch == 0) goto done;
95
    add4 = atoi(pch);
96

    
97
done:
98
    add->s_addr=(add4<<24)+(add3<<16)+(add2<<8)+add1;
99

    
100
    return 1;
101
}
102
#endif /* !defined(HAVE_INET_ATON) */
103

    
104
/* resolve host with also IP address parsing */
105
int resolve_host(struct in_addr *sin_addr, const char *hostname)
106
{
107
    struct hostent *hp;
108

    
109
    if (!inet_aton(hostname, sin_addr)) {
110
        hp = gethostbyname(hostname);
111
        if (!hp)
112
            return -1;
113
        memcpy(sin_addr, hp->h_addr, sizeof(struct in_addr));
114
    }
115
    return 0;
116
}
117

    
118
int ff_socket_nonblock(int socket, int enable)
119
{
120
#ifdef __MINGW32__
121
   return ioctlsocket(socket, FIONBIO, &enable);
122
#else
123
   if (enable)
124
      return fcntl(socket, F_SETFL, fcntl(socket, F_GETFL) | O_NONBLOCK);
125
   else
126
      return fcntl(socket, F_SETFL, fcntl(socket, F_GETFL) & ~O_NONBLOCK);
127
#endif
128
}
129
#endif /* CONFIG_NETWORK */
130

    
131
#ifdef CONFIG_FFSERVER
132
#ifndef HAVE_SYS_POLL_H
133
int poll(struct pollfd *fds, nfds_t numfds, int timeout)
134
{
135
    fd_set read_set;
136
    fd_set write_set;
137
    fd_set exception_set;
138
    nfds_t i;
139
    int n;
140
    int rc;
141

    
142
#ifdef __MINGW32__
143
    if (numfds >= FD_SETSIZE) {
144
        errno = EINVAL;
145
        return -1;
146
    }
147
#endif
148

    
149
    FD_ZERO(&read_set);
150
    FD_ZERO(&write_set);
151
    FD_ZERO(&exception_set);
152

    
153
    n = -1;
154
    for(i = 0; i < numfds; i++) {
155
        if (fds[i].fd < 0)
156
            continue;
157
#ifndef __MINGW32__
158
        if (fds[i].fd >= FD_SETSIZE) {
159
            errno = EINVAL;
160
            return -1;
161
        }
162
#endif
163

    
164
        if (fds[i].events & POLLIN)  FD_SET(fds[i].fd, &read_set);
165
        if (fds[i].events & POLLOUT) FD_SET(fds[i].fd, &write_set);
166
        if (fds[i].events & POLLERR) FD_SET(fds[i].fd, &exception_set);
167

    
168
        if (fds[i].fd > n)
169
            n = fds[i].fd;
170
    };
171

    
172
    if (n == -1)
173
        /* Hey!? Nothing to poll, in fact!!! */
174
        return 0;
175

    
176
    if (timeout < 0)
177
        rc = select(n+1, &read_set, &write_set, &exception_set, NULL);
178
    else {
179
        struct timeval    tv;
180

    
181
        tv.tv_sec = timeout / 1000;
182
        tv.tv_usec = 1000 * (timeout % 1000);
183
        rc = select(n+1, &read_set, &write_set, &exception_set, &tv);
184
    };
185

    
186
    if (rc < 0)
187
        return rc;
188

    
189
    for(i = 0; i < (nfds_t) n; i++) {
190
        fds[i].revents = 0;
191

    
192
        if (FD_ISSET(fds[i].fd, &read_set))      fds[i].revents |= POLLIN;
193
        if (FD_ISSET(fds[i].fd, &write_set))     fds[i].revents |= POLLOUT;
194
        if (FD_ISSET(fds[i].fd, &exception_set)) fds[i].revents |= POLLERR;
195
    };
196

    
197
    return rc;
198
}
199
#endif /* HAVE_SYS_POLL_H */
200
#endif /* CONFIG_FFSERVER */
201