0
|
1 /*
|
|
2 * FFM (ffserver live feed) encoder and decoder
|
|
3 * Copyright (c) 2001 Fabrice Bellard.
|
|
4 *
|
|
5 * This library is free software; you can redistribute it and/or
|
|
6 * modify it under the terms of the GNU Lesser General Public
|
|
7 * License as published by the Free Software Foundation; either
|
|
8 * version 2 of the License, or (at your option) any later version.
|
|
9 *
|
|
10 * This library 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 GNU
|
|
13 * Lesser General Public License for more details.
|
|
14 *
|
|
15 * You should have received a copy of the GNU Lesser General Public
|
|
16 * License along with this library; if not, write to the Free Software
|
|
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
18 */
|
|
19 #include "avformat.h"
|
|
20 #include <unistd.h>
|
|
21
|
|
22 /* The FFM file is made of blocks of fixed size */
|
|
23 #define FFM_HEADER_SIZE 14
|
|
24 #define PACKET_ID 0x666d
|
|
25
|
|
26 /* each packet contains frames (which can span several packets */
|
|
27 #define FRAME_HEADER_SIZE 8
|
|
28 #define FLAG_KEY_FRAME 0x01
|
|
29
|
|
30 typedef struct FFMStream {
|
|
31 INT64 pts;
|
|
32 } FFMStream;
|
|
33
|
|
34 enum {
|
|
35 READ_HEADER,
|
|
36 READ_DATA,
|
|
37 };
|
|
38
|
|
39 typedef struct FFMContext {
|
|
40 /* only reading mode */
|
|
41 offset_t write_index, file_size;
|
|
42 int read_state;
|
|
43 UINT8 header[FRAME_HEADER_SIZE];
|
|
44
|
|
45 /* read and write */
|
|
46 int first_packet; /* true if first packet, needed to set the discontinuity tag */
|
|
47 int packet_size;
|
|
48 int frame_offset;
|
|
49 INT64 pts;
|
|
50 UINT8 *packet_ptr, *packet_end;
|
|
51 UINT8 packet[FFM_PACKET_SIZE];
|
|
52 } FFMContext;
|
|
53
|
|
54 /* disable pts hack for testing */
|
|
55 int ffm_nopts = 0;
|
|
56
|
|
57 static void flush_packet(AVFormatContext *s)
|
|
58 {
|
|
59 FFMContext *ffm = s->priv_data;
|
|
60 int fill_size, h;
|
|
61 ByteIOContext *pb = &s->pb;
|
|
62
|
|
63 fill_size = ffm->packet_end - ffm->packet_ptr;
|
|
64 memset(ffm->packet_ptr, 0, fill_size);
|
|
65
|
|
66 /* put header */
|
|
67 put_be16(pb, PACKET_ID);
|
|
68 put_be16(pb, fill_size);
|
|
69 put_be64(pb, ffm->pts);
|
|
70 h = ffm->frame_offset;
|
|
71 if (ffm->first_packet)
|
|
72 h |= 0x8000;
|
|
73 put_be16(pb, h);
|
|
74 put_buffer(pb, ffm->packet, ffm->packet_end - ffm->packet);
|
|
75
|
|
76 /* prepare next packet */
|
|
77 ffm->frame_offset = 0; /* no key frame */
|
|
78 ffm->pts = 0; /* no pts */
|
|
79 ffm->packet_ptr = ffm->packet;
|
|
80 ffm->first_packet = 0;
|
|
81 }
|
|
82
|
|
83 /* 'first' is true if first data of a frame */
|
|
84 static void ffm_write_data(AVFormatContext *s,
|
|
85 UINT8 *buf, int size,
|
|
86 INT64 pts, int first)
|
|
87 {
|
|
88 FFMContext *ffm = s->priv_data;
|
|
89 int len;
|
|
90
|
|
91 if (first && ffm->frame_offset == 0)
|
|
92 ffm->frame_offset = ffm->packet_ptr - ffm->packet + FFM_HEADER_SIZE;
|
|
93 if (first && ffm->pts == 0)
|
|
94 ffm->pts = pts;
|
|
95
|
|
96 /* write as many packets as needed */
|
|
97 while (size > 0) {
|
|
98 len = ffm->packet_end - ffm->packet_ptr;
|
|
99 if (len > size)
|
|
100 len = size;
|
|
101 memcpy(ffm->packet_ptr, buf, len);
|
|
102
|
|
103 ffm->packet_ptr += len;
|
|
104 buf += len;
|
|
105 size -= len;
|
|
106 if (ffm->packet_ptr >= ffm->packet_end) {
|
|
107 /* special case : no pts in packet : we leave the current one */
|
|
108 if (ffm->pts == 0)
|
|
109 ffm->pts = pts;
|
|
110
|
|
111 flush_packet(s);
|
|
112 }
|
|
113 }
|
|
114 }
|
|
115
|
|
116 static int ffm_write_header(AVFormatContext *s)
|
|
117 {
|
|
118 FFMContext *ffm = s->priv_data;
|
|
119 AVStream *st;
|
|
120 FFMStream *fst;
|
|
121 ByteIOContext *pb = &s->pb;
|
|
122 AVCodecContext *codec;
|
|
123 int bit_rate, i;
|
|
124
|
|
125 ffm->packet_size = FFM_PACKET_SIZE;
|
|
126
|
|
127 /* header */
|
|
128 put_tag(pb, "FFM1");
|
|
129 put_be32(pb, ffm->packet_size);
|
|
130 /* XXX: store write position in other file ? */
|
|
131 put_be64(pb, ffm->packet_size); /* current write position */
|
|
132
|
|
133 put_be32(pb, s->nb_streams);
|
|
134 bit_rate = 0;
|
|
135 for(i=0;i<s->nb_streams;i++) {
|
|
136 st = s->streams[i];
|
|
137 bit_rate += st->codec.bit_rate;
|
|
138 }
|
|
139 put_be32(pb, bit_rate);
|
|
140
|
|
141 /* list of streams */
|
|
142 for(i=0;i<s->nb_streams;i++) {
|
|
143 st = s->streams[i];
|
|
144 fst = av_mallocz(sizeof(FFMStream));
|
|
145 if (!fst)
|
|
146 goto fail;
|
|
147 st->priv_data = fst;
|
|
148
|
|
149 codec = &st->codec;
|
|
150 /* generic info */
|
|
151 put_be32(pb, codec->codec_id);
|
|
152 put_byte(pb, codec->codec_type);
|
|
153 put_be32(pb, codec->bit_rate);
|
5
|
154 put_be32(pb, st->quality);
|
0
|
155 put_be32(pb, codec->flags);
|
|
156 /* specific info */
|
|
157 switch(codec->codec_type) {
|
|
158 case CODEC_TYPE_VIDEO:
|
|
159 put_be32(pb, (codec->frame_rate * 1000) / FRAME_RATE_BASE);
|
|
160 put_be16(pb, codec->width);
|
|
161 put_be16(pb, codec->height);
|
|
162 put_be16(pb, codec->gop_size);
|
|
163 put_byte(pb, codec->qmin);
|
|
164 put_byte(pb, codec->qmax);
|
|
165 put_byte(pb, codec->max_qdiff);
|
|
166 put_be16(pb, (int) (codec->qcompress * 10000.0));
|
|
167 put_be16(pb, (int) (codec->qblur * 10000.0));
|
|
168 put_be32(pb, codec->bit_rate_tolerance);
|
|
169 put_strz(pb, codec->rc_eq);
|
|
170 put_be32(pb, codec->rc_max_rate);
|
|
171 put_be32(pb, codec->rc_min_rate);
|
|
172 put_be32(pb, codec->rc_buffer_size);
|
|
173 put_be64_double(pb, codec->i_quant_factor);
|
|
174 put_be64_double(pb, codec->b_quant_factor);
|
|
175 put_be64_double(pb, codec->i_quant_offset);
|
|
176 put_be64_double(pb, codec->b_quant_offset);
|
|
177 put_be32(pb, codec->dct_algo);
|
|
178 break;
|
|
179 case CODEC_TYPE_AUDIO:
|
|
180 put_be32(pb, codec->sample_rate);
|
|
181 put_le16(pb, codec->channels);
|
|
182 put_le16(pb, codec->frame_size);
|
|
183 break;
|
|
184 default:
|
|
185 av_abort();
|
|
186 }
|
|
187 /* hack to have real time */
|
|
188 if (ffm_nopts)
|
|
189 fst->pts = 0;
|
|
190 else
|
|
191 fst->pts = av_gettime();
|
|
192 }
|
|
193
|
|
194 /* flush until end of block reached */
|
|
195 while ((url_ftell(pb) % ffm->packet_size) != 0)
|
|
196 put_byte(pb, 0);
|
|
197
|
|
198 put_flush_packet(pb);
|
|
199
|
|
200 /* init packet mux */
|
|
201 ffm->packet_ptr = ffm->packet;
|
|
202 ffm->packet_end = ffm->packet + ffm->packet_size - FFM_HEADER_SIZE;
|
|
203 ffm->frame_offset = 0;
|
|
204 ffm->pts = 0;
|
|
205 ffm->first_packet = 1;
|
|
206
|
|
207 return 0;
|
|
208 fail:
|
|
209 for(i=0;i<s->nb_streams;i++) {
|
|
210 st = s->streams[i];
|
|
211 av_freep(&st->priv_data);
|
|
212 }
|
|
213 return -1;
|
|
214 }
|
|
215
|
|
216 static int ffm_write_packet(AVFormatContext *s, int stream_index,
|
|
217 UINT8 *buf, int size, int force_pts)
|
|
218 {
|
|
219 AVStream *st = s->streams[stream_index];
|
|
220 FFMStream *fst = st->priv_data;
|
|
221 INT64 pts;
|
|
222 UINT8 header[FRAME_HEADER_SIZE];
|
|
223 int duration;
|
|
224
|
|
225 if (st->codec.codec_type == CODEC_TYPE_AUDIO) {
|
|
226 duration = ((float)st->codec.frame_size / st->codec.sample_rate * 1000000.0);
|
|
227 } else {
|
|
228 duration = (1000000.0 * FRAME_RATE_BASE / (float)st->codec.frame_rate);
|
|
229 }
|
|
230
|
|
231 pts = fst->pts;
|
|
232 /* packet size & key_frame */
|
|
233 header[0] = stream_index;
|
|
234 header[1] = 0;
|
7
|
235 if (st->codec.coded_frame->key_frame) //if st->codec.coded_frame==NULL then there is a bug somewhere else
|
0
|
236 header[1] |= FLAG_KEY_FRAME;
|
|
237 header[2] = (size >> 16) & 0xff;
|
|
238 header[3] = (size >> 8) & 0xff;
|
|
239 header[4] = size & 0xff;
|
|
240 header[5] = (duration >> 16) & 0xff;
|
|
241 header[6] = (duration >> 8) & 0xff;
|
|
242 header[7] = duration & 0xff;
|
|
243 ffm_write_data(s, header, FRAME_HEADER_SIZE, pts, 1);
|
|
244 ffm_write_data(s, buf, size, pts, 0);
|
|
245
|
|
246 fst->pts += duration;
|
|
247 return 0;
|
|
248 }
|
|
249
|
|
250 static int ffm_write_trailer(AVFormatContext *s)
|
|
251 {
|
|
252 ByteIOContext *pb = &s->pb;
|
|
253 FFMContext *ffm = s->priv_data;
|
|
254 int i;
|
|
255
|
|
256 /* flush packets */
|
|
257 if (ffm->packet_ptr > ffm->packet)
|
|
258 flush_packet(s);
|
|
259
|
|
260 put_flush_packet(pb);
|
|
261
|
|
262 if (!url_is_streamed(pb)) {
|
|
263 INT64 size;
|
|
264 /* update the write offset */
|
|
265 size = url_ftell(pb);
|
|
266 url_fseek(pb, 8, SEEK_SET);
|
|
267 put_be64(pb, size);
|
|
268 put_flush_packet(pb);
|
|
269 }
|
|
270
|
|
271 for(i=0;i<s->nb_streams;i++)
|
|
272 av_freep(&s->streams[i]->priv_data);
|
|
273 return 0;
|
|
274 }
|
|
275
|
|
276 /* ffm demux */
|
|
277
|
|
278 static int ffm_is_avail_data(AVFormatContext *s, int size)
|
|
279 {
|
|
280 FFMContext *ffm = s->priv_data;
|
|
281 offset_t pos, avail_size;
|
|
282 int len;
|
|
283
|
|
284 len = ffm->packet_end - ffm->packet_ptr;
|
|
285 if (!ffm_nopts) {
|
|
286 /* XXX: I don't understand this test, so I disabled it for testing */
|
|
287 if (size <= len)
|
|
288 return 1;
|
|
289 }
|
|
290 pos = url_ftell(&s->pb);
|
|
291 if (pos == ffm->write_index) {
|
|
292 /* exactly at the end of stream */
|
|
293 return 0;
|
|
294 } else if (pos < ffm->write_index) {
|
|
295 avail_size = ffm->write_index - pos;
|
|
296 } else {
|
|
297 avail_size = (ffm->file_size - pos) + (ffm->write_index - FFM_PACKET_SIZE);
|
|
298 }
|
|
299 avail_size = (avail_size / ffm->packet_size) * (ffm->packet_size - FFM_HEADER_SIZE) + len;
|
|
300 if (size <= avail_size)
|
|
301 return 1;
|
|
302 else
|
|
303 return 0;
|
|
304 }
|
|
305
|
|
306 /* first is true if we read the frame header */
|
|
307 static int ffm_read_data(AVFormatContext *s,
|
|
308 UINT8 *buf, int size, int first)
|
|
309 {
|
|
310 FFMContext *ffm = s->priv_data;
|
|
311 ByteIOContext *pb = &s->pb;
|
|
312 int len, fill_size, size1, frame_offset;
|
|
313
|
|
314 size1 = size;
|
|
315 while (size > 0) {
|
|
316 redo:
|
|
317 len = ffm->packet_end - ffm->packet_ptr;
|
|
318 if (len > size)
|
|
319 len = size;
|
|
320 if (len == 0) {
|
|
321 if (url_ftell(pb) == ffm->file_size)
|
|
322 url_fseek(pb, ffm->packet_size, SEEK_SET);
|
|
323 retry_read:
|
|
324 get_be16(pb); /* PACKET_ID */
|
|
325 fill_size = get_be16(pb);
|
|
326 ffm->pts = get_be64(pb);
|
|
327 frame_offset = get_be16(pb);
|
|
328 get_buffer(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE);
|
|
329 ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);
|
|
330 /* if first packet or resynchronization packet, we must
|
|
331 handle it specifically */
|
|
332 if (ffm->first_packet || (frame_offset & 0x8000)) {
|
|
333 if (!frame_offset) {
|
|
334 /* This packet has no frame headers in it */
|
|
335 if (url_ftell(pb) >= ffm->packet_size * 3) {
|
|
336 url_fseek(pb, -ffm->packet_size * 2, SEEK_CUR);
|
|
337 goto retry_read;
|
|
338 }
|
|
339 /* This is bad, we cannot find a valid frame header */
|
|
340 return 0;
|
|
341 }
|
|
342 ffm->first_packet = 0;
|
|
343 if ((frame_offset & 0x7ffff) < FFM_HEADER_SIZE)
|
|
344 av_abort();
|
|
345 ffm->packet_ptr = ffm->packet + (frame_offset & 0x7fff) - FFM_HEADER_SIZE;
|
|
346 if (!first)
|
|
347 break;
|
|
348 } else {
|
|
349 ffm->packet_ptr = ffm->packet;
|
|
350 }
|
|
351 goto redo;
|
|
352 }
|
|
353 memcpy(buf, ffm->packet_ptr, len);
|
|
354 buf += len;
|
|
355 ffm->packet_ptr += len;
|
|
356 size -= len;
|
|
357 first = 0;
|
|
358 }
|
|
359 return size1 - size;
|
|
360 }
|
|
361
|
|
362
|
|
363 static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
|
|
364 {
|
|
365 FFMContext *ffm = s->priv_data;
|
|
366 AVStream *st;
|
|
367 FFMStream *fst;
|
|
368 ByteIOContext *pb = &s->pb;
|
|
369 AVCodecContext *codec;
|
|
370 int i;
|
|
371 UINT32 tag;
|
|
372
|
|
373 /* header */
|
|
374 tag = get_le32(pb);
|
|
375 if (tag != MKTAG('F', 'F', 'M', '1'))
|
|
376 goto fail;
|
|
377 ffm->packet_size = get_be32(pb);
|
|
378 if (ffm->packet_size != FFM_PACKET_SIZE)
|
|
379 goto fail;
|
|
380 ffm->write_index = get_be64(pb);
|
|
381 /* get also filesize */
|
|
382 if (!url_is_streamed(pb)) {
|
|
383 ffm->file_size = url_filesize(url_fileno(pb));
|
|
384 } else {
|
|
385 ffm->file_size = (UINT64_C(1) << 63) - 1;
|
|
386 }
|
|
387
|
|
388 s->nb_streams = get_be32(pb);
|
|
389 get_be32(pb); /* total bitrate */
|
|
390 /* read each stream */
|
|
391 for(i=0;i<s->nb_streams;i++) {
|
|
392 char rc_eq_buf[128];
|
|
393
|
|
394 st = av_mallocz(sizeof(AVStream));
|
|
395 if (!st)
|
|
396 goto fail;
|
5
|
397 avcodec_get_context_defaults(&st->codec);
|
0
|
398 s->streams[i] = st;
|
|
399 fst = av_mallocz(sizeof(FFMStream));
|
|
400 if (!fst)
|
|
401 goto fail;
|
|
402 st->priv_data = fst;
|
|
403
|
|
404 codec = &st->codec;
|
|
405 /* generic info */
|
|
406 st->codec.codec_id = get_be32(pb);
|
|
407 st->codec.codec_type = get_byte(pb); /* codec_type */
|
|
408 codec->bit_rate = get_be32(pb);
|
5
|
409 st->quality = get_be32(pb);
|
0
|
410 codec->flags = get_be32(pb);
|
|
411 /* specific info */
|
|
412 switch(codec->codec_type) {
|
|
413 case CODEC_TYPE_VIDEO:
|
|
414 codec->frame_rate = ((INT64)get_be32(pb) * FRAME_RATE_BASE) / 1000;
|
|
415 codec->width = get_be16(pb);
|
|
416 codec->height = get_be16(pb);
|
|
417 codec->gop_size = get_be16(pb);
|
|
418 codec->qmin = get_byte(pb);
|
|
419 codec->qmax = get_byte(pb);
|
|
420 codec->max_qdiff = get_byte(pb);
|
|
421 codec->qcompress = get_be16(pb) / 10000.0;
|
|
422 codec->qblur = get_be16(pb) / 10000.0;
|
|
423 codec->bit_rate_tolerance = get_be32(pb);
|
34
|
424 codec->rc_eq = av_strdup(get_strz(pb, rc_eq_buf, sizeof(rc_eq_buf)));
|
0
|
425 codec->rc_max_rate = get_be32(pb);
|
|
426 codec->rc_min_rate = get_be32(pb);
|
|
427 codec->rc_buffer_size = get_be32(pb);
|
|
428 codec->i_quant_factor = get_be64_double(pb);
|
|
429 codec->b_quant_factor = get_be64_double(pb);
|
|
430 codec->i_quant_offset = get_be64_double(pb);
|
|
431 codec->b_quant_offset = get_be64_double(pb);
|
|
432 codec->dct_algo = get_be32(pb);
|
|
433 break;
|
|
434 case CODEC_TYPE_AUDIO:
|
|
435 codec->sample_rate = get_be32(pb);
|
|
436 codec->channels = get_le16(pb);
|
|
437 codec->frame_size = get_le16(pb);
|
|
438 break;
|
|
439 default:
|
|
440 goto fail;
|
|
441 }
|
|
442
|
|
443 }
|
|
444
|
|
445 /* get until end of block reached */
|
|
446 while ((url_ftell(pb) % ffm->packet_size) != 0)
|
|
447 get_byte(pb);
|
|
448
|
|
449 /* init packet demux */
|
|
450 ffm->packet_ptr = ffm->packet;
|
|
451 ffm->packet_end = ffm->packet;
|
|
452 ffm->frame_offset = 0;
|
|
453 ffm->pts = 0;
|
|
454 ffm->read_state = READ_HEADER;
|
|
455 ffm->first_packet = 1;
|
|
456 return 0;
|
|
457 fail:
|
|
458 for(i=0;i<s->nb_streams;i++) {
|
|
459 st = s->streams[i];
|
|
460 if (st) {
|
|
461 av_freep(&st->priv_data);
|
|
462 av_free(st);
|
|
463 }
|
|
464 }
|
|
465 return -1;
|
|
466 }
|
|
467
|
|
468 /* return < 0 if eof */
|
|
469 static int ffm_read_packet(AVFormatContext *s, AVPacket *pkt)
|
|
470 {
|
|
471 int size;
|
|
472 FFMContext *ffm = s->priv_data;
|
|
473 int duration;
|
|
474
|
|
475 switch(ffm->read_state) {
|
|
476 case READ_HEADER:
|
|
477 if (!ffm_is_avail_data(s, FRAME_HEADER_SIZE)) {
|
|
478 return -EAGAIN;
|
|
479 }
|
|
480 #if 0
|
|
481 printf("pos=%08Lx spos=%Lx, write_index=%Lx size=%Lx\n",
|
|
482 url_ftell(&s->pb), s->pb.pos, ffm->write_index, ffm->file_size);
|
|
483 #endif
|
|
484 if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=
|
|
485 FRAME_HEADER_SIZE)
|
|
486 return -EAGAIN;
|
|
487 #if 0
|
|
488 {
|
|
489 int i;
|
|
490 for(i=0;i<FRAME_HEADER_SIZE;i++)
|
|
491 printf("%02x ", ffm->header[i]);
|
|
492 printf("\n");
|
|
493 }
|
|
494 #endif
|
|
495 ffm->read_state = READ_DATA;
|
|
496 /* fall thru */
|
|
497 case READ_DATA:
|
|
498 size = (ffm->header[2] << 16) | (ffm->header[3] << 8) | ffm->header[4];
|
|
499 if (!ffm_is_avail_data(s, size)) {
|
|
500 return -EAGAIN;
|
|
501 }
|
|
502
|
|
503 duration = (ffm->header[5] << 16) | (ffm->header[6] << 8) | ffm->header[7];
|
|
504
|
|
505 av_new_packet(pkt, size);
|
|
506 pkt->stream_index = ffm->header[0];
|
|
507 if (ffm->header[1] & FLAG_KEY_FRAME)
|
|
508 pkt->flags |= PKT_FLAG_KEY;
|
|
509
|
|
510 ffm->read_state = READ_HEADER;
|
|
511 if (ffm_read_data(s, pkt->data, size, 0) != size) {
|
|
512 /* bad case: desynchronized packet. we cancel all the packet loading */
|
|
513 av_free_packet(pkt);
|
|
514 return -EAGAIN;
|
|
515 }
|
|
516 pkt->pts = ffm->pts;
|
|
517 pkt->duration = duration;
|
|
518 break;
|
|
519 }
|
|
520 return 0;
|
|
521 }
|
|
522
|
|
523 //#define DEBUG_SEEK
|
|
524
|
|
525 /* pos is between 0 and file_size - FFM_PACKET_SIZE. It is translated
|
|
526 by the write position inside this function */
|
|
527 static void ffm_seek1(AVFormatContext *s, offset_t pos1)
|
|
528 {
|
|
529 FFMContext *ffm = s->priv_data;
|
|
530 ByteIOContext *pb = &s->pb;
|
|
531 offset_t pos;
|
|
532
|
|
533 pos = pos1 + ffm->write_index;
|
|
534 if (pos >= ffm->file_size)
|
|
535 pos -= (ffm->file_size - FFM_PACKET_SIZE);
|
|
536 #ifdef DEBUG_SEEK
|
|
537 printf("seek to %Lx -> %Lx\n", pos1, pos);
|
|
538 #endif
|
|
539 url_fseek(pb, pos, SEEK_SET);
|
|
540 }
|
|
541
|
|
542 static INT64 get_pts(AVFormatContext *s, offset_t pos)
|
|
543 {
|
|
544 ByteIOContext *pb = &s->pb;
|
|
545 INT64 pts;
|
|
546
|
|
547 ffm_seek1(s, pos);
|
|
548 url_fskip(pb, 4);
|
|
549 pts = get_be64(pb);
|
|
550 #ifdef DEBUG_SEEK
|
|
551 printf("pts=%0.6f\n", pts / 1000000.0);
|
|
552 #endif
|
|
553 return pts;
|
|
554 }
|
|
555
|
|
556 /* seek to a given time in the file. The file read pointer is
|
|
557 positionned at or before pts. XXX: the following code is quite
|
|
558 approximative */
|
|
559 static int ffm_seek(AVFormatContext *s, INT64 wanted_pts)
|
|
560 {
|
|
561 FFMContext *ffm = s->priv_data;
|
|
562 offset_t pos_min, pos_max, pos;
|
|
563 INT64 pts_min, pts_max, pts;
|
|
564 double pos1;
|
|
565
|
|
566 #ifdef DEBUG_SEEK
|
|
567 printf("wanted_pts=%0.6f\n", wanted_pts / 1000000.0);
|
|
568 #endif
|
|
569 /* find the position using linear interpolation (better than
|
|
570 dichotomy in typical cases) */
|
|
571 pos_min = 0;
|
|
572 pos_max = ffm->file_size - 2 * FFM_PACKET_SIZE;
|
|
573 while (pos_min <= pos_max) {
|
|
574 pts_min = get_pts(s, pos_min);
|
|
575 pts_max = get_pts(s, pos_max);
|
|
576 /* linear interpolation */
|
|
577 pos1 = (double)(pos_max - pos_min) * (double)(wanted_pts - pts_min) /
|
|
578 (double)(pts_max - pts_min);
|
|
579 pos = (((INT64)pos1) / FFM_PACKET_SIZE) * FFM_PACKET_SIZE;
|
|
580 if (pos <= pos_min)
|
|
581 pos = pos_min;
|
|
582 else if (pos >= pos_max)
|
|
583 pos = pos_max;
|
|
584 pts = get_pts(s, pos);
|
|
585 /* check if we are lucky */
|
|
586 if (pts == wanted_pts) {
|
|
587 goto found;
|
|
588 } else if (pts > wanted_pts) {
|
|
589 pos_max = pos - FFM_PACKET_SIZE;
|
|
590 } else {
|
|
591 pos_min = pos + FFM_PACKET_SIZE;
|
|
592 }
|
|
593 }
|
|
594 pos = pos_min;
|
|
595 if (pos > 0)
|
|
596 pos -= FFM_PACKET_SIZE;
|
|
597 found:
|
|
598 ffm_seek1(s, pos);
|
|
599 return 0;
|
|
600 }
|
|
601
|
|
602 offset_t ffm_read_write_index(int fd)
|
|
603 {
|
|
604 UINT8 buf[8];
|
|
605 offset_t pos;
|
|
606 int i;
|
|
607
|
|
608 lseek(fd, 8, SEEK_SET);
|
|
609 read(fd, buf, 8);
|
|
610 pos = 0;
|
|
611 for(i=0;i<8;i++)
|
|
612 pos |= buf[i] << (56 - i * 8);
|
|
613 return pos;
|
|
614 }
|
|
615
|
|
616 void ffm_write_write_index(int fd, offset_t pos)
|
|
617 {
|
|
618 UINT8 buf[8];
|
|
619 int i;
|
|
620
|
|
621 for(i=0;i<8;i++)
|
|
622 buf[i] = (pos >> (56 - i * 8)) & 0xff;
|
|
623 lseek(fd, 8, SEEK_SET);
|
|
624 write(fd, buf, 8);
|
|
625 }
|
|
626
|
|
627 void ffm_set_write_index(AVFormatContext *s, offset_t pos, offset_t file_size)
|
|
628 {
|
|
629 FFMContext *ffm = s->priv_data;
|
|
630 ffm->write_index = pos;
|
|
631 ffm->file_size = file_size;
|
|
632 }
|
|
633
|
|
634 static int ffm_read_close(AVFormatContext *s)
|
|
635 {
|
|
636 AVStream *st;
|
|
637 int i;
|
|
638
|
|
639 for(i=0;i<s->nb_streams;i++) {
|
|
640 st = s->streams[i];
|
|
641 av_freep(&st->priv_data);
|
|
642 }
|
|
643 return 0;
|
|
644 }
|
|
645
|
|
646 static int ffm_probe(AVProbeData *p)
|
|
647 {
|
|
648 if (p->buf_size >= 4 &&
|
|
649 p->buf[0] == 'F' && p->buf[1] == 'F' && p->buf[2] == 'M' &&
|
|
650 p->buf[3] == '1')
|
|
651 return AVPROBE_SCORE_MAX + 1;
|
|
652 return 0;
|
|
653 }
|
|
654
|
|
655 static AVInputFormat ffm_iformat = {
|
|
656 "ffm",
|
|
657 "ffm format",
|
|
658 sizeof(FFMContext),
|
|
659 ffm_probe,
|
|
660 ffm_read_header,
|
|
661 ffm_read_packet,
|
|
662 ffm_read_close,
|
|
663 ffm_seek,
|
|
664 };
|
|
665
|
|
666 static AVOutputFormat ffm_oformat = {
|
|
667 "ffm",
|
|
668 "ffm format",
|
|
669 "",
|
|
670 "ffm",
|
|
671 sizeof(FFMContext),
|
|
672 /* not really used */
|
|
673 CODEC_ID_MP2,
|
|
674 CODEC_ID_MPEG1VIDEO,
|
|
675 ffm_write_header,
|
|
676 ffm_write_packet,
|
|
677 ffm_write_trailer,
|
|
678 };
|
|
679
|
|
680 int ffm_init(void)
|
|
681 {
|
|
682 av_register_input_format(&ffm_iformat);
|
|
683 av_register_output_format(&ffm_oformat);
|
|
684 return 0;
|
|
685 }
|