FFmpeg: libavformat/avio.c Source File

FFmpeg

[フレーム]

libavformat

avio.c

Go to the documentation of this file.

1 /*

2 * unbuffered I/O

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 #include "libavutil/avstring.h"

23 #include "libavutil/dict.h"

24 #include "libavutil/opt.h"

25 #include "libavutil/time.h"

26 #include "os_support.h"

27 #include "avformat.h"

28 #if CONFIG_NETWORK

29 #include "network.h"

30 #endif

31 #include "url.h"

33 static URLProtocol *first_protocol = NULL;

35 URLProtocol *ffurl_protocol_next(URLProtocol *prev)

36 {

37 return prev ? prev->next : first_protocol;

38 }

40 /** @name Logging context. */

41 /*@{*/

42 static const char *urlcontext_to_name(void *ptr)

43 {

44 URLContext *h = (URLContext *)ptr;

45 if(h->prot) return h->prot->name;

46 else return "NULL";

47 }

49 static void *urlcontext_child_next(void *obj, void *prev)

50 {

51 URLContext *h = obj;

52 if (!prev && h->priv_data && h->prot->priv_data_class)

53 return h->priv_data;

54 return NULL;

55 }

57 static const AVClass *urlcontext_child_class_next(const AVClass *prev)

58 {

59 URLProtocol *p = NULL;

61 /* find the protocol that corresponds to prev */

62 while (prev && (p = ffurl_protocol_next(p)))

63 if (p->priv_data_class == prev)

64 break;

66 /* find next protocol with priv options */

67 while (p = ffurl_protocol_next(p))

68 if (p->priv_data_class)

69 return p->priv_data_class;

70 return NULL;

72 }

74 static const AVOption options[] = {{NULL}};

75 const AVClass ffurl_context_class = {

76 .class_name = "URLContext",

77 .item_name = urlcontext_to_name,

78 .option = options,

79 .version = LIBAVUTIL_VERSION_INT,

80 .child_next = urlcontext_child_next,

81 .child_class_next = urlcontext_child_class_next,

82 };

83 /*@}*/

86 const char *avio_enum_protocols(void **opaque, int output)

87 {

88 URLProtocol *p;

89 *opaque = ffurl_protocol_next(*opaque);

90 if (!(p = *opaque)) return NULL;

91 if ((output && p->url_write) || (!output && p->url_read))

92 return p->name;

93 return avio_enum_protocols(opaque, output);

94 }

96 int ffurl_register_protocol(URLProtocol *protocol, int size)

97 {

98 URLProtocol **p;

99 if (size < sizeof(URLProtocol)) {

100 URLProtocol* temp = av_mallocz(sizeof(URLProtocol));

101 memcpy(temp, protocol, size);

102 protocol = temp;

103 }

104 p = &first_protocol;

105 while (*p != NULL) p = &(*p)->next;

106 *p = protocol;

107 protocol->next = NULL;

108 return 0;

109 }

110

111 static int url_alloc_for_protocol (URLContext **puc, struct URLProtocol *up,

112 const char *filename, int flags,

113 const AVIOInterruptCB *int_cb)

114 {

115 URLContext *uc;

116 int err;

117

118 #if CONFIG_NETWORK

119 if (up->flags & URL_PROTOCOL_FLAG_NETWORK && !ff_network_init())

120 return AVERROR(EIO);

121 #endif

122 if ((flags & AVIO_FLAG_READ) && !up->url_read) {

123 av_log(NULL, AV_LOG_ERROR,

124 "Impossible to open the '%s' protocol for reading\n", up->name);

125 return AVERROR(EIO);

126 }

127 if ((flags & AVIO_FLAG_WRITE) && !up->url_write) {

128 av_log(NULL, AV_LOG_ERROR,

129 "Impossible to open the '%s' protocol for writing\n", up->name);

130 return AVERROR(EIO);

131 }

132 uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1);

133 if (!uc) {

134 err = AVERROR(ENOMEM);

135 goto fail;

136 }

137 uc->av_class = &ffurl_context_class;

138 uc->filename = (char *) &uc[1];

139 strcpy(uc->filename, filename);

140 uc->prot = up;

141 uc->flags = flags;

142 uc->is_streamed = 0; /* default = not streamed */

143 uc->max_packet_size = 0; /* default: stream file */

144 if (up->priv_data_size) {

145 uc->priv_data = av_mallocz(up->priv_data_size);

146 if (up->priv_data_class) {

147 int proto_len= strlen(up->name);

148 char *start = strchr(uc->filename, ',');

149 *(const AVClass**)uc->priv_data = up->priv_data_class;

150 av_opt_set_defaults(uc->priv_data);

151 if(!strncmp(up->name, uc->filename, proto_len) && uc->filename + proto_len == start){

152 int ret= 0;

153 char *p= start;

154 char sep= *++p;

155 char *key, *val;

156 p++;

157 while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){

158 *val= *key= 0;

159 ret= av_opt_set(uc->priv_data, p, key+1, 0);

160 if (ret == AVERROR_OPTION_NOT_FOUND)

161 av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p);

162 *val= *key= sep;

163 p= val+1;

164 }

165 if(ret<0 || p!=key){

166 av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start);

167 av_freep(&uc->priv_data);

168 av_freep(&uc);

169 err = AVERROR(EINVAL);

170 goto fail;

171 }

172 memmove(start, key+1, strlen(key));

173 }

174 }

175 }

176 if (int_cb)

177 uc->interrupt_callback = *int_cb;

178

179 *puc = uc;

180 return 0;

181 fail:

182 *puc = NULL;

183 #if CONFIG_NETWORK

184 if (up->flags & URL_PROTOCOL_FLAG_NETWORK)

185 ff_network_close();

186 #endif

187 return err;

188 }

189

190 int ffurl_connect(URLContext* uc, AVDictionary **options)

191 {

192 int err =

193 uc->prot->url_open2 ? uc->prot->url_open2(uc, uc->filename, uc->flags, options) :

194 uc->prot->url_open(uc, uc->filename, uc->flags);

195 if (err)

196 return err;

197 uc->is_connected = 1;

198 //We must be careful here as ffurl_seek() could be slow, for example for http

199 if( (uc->flags & AVIO_FLAG_WRITE)

200 || !strcmp(uc->prot->name, "file"))

201 if(!uc->is_streamed && ffurl_seek(uc, 0, SEEK_SET) < 0)

202 uc->is_streamed= 1;

203 return 0;

204 }

205

206 #define URL_SCHEME_CHARS \

207 "abcdefghijklmnopqrstuvwxyz" \

208 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \

209 "0123456789+-."

210

211 int ffurl_alloc(URLContext **puc, const char *filename, int flags,

212 const AVIOInterruptCB *int_cb)

213 {

214 URLProtocol *up = NULL;

215 char proto_str[128], proto_nested[128], *ptr;

216 size_t proto_len = strspn(filename, URL_SCHEME_CHARS);

217

218 if (!first_protocol) {

219 av_log(NULL, AV_LOG_WARNING, "No URL Protocols are registered. "

220 "Missing call to av_register_all()?\n");

221 }

222

223 if (filename[proto_len] != ':' &&

224 (filename[proto_len] != ',' || !strchr(filename + proto_len + 1, ':')) ||

225 is_dos_path(filename))

226 strcpy(proto_str, "file");

227 else

228 av_strlcpy(proto_str, filename, FFMIN(proto_len+1, sizeof(proto_str)));

229

230 if ((ptr = strchr(proto_str, ',')))

231 *ptr = '0円';

232 av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));

233 if ((ptr = strchr(proto_nested, '+')))

234 *ptr = '0円';

235

236 while (up = ffurl_protocol_next(up)) {

237 if (!strcmp(proto_str, up->name))

238 return url_alloc_for_protocol (puc, up, filename, flags, int_cb);

239 if (up->flags & URL_PROTOCOL_FLAG_NESTED_SCHEME &&

240 !strcmp(proto_nested, up->name))

241 return url_alloc_for_protocol (puc, up, filename, flags, int_cb);

242 }

243 *puc = NULL;

244 return AVERROR_PROTOCOL_NOT_FOUND;

245 }

246

247 int ffurl_open(URLContext **puc, const char *filename, int flags,

248 const AVIOInterruptCB *int_cb, AVDictionary **options)

249 {

250 int ret = ffurl_alloc(puc, filename, flags, int_cb);

251 if (ret)

252 return ret;

253 if (options && (*puc)->prot->priv_data_class &&

254 (ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)

255 goto fail;

256 ret = ffurl_connect(*puc, options);

257 if (!ret)

258 return 0;

259 fail:

260 ffurl_close(*puc);

261 *puc = NULL;

262 return ret;

263 }

264

265 static inline int retry_transfer_wrapper(URLContext *h, unsigned char *buf, int size, int size_min,

266 int (*transfer_func)(URLContext *h, unsigned char *buf, int size))

267 {

268 int ret, len;

269 int fast_retries = 5;

270 int64_t wait_since = 0;

271

272 len = 0;

273 while (len < size_min) {

274 ret = transfer_func(h, buf+len, size-len);

275 if (ret == AVERROR(EINTR))

276 continue;

277 if (h->flags & AVIO_FLAG_NONBLOCK)

278 return ret;

279 if (ret == AVERROR(EAGAIN)) {

280 ret = 0;

281 if (fast_retries) {

282 fast_retries--;

283 } else {

284 if (h->rw_timeout) {

285 if (!wait_since)

286 wait_since = av_gettime();

287 else if (av_gettime() > wait_since + h->rw_timeout)

288 return AVERROR(EIO);

289 }

290 av_usleep(1000);

291 }

292 } else if (ret < 1)

293 return (ret < 0 && ret != AVERROR_EOF) ? ret : len;

294 if (ret)

295 fast_retries = FFMAX(fast_retries, 2);

296 len += ret;

297 if (len < size && ff_check_interrupt(&h->interrupt_callback))

298 return AVERROR_EXIT;

299 }

300 return len;

301 }

302

303 int ffurl_read(URLContext *h, unsigned char *buf, int size)

304 {

305 if (!(h->flags & AVIO_FLAG_READ))

306 return AVERROR(EIO);

307 return retry_transfer_wrapper(h, buf, size, 1, h->prot->url_read);

308 }

309

310 int ffurl_read_complete(URLContext *h, unsigned char *buf, int size)

311 {

312 if (!(h->flags & AVIO_FLAG_READ))

313 return AVERROR(EIO);

314 return retry_transfer_wrapper(h, buf, size, size, h->prot->url_read);

315 }

316

317 int ffurl_write(URLContext *h, const unsigned char *buf, int size)

318 {

319 if (!(h->flags & AVIO_FLAG_WRITE))

320 return AVERROR(EIO);

321 /* avoid sending too big packets */

322 if (h->max_packet_size && size > h->max_packet_size)

323 return AVERROR(EIO);

324

325 return retry_transfer_wrapper(h, (unsigned char *)buf, size, size, (void*)h->prot->url_write);

326 }

327

328 int64_t ffurl_seek(URLContext *h, int64_t pos, int whence)

329 {

330 int64_t ret;

331

332 if (!h->prot->url_seek)

333 return AVERROR(ENOSYS);

334 ret = h->prot->url_seek(h, pos, whence & ~AVSEEK_FORCE);

335 return ret;

336 }

337

338 int ffurl_closep(URLContext **hh)

339 {

340 URLContext *h= *hh;

341 int ret = 0;

342 if (!h) return 0; /* can happen when ffurl_open fails */

343

344 if (h->is_connected && h->prot->url_close)

345 ret = h->prot->url_close(h);

346 #if CONFIG_NETWORK

347 if (h->prot->flags & URL_PROTOCOL_FLAG_NETWORK)

348 ff_network_close();

349 #endif

350 if (h->prot->priv_data_size) {

351 if (h->prot->priv_data_class)

352 av_opt_free(h->priv_data);

353 av_freep(&h->priv_data);

354 }

355 av_freep(hh);

356 return ret;

357 }

358

359 int ffurl_close(URLContext *h)

360 {

361 return ffurl_closep(&h);

362 }

363

364

365 int avio_check(const char *url, int flags)

366 {

367 URLContext *h;

368 int ret = ffurl_alloc(&h, url, flags, NULL);

369 if (ret)

370 return ret;

371

372 if (h->prot->url_check) {

373 ret = h->prot->url_check(h, flags);

374 } else {

375 ret = ffurl_connect(h, NULL);

376 if (ret >= 0)

377 ret = flags;

378 }

379

380 ffurl_close(h);

381 return ret;

382 }

383

384 int64_t ffurl_size(URLContext *h)

385 {

386 int64_t pos, size;

387

388 size= ffurl_seek(h, 0, AVSEEK_SIZE);

389 if(size<0){

390 pos = ffurl_seek(h, 0, SEEK_CUR);

391 if ((size = ffurl_seek(h, -1, SEEK_END)) < 0)

392 return size;

393 size++;

394 ffurl_seek(h, pos, SEEK_SET);

395 }

396 return size;

397 }

398

399 int ffurl_get_file_handle(URLContext *h)

400 {

401 if (!h->prot->url_get_file_handle)

402 return -1;

403 return h->prot->url_get_file_handle(h);

404 }

405

406 int ffurl_get_multi_file_handle(URLContext *h, int **handles, int *numhandles)

407 {

408 if (!h->prot->url_get_multi_file_handle) {

409 if (!h->prot->url_get_file_handle)

410 return AVERROR(ENOSYS);

411 *handles = av_malloc(sizeof(**handles));

412 if (!*handles)

413 return AVERROR(ENOMEM);

414 *numhandles = 1;

415 *handles[0] = h->prot->url_get_file_handle(h);

416 return 0;

417 }

418 return h->prot->url_get_multi_file_handle(h, handles, numhandles);

419 }

420

421 int ffurl_shutdown(URLContext *h, int flags)

422 {

423 if (!h->prot->url_shutdown)

424 return AVERROR(EINVAL);

425 return h->prot->url_shutdown(h, flags);

426 }

427

428 int ff_check_interrupt(AVIOInterruptCB *cb)

429 {

430 int ret;

431 if (cb && cb->callback && (ret = cb->callback(cb->opaque)))

432 return ret;

433 return 0;

434 }

Generated on Wed Jul 10 2013 23:48:11 for FFmpeg by doxygen 1.8.2