av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
[libav.git] / libavformat / mpeg.c
1 /*
2 * MPEG1/2 mux/demux
3 * Copyright (c) 2000, 2001, 2002 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
21 #define MAX_PAYLOAD_SIZE 4096
22 //#define DEBUG_SEEK
23
24 #undef NDEBUG
25 #include <assert.h>
26
27 typedef struct {
28 uint8_t buffer[MAX_PAYLOAD_SIZE];
29 int buffer_ptr;
30 int nb_frames; /* number of starting frame encountered (AC3) */
31 int frame_start_offset; /* starting offset of the frame + 1 (0 if none) */
32 uint8_t id;
33 int max_buffer_size; /* in bytes */
34 int packet_number;
35 int64_t start_pts;
36 int64_t start_dts;
37 uint8_t lpcm_header[3];
38 int lpcm_align;
39 } StreamInfo;
40
41 typedef struct {
42 int packet_size; /* required packet size */
43 int packet_number;
44 int pack_header_freq; /* frequency (in packets^-1) at which we send pack headers */
45 int system_header_freq;
46 int system_header_size;
47 int mux_rate; /* bitrate in units of 50 bytes/s */
48 /* stream info */
49 int audio_bound;
50 int video_bound;
51 int is_mpeg2;
52 int is_vcd;
53 int is_svcd;
54 int scr_stream_index; /* stream from which the system clock is
55 computed (VBR case) */
56 int64_t last_scr; /* current system clock */
57
58 double vcd_padding_bitrate;
59 int64_t vcd_padding_bytes_written;
60
61 } MpegMuxContext;
62
63 #define PACK_START_CODE ((unsigned int)0x000001ba)
64 #define SYSTEM_HEADER_START_CODE ((unsigned int)0x000001bb)
65 #define SEQUENCE_END_CODE ((unsigned int)0x000001b7)
66 #define PACKET_START_CODE_MASK ((unsigned int)0xffffff00)
67 #define PACKET_START_CODE_PREFIX ((unsigned int)0x00000100)
68 #define ISO_11172_END_CODE ((unsigned int)0x000001b9)
69
70 /* mpeg2 */
71 #define PROGRAM_STREAM_MAP 0x1bc
72 #define PRIVATE_STREAM_1 0x1bd
73 #define PADDING_STREAM 0x1be
74 #define PRIVATE_STREAM_2 0x1bf
75
76
77 #define AUDIO_ID 0xc0
78 #define VIDEO_ID 0xe0
79 #define AC3_ID 0x80
80 #define LPCM_ID 0xa0
81
82 static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
83
84 #ifdef CONFIG_ENCODERS
85 extern AVOutputFormat mpeg1system_mux;
86 extern AVOutputFormat mpeg1vcd_mux;
87 extern AVOutputFormat mpeg2vob_mux;
88 extern AVOutputFormat mpeg2svcd_mux;
89
90 static int put_pack_header(AVFormatContext *ctx,
91 uint8_t *buf, int64_t timestamp)
92 {
93 MpegMuxContext *s = ctx->priv_data;
94 PutBitContext pb;
95
96 init_put_bits(&pb, buf, 128);
97
98 put_bits(&pb, 32, PACK_START_CODE);
99 if (s->is_mpeg2) {
100 put_bits(&pb, 2, 0x1);
101 } else {
102 put_bits(&pb, 4, 0x2);
103 }
104 put_bits(&pb, 3, (uint32_t)((timestamp >> 30) & 0x07));
105 put_bits(&pb, 1, 1);
106 put_bits(&pb, 15, (uint32_t)((timestamp >> 15) & 0x7fff));
107 put_bits(&pb, 1, 1);
108 put_bits(&pb, 15, (uint32_t)((timestamp) & 0x7fff));
109 put_bits(&pb, 1, 1);
110 if (s->is_mpeg2) {
111 /* clock extension */
112 put_bits(&pb, 9, 0);
113 }
114 put_bits(&pb, 1, 1);
115 put_bits(&pb, 22, s->mux_rate);
116 put_bits(&pb, 1, 1);
117 if (s->is_mpeg2) {
118 put_bits(&pb, 1, 1);
119 put_bits(&pb, 5, 0x1f); /* reserved */
120 put_bits(&pb, 3, 0); /* stuffing length */
121 }
122 flush_put_bits(&pb);
123 return pbBufPtr(&pb) - pb.buf;
124 }
125
126 static int put_system_header(AVFormatContext *ctx, uint8_t *buf,int only_for_stream_id)
127 {
128 MpegMuxContext *s = ctx->priv_data;
129 int size, rate_bound, i, private_stream_coded, id;
130 PutBitContext pb;
131
132 init_put_bits(&pb, buf, 128);
133
134 put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
135 put_bits(&pb, 16, 0);
136 put_bits(&pb, 1, 1);
137
138 rate_bound = s->mux_rate; /* maximum bit rate of the multiplexed stream */
139 put_bits(&pb, 22, rate_bound);
140 put_bits(&pb, 1, 1); /* marker */
141 if (s->is_vcd && only_for_stream_id==VIDEO_ID) {
142 /* This header applies only to the video stream (see VCD standard p. IV-7)*/
143 put_bits(&pb, 6, 0);
144 } else
145 put_bits(&pb, 6, s->audio_bound);
146
147 if (s->is_vcd)
148 put_bits(&pb, 1, 0); /* see VCD standard, p. IV-7*/
149 else
150 put_bits(&pb, 1, 1); /* variable bitrate*/
151 put_bits(&pb, 1, 1); /* non constrainted bit stream */
152
153 if (s->is_vcd) {
154 /* see VCD standard p IV-7 */
155 put_bits(&pb, 1, 1); /* audio locked */
156 put_bits(&pb, 1, 1); /* video locked */
157 } else {
158 put_bits(&pb, 1, 0); /* audio locked */
159 put_bits(&pb, 1, 0); /* video locked */
160 }
161
162 put_bits(&pb, 1, 1); /* marker */
163
164 if (s->is_vcd && only_for_stream_id==AUDIO_ID) {
165 /* This header applies only to the audio stream (see VCD standard p. IV-7)*/
166 put_bits(&pb, 5, 0);
167 } else
168 put_bits(&pb, 5, s->video_bound);
169
170 put_bits(&pb, 8, 0xff); /* reserved byte */
171
172 /* audio stream info */
173 private_stream_coded = 0;
174 for(i=0;i<ctx->nb_streams;i++) {
175 StreamInfo *stream = ctx->streams[i]->priv_data;
176
177 /* For VCDs, only include the stream info for the stream
178 that the pack which contains this system belongs to.
179 (see VCD standard p. IV-7) */
180 if ( !s->is_vcd || stream->id==only_for_stream_id
181 || only_for_stream_id==0) {
182
183 id = stream->id;
184 if (id < 0xc0) {
185 /* special case for private streams (AC3 use that) */
186 if (private_stream_coded)
187 continue;
188 private_stream_coded = 1;
189 id = 0xbd;
190 }
191 put_bits(&pb, 8, id); /* stream ID */
192 put_bits(&pb, 2, 3);
193 if (id < 0xe0) {
194 /* audio */
195 put_bits(&pb, 1, 0);
196 put_bits(&pb, 13, stream->max_buffer_size / 128);
197 } else {
198 /* video */
199 put_bits(&pb, 1, 1);
200 put_bits(&pb, 13, stream->max_buffer_size / 1024);
201 }
202 }
203 }
204 flush_put_bits(&pb);
205 size = pbBufPtr(&pb) - pb.buf;
206 /* patch packet size */
207 buf[4] = (size - 6) >> 8;
208 buf[5] = (size - 6) & 0xff;
209
210 return size;
211 }
212
213 static int get_system_header_size(AVFormatContext *ctx)
214 {
215 int buf_index, i, private_stream_coded;
216 StreamInfo *stream;
217
218 buf_index = 12;
219 private_stream_coded = 0;
220 for(i=0;i<ctx->nb_streams;i++) {
221 stream = ctx->streams[i]->priv_data;
222 if (stream->id < 0xc0) {
223 if (private_stream_coded)
224 continue;
225 private_stream_coded = 1;
226 }
227 buf_index += 3;
228 }
229 return buf_index;
230 }
231
232 static int mpeg_mux_init(AVFormatContext *ctx)
233 {
234 MpegMuxContext *s = ctx->priv_data;
235 int bitrate, i, mpa_id, mpv_id, ac3_id, lpcm_id, j;
236 AVStream *st;
237 StreamInfo *stream;
238 int audio_bitrate;
239 int video_bitrate;
240
241 s->packet_number = 0;
242 s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
243 s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
244 s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux);
245
246 if (s->is_vcd || s->is_svcd)
247 s->packet_size = 2324; /* VCD/SVCD packet size */
248 else
249 s->packet_size = 2048;
250
251 s->vcd_padding_bytes_written = 0;
252 s->vcd_padding_bitrate=0;
253
254 s->audio_bound = 0;
255 s->video_bound = 0;
256 mpa_id = AUDIO_ID;
257 ac3_id = AC3_ID;
258 mpv_id = VIDEO_ID;
259 lpcm_id = LPCM_ID;
260 s->scr_stream_index = -1;
261 for(i=0;i<ctx->nb_streams;i++) {
262 st = ctx->streams[i];
263 stream = av_mallocz(sizeof(StreamInfo));
264 if (!stream)
265 goto fail;
266 st->priv_data = stream;
267
268 switch(st->codec.codec_type) {
269 case CODEC_TYPE_AUDIO:
270 if (st->codec.codec_id == CODEC_ID_AC3) {
271 stream->id = ac3_id++;
272 } else if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
273 stream->id = lpcm_id++;
274 for(j = 0; j < 4; j++) {
275 if (lpcm_freq_tab[j] == st->codec.sample_rate)
276 break;
277 }
278 if (j == 4)
279 goto fail;
280 if (st->codec.channels > 8)
281 return -1;
282 stream->lpcm_header[0] = 0x0c;
283 stream->lpcm_header[1] = (st->codec.channels - 1) | (j << 4);
284 stream->lpcm_header[2] = 0x80;
285 stream->lpcm_align = st->codec.channels * 2;
286 } else {
287 stream->id = mpa_id++;
288 }
289 stream->max_buffer_size = 4 * 1024;
290 s->audio_bound++;
291 break;
292 case CODEC_TYPE_VIDEO:
293 /* by default, video is used for the SCR computation */
294 if (s->scr_stream_index == -1)
295 s->scr_stream_index = i;
296 stream->id = mpv_id++;
297 stream->max_buffer_size = 46 * 1024;
298 s->video_bound++;
299 break;
300 default:
301 av_abort();
302 }
303 }
304 /* if no SCR, use first stream (audio) */
305 if (s->scr_stream_index == -1)
306 s->scr_stream_index = 0;
307
308 bitrate = 0;
309 audio_bitrate = 0;
310 video_bitrate = 0;
311 for(i=0;i<ctx->nb_streams;i++) {
312 st = ctx->streams[i];
313 stream = (StreamInfo*) st->priv_data;
314
315 bitrate += st->codec.bit_rate;
316
317 if (stream->id==AUDIO_ID)
318 audio_bitrate += st->codec.bit_rate;
319 else if (stream->id==VIDEO_ID)
320 video_bitrate += st->codec.bit_rate;
321 }
322
323 if (s->is_vcd) {
324 double overhead_rate;
325
326 /* The VCD standard mandates that the mux_rate field is 3528
327 (see standard p. IV-6).
328 The value is actually "wrong", i.e. if you calculate
329 it using the normal formula and the 75 sectors per second transfer
330 rate you get a different value because the real pack size is 2324,
331 not 2352. But the standard explicitly specifies that the mux_rate
332 field in the header must have this value.*/
333 s->mux_rate=2352 * 75 / 50; /* = 3528*/
334
335 /* The VCD standard states that the muxed stream must be
336 exactly 75 packs / second (the data rate of a single speed cdrom).
337 Since the video bitrate (probably 1150000 bits/sec) will be below
338 the theoretical maximum we have to add some padding packets
339 to make up for the lower data rate.
340 (cf. VCD standard p. IV-6 )*/
341
342 /* Add the header overhead to the data rate.
343 2279 data bytes per audio pack, 2294 data bytes per video pack*/
344 overhead_rate = ((audio_bitrate / 8.0) / 2279) * (2324 - 2279);
345 overhead_rate += ((video_bitrate / 8.0) / 2294) * (2324 - 2294);
346 overhead_rate *= 8;
347
348 /* Add padding so that the full bitrate is 2324*75 bytes/sec */
349 s->vcd_padding_bitrate = 2324 * 75 * 8 - (bitrate + overhead_rate);
350
351 } else {
352 /* we increase slightly the bitrate to take into account the
353 headers. XXX: compute it exactly */
354 bitrate += 2000;
355 s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
356 }
357
358 if (s->is_vcd || s->is_mpeg2)
359 /* every packet */
360 s->pack_header_freq = 1;
361 else
362 /* every 2 seconds */
363 s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
364
365 /* the above seems to make pack_header_freq zero sometimes */
366 if (s->pack_header_freq == 0)
367 s->pack_header_freq = 1;
368
369 if (s->is_mpeg2)
370 /* every 200 packets. Need to look at the spec. */
371 s->system_header_freq = s->pack_header_freq * 40;
372 else if (s->is_vcd)
373 /* the standard mandates that there are only two system headers
374 in the whole file: one in the first packet of each stream.
375 (see standard p. IV-7 and IV-8) */
376 s->system_header_freq = 0x7fffffff;
377 else
378 s->system_header_freq = s->pack_header_freq * 5;
379
380 for(i=0;i<ctx->nb_streams;i++) {
381 stream = ctx->streams[i]->priv_data;
382 stream->buffer_ptr = 0;
383 stream->packet_number = 0;
384 stream->start_pts = AV_NOPTS_VALUE;
385 stream->start_dts = AV_NOPTS_VALUE;
386 }
387 s->system_header_size = get_system_header_size(ctx);
388 s->last_scr = 0;
389 return 0;
390 fail:
391 for(i=0;i<ctx->nb_streams;i++) {
392 av_free(ctx->streams[i]->priv_data);
393 }
394 return -ENOMEM;
395 }
396
397 static inline void put_timestamp(ByteIOContext *pb, int id, int64_t timestamp)
398 {
399 put_byte(pb,
400 (id << 4) |
401 (((timestamp >> 30) & 0x07) << 1) |
402 1);
403 put_be16(pb, (uint16_t)((((timestamp >> 15) & 0x7fff) << 1) | 1));
404 put_be16(pb, (uint16_t)((((timestamp) & 0x7fff) << 1) | 1));
405 }
406
407
408 /* return the number of padding bytes that should be inserted into
409 the multiplexed stream.*/
410 static int get_vcd_padding_size(AVFormatContext *ctx, int64_t pts)
411 {
412 MpegMuxContext *s = ctx->priv_data;
413 int pad_bytes = 0;
414
415 if (s->vcd_padding_bitrate > 0 && pts!=AV_NOPTS_VALUE)
416 {
417 int64_t full_pad_bytes;
418
419 full_pad_bytes = (int64_t)((s->vcd_padding_bitrate * (pts / 90000.0)) / 8.0);
420 pad_bytes = (int) (full_pad_bytes - s->vcd_padding_bytes_written);
421
422 if (pad_bytes<0)
423 /* might happen if we have already padded to a later timestamp. This
424 can occur if another stream has already advanced further.*/
425 pad_bytes=0;
426 }
427
428 return pad_bytes;
429 }
430
431
432 /* return the exact available payload size for the next packet for
433 stream 'stream_index'. 'pts' and 'dts' are only used to know if
434 timestamps are needed in the packet header. */
435 static int get_packet_payload_size(AVFormatContext *ctx, int stream_index,
436 int64_t pts, int64_t dts)
437 {
438 MpegMuxContext *s = ctx->priv_data;
439 int buf_index;
440 StreamInfo *stream;
441
442 stream = ctx->streams[stream_index]->priv_data;
443
444 buf_index = 0;
445 if (((s->packet_number % s->pack_header_freq) == 0)) {
446 /* pack header size */
447 if (s->is_mpeg2)
448 buf_index += 14;
449 else
450 buf_index += 12;
451
452 if (s->is_vcd) {
453 /* there is exactly one system header for each stream in a VCD MPEG,
454 One in the very first video packet and one in the very first
455 audio packet (see VCD standard p. IV-7 and IV-8).*/
456
457 if (stream->packet_number==0)
458 /* The system headers refer only to the stream they occur in,
459 so they have a constant size.*/
460 buf_index += 15;
461
462 } else {
463 if ((s->packet_number % s->system_header_freq) == 0)
464 buf_index += s->system_header_size;
465 }
466 }
467
468 if (s->is_vcd && stream->packet_number==0)
469 /* the first pack of each stream contains only the pack header,
470 the system header and some padding (see VCD standard p. IV-6)
471 Add the padding size, so that the actual payload becomes 0.*/
472 buf_index += s->packet_size - buf_index;
473 else {
474 /* packet header size */
475 buf_index += 6;
476 if (s->is_mpeg2)
477 buf_index += 3;
478 if (pts != AV_NOPTS_VALUE) {
479 if (dts != pts)
480 buf_index += 5 + 5;
481 else
482 buf_index += 5;
483
484 } else {
485 if (!s->is_mpeg2)
486 buf_index++;
487 }
488
489 if (stream->id < 0xc0) {
490 /* AC3/LPCM private data header */
491 buf_index += 4;
492 if (stream->id >= 0xa0) {
493 int n;
494 buf_index += 3;
495 /* NOTE: we round the payload size to an integer number of
496 LPCM samples */
497 n = (s->packet_size - buf_index) % stream->lpcm_align;
498 if (n)
499 buf_index += (stream->lpcm_align - n);
500 }
501 }
502
503 if (s->is_vcd && stream->id == AUDIO_ID)
504 /* The VCD standard demands that 20 zero bytes follow
505 each audio packet (see standard p. IV-8).*/
506 buf_index+=20;
507 }
508 return s->packet_size - buf_index;
509 }
510
511 /* Write an MPEG padding packet header. */
512 static int put_padding_header(AVFormatContext *ctx,uint8_t* buf, int full_padding_size)
513 {
514 MpegMuxContext *s = ctx->priv_data;
515 int size = full_padding_size - 6; /* subtract header length */
516
517 buf[0] = (uint8_t)(PADDING_STREAM >> 24);
518 buf[1] = (uint8_t)(PADDING_STREAM >> 16);
519 buf[2] = (uint8_t)(PADDING_STREAM >> 8);
520 buf[3] = (uint8_t)(PADDING_STREAM);
521 buf[4] = (uint8_t)(size >> 8);
522 buf[5] = (uint8_t)(size & 0xff);
523
524 if (!s->is_mpeg2) {
525 buf[6] = 0x0f;
526 return 7;
527 } else
528 return 6;
529 }
530
531 static void put_padding_packet(AVFormatContext *ctx, ByteIOContext *pb,int packet_bytes)
532 {
533 uint8_t buffer[7];
534 int size, i;
535
536 size = put_padding_header(ctx,buffer, packet_bytes);
537 put_buffer(pb, buffer, size);
538 packet_bytes -= size;
539
540 for(i=0;i<packet_bytes;i++)
541 put_byte(pb, 0xff);
542 }
543
544
545 /* flush the packet on stream stream_index */
546 static void flush_packet(AVFormatContext *ctx, int stream_index,
547 int64_t pts, int64_t dts, int64_t scr)
548 {
549 MpegMuxContext *s = ctx->priv_data;
550 StreamInfo *stream = ctx->streams[stream_index]->priv_data;
551 uint8_t *buf_ptr;
552 int size, payload_size, startcode, id, stuffing_size, i, header_len;
553 int packet_size;
554 uint8_t buffer[128];
555 int zero_trail_bytes = 0;
556 int pad_packet_bytes = 0;
557
558 id = stream->id;
559
560 #if 0
561 printf("packet ID=%2x PTS=%0.3f\n",
562 id, pts / 90000.0);
563 #endif
564
565 buf_ptr = buffer;
566
567 if (((s->packet_number % s->pack_header_freq) == 0)) {
568 /* output pack and systems header if needed */
569 size = put_pack_header(ctx, buf_ptr, scr);
570 buf_ptr += size;
571
572 if (s->is_vcd) {
573 /* there is exactly one system header for each stream in a VCD MPEG,
574 One in the very first video packet and one in the very first
575 audio packet (see VCD standard p. IV-7 and IV-8).*/
576
577 if (stream->packet_number==0) {
578 size = put_system_header(ctx, buf_ptr, id);
579 buf_ptr += size;
580 }
581 } else {
582 if ((s->packet_number % s->system_header_freq) == 0) {
583 size = put_system_header(ctx, buf_ptr, 0);
584 buf_ptr += size;
585 }
586 }
587 }
588 size = buf_ptr - buffer;
589 put_buffer(&ctx->pb, buffer, size);
590
591 packet_size = s->packet_size - size;
592
593 if (s->is_vcd && id == AUDIO_ID)
594 /* The VCD standard demands that 20 zero bytes follow
595 each audio pack (see standard p. IV-8).*/
596 zero_trail_bytes += 20;
597
598 if (s->is_vcd && stream->packet_number==0) {
599 /* the first pack of each stream contains only the pack header,
600 the system header and lots of padding (see VCD standard p. IV-6).
601 In the case of an audio pack, 20 zero bytes are also added at
602 the end.*/
603 pad_packet_bytes = packet_size - zero_trail_bytes;
604 }
605
606 packet_size -= pad_packet_bytes + zero_trail_bytes;
607
608 if (packet_size > 0) {
609
610 /* packet header size */
611 packet_size -= 6;
612
613 /* packet header */
614 if (s->is_mpeg2) {
615 header_len = 3;
616 } else {
617 header_len = 0;
618 }
619 if (pts != AV_NOPTS_VALUE) {
620 if (dts != pts)
621 header_len += 5 + 5;
622 else
623 header_len += 5;
624 } else {
625 if (!s->is_mpeg2)
626 header_len++;
627 }
628
629 payload_size = packet_size - header_len;
630 if (id < 0xc0) {
631 startcode = PRIVATE_STREAM_1;
632 payload_size -= 4;
633 if (id >= 0xa0)
634 payload_size -= 3;
635 } else {
636 startcode = 0x100 + id;
637 }
638
639 stuffing_size = payload_size - stream->buffer_ptr;
640 if (stuffing_size < 0)
641 stuffing_size = 0;
642 put_be32(&ctx->pb, startcode);
643
644 put_be16(&ctx->pb, packet_size);
645
646 if (!s->is_mpeg2)
647 for(i=0;i<stuffing_size;i++)
648 put_byte(&ctx->pb, 0xff);
649
650 if (s->is_mpeg2) {
651 put_byte(&ctx->pb, 0x80); /* mpeg2 id */
652
653 if (pts != AV_NOPTS_VALUE) {
654 if (dts != pts) {
655 put_byte(&ctx->pb, 0xc0); /* flags */
656 put_byte(&ctx->pb, header_len - 3 + stuffing_size);
657 put_timestamp(&ctx->pb, 0x03, pts);
658 put_timestamp(&ctx->pb, 0x01, dts);
659 } else {
660 put_byte(&ctx->pb, 0x80); /* flags */
661 put_byte(&ctx->pb, header_len - 3 + stuffing_size);
662 put_timestamp(&ctx->pb, 0x02, pts);
663 }
664 } else {
665 put_byte(&ctx->pb, 0x00); /* flags */
666 put_byte(&ctx->pb, header_len - 3 + stuffing_size);
667 }
668 } else {
669 if (pts != AV_NOPTS_VALUE) {
670 if (dts != pts) {
671 put_timestamp(&ctx->pb, 0x03, pts);
672 put_timestamp(&ctx->pb, 0x01, dts);
673 } else {
674 put_timestamp(&ctx->pb, 0x02, pts);
675 }
676 } else {
677 put_byte(&ctx->pb, 0x0f);
678 }
679 }
680
681 if (startcode == PRIVATE_STREAM_1) {
682 put_byte(&ctx->pb, id);
683 if (id >= 0xa0) {
684 /* LPCM (XXX: check nb_frames) */
685 put_byte(&ctx->pb, 7);
686 put_be16(&ctx->pb, 4); /* skip 3 header bytes */
687 put_byte(&ctx->pb, stream->lpcm_header[0]);
688 put_byte(&ctx->pb, stream->lpcm_header[1]);
689 put_byte(&ctx->pb, stream->lpcm_header[2]);
690 } else {
691 /* AC3 */
692 put_byte(&ctx->pb, stream->nb_frames);
693 put_be16(&ctx->pb, stream->frame_start_offset);
694 }
695 }
696
697 if (s->is_mpeg2)
698 for(i=0;i<stuffing_size;i++)
699 put_byte(&ctx->pb, 0xff);
700
701 /* output data */
702 put_buffer(&ctx->pb, stream->buffer, payload_size - stuffing_size);
703 }
704
705 if (pad_packet_bytes > 0)
706 put_padding_packet(ctx,&ctx->pb, pad_packet_bytes);
707
708 for(i=0;i<zero_trail_bytes;i++)
709 put_byte(&ctx->pb, 0x00);
710
711 put_flush_packet(&ctx->pb);
712
713 s->packet_number++;
714 stream->packet_number++;
715 stream->nb_frames = 0;
716 stream->frame_start_offset = 0;
717 }
718
719 static void put_vcd_padding_sector(AVFormatContext *ctx)
720 {
721 /* There are two ways to do this padding: writing a sector/pack
722 of 0 values, or writing an MPEG padding pack. Both seem to
723 work with most decoders, BUT the VCD standard only allows a 0-sector
724 (see standard p. IV-4, IV-5).
725 So a 0-sector it is...*/
726
727 MpegMuxContext *s = ctx->priv_data;
728 int i;
729
730 for(i=0;i<s->packet_size;i++)
731 put_byte(&ctx->pb, 0);
732
733 s->vcd_padding_bytes_written += s->packet_size;
734
735 put_flush_packet(&ctx->pb);
736
737 /* increasing the packet number is correct. The SCR of the following packs
738 is calculated from the packet_number and it has to include the padding
739 sector (it represents the sector index, not the MPEG pack index)
740 (see VCD standard p. IV-6)*/
741 s->packet_number++;
742 }
743
744 /* XXX: move that to upper layer */
745 /* XXX: we assume that there are always 'max_b_frames' between
746 reference frames. A better solution would be to use the AVFrame pts
747 field */
748 static void compute_pts_dts(AVStream *st, int64_t *ppts, int64_t *pdts,
749 int64_t timestamp)
750 {
751 int frame_delay;
752 int64_t pts, dts;
753
754 if (st->codec.codec_type == CODEC_TYPE_VIDEO &&
755 st->codec.max_b_frames != 0) {
756 frame_delay = (st->codec.frame_rate_base * 90000LL) /
757 st->codec.frame_rate;
758 if (timestamp == 0) {
759 /* specific case for first frame : DTS just before */
760 pts = timestamp;
761 dts = timestamp - frame_delay;
762 } else {
763 timestamp -= frame_delay;
764 if (st->codec.coded_frame->pict_type == FF_B_TYPE) {
765 /* B frames has identical pts/dts */
766 pts = timestamp;
767 dts = timestamp;
768 } else {
769 /* a reference frame has a pts equal to the dts of the
770 _next_ one */
771 dts = timestamp;
772 pts = timestamp + (st->codec.max_b_frames + 1) * frame_delay;
773 }
774 }
775 #if 1
776 av_log(&st->codec, AV_LOG_DEBUG, "pts=%0.3f dts=%0.3f pict_type=%c\n",
777 pts / 90000.0, dts / 90000.0,
778 av_get_pict_type_char(st->codec.coded_frame->pict_type));
779 #endif
780 } else {
781 pts = timestamp;
782 dts = timestamp;
783 }
784 *ppts = pts & ((1LL << 33) - 1);
785 *pdts = dts & ((1LL << 33) - 1);
786 }
787
788 static int64_t update_scr(AVFormatContext *ctx,int stream_index,int64_t pts)
789 {
790 MpegMuxContext *s = ctx->priv_data;
791 int64_t scr;
792
793 if (s->is_vcd)
794 /* Since the data delivery rate is constant, SCR is computed
795 using the formula C + i * 1200 where C is the start constant
796 and i is the pack index.
797 It is recommended that SCR 0 is at the beginning of the VCD front
798 margin (a sequence of empty Form 2 sectors on the CD).
799 It is recommended that the front margin is 30 sectors long, so
800 we use C = 30*1200 = 36000
801 (Note that even if the front margin is not 30 sectors the file
802 will still be correct according to the standard. It just won't have
803 the "recommended" value).*/
804 scr = 36000 + s->packet_number * 1200;
805 else {
806 /* XXX I believe this calculation of SCR is wrong. SCR
807 specifies at which time the data should enter the decoder.
808 Two packs cannot enter the decoder at the same time. */
809
810 /* XXX: system clock should be computed precisely, especially for
811 CBR case. The current mode gives at least something coherent */
812 if (stream_index == s->scr_stream_index
813 && pts != AV_NOPTS_VALUE)
814 scr = pts;
815 else
816 scr = s->last_scr;
817 }
818
819 s->last_scr=scr;
820
821 return scr;
822 }
823
824
825 static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
826 const uint8_t *buf, int size,
827 int64_t timestamp)
828 {
829 MpegMuxContext *s = ctx->priv_data;
830 AVStream *st = ctx->streams[stream_index];
831 StreamInfo *stream = st->priv_data;
832 int64_t pts, dts, new_start_pts, new_start_dts;
833 int len, avail_size;
834
835 compute_pts_dts(st, &pts, &dts, timestamp);
836
837
838 #if 0
839 update_scr(ctx,stream_index,pts);
840
841 printf("%d: pts=%0.3f dts=%0.3f scr=%0.3f\n",
842 stream_index,
843 pts / 90000.0,
844 dts / 90000.0,
845 s->last_scr / 90000.0);
846 #endif
847
848 /* we assume here that pts != AV_NOPTS_VALUE */
849 new_start_pts = stream->start_pts;
850 new_start_dts = stream->start_dts;
851
852 if (stream->start_pts == AV_NOPTS_VALUE) {
853 new_start_pts = pts;
854 new_start_dts = dts;
855 }
856 avail_size = get_packet_payload_size(ctx, stream_index,
857 new_start_pts,
858 new_start_dts);
859 if (stream->buffer_ptr >= avail_size) {
860
861 update_scr(ctx,stream_index,stream->start_pts);
862
863 /* unlikely case: outputing the pts or dts increase the packet
864 size so that we cannot write the start of the next
865 packet. In this case, we must flush the current packet with
866 padding.
867 Note: this always happens for the first audio and video packet
868 in a VCD file, since they do not carry any data.*/
869 flush_packet(ctx, stream_index,
870 stream->start_pts, stream->start_dts, s->last_scr);
871 stream->buffer_ptr = 0;
872 }
873 stream->start_pts = new_start_pts;
874 stream->start_dts = new_start_dts;
875 stream->nb_frames++;
876 if (stream->frame_start_offset == 0)
877 stream->frame_start_offset = stream->buffer_ptr;
878 while (size > 0) {
879 avail_size = get_packet_payload_size(ctx, stream_index,
880 stream->start_pts,
881 stream->start_dts);
882 len = avail_size - stream->buffer_ptr;
883 if (len > size)
884 len = size;
885 memcpy(stream->buffer + stream->buffer_ptr, buf, len);
886 stream->buffer_ptr += len;
887 buf += len;
888 size -= len;
889 if (stream->buffer_ptr >= avail_size) {
890
891 update_scr(ctx,stream_index,stream->start_pts);
892
893 /* if packet full, we send it now */
894 flush_packet(ctx, stream_index,
895 stream->start_pts, stream->start_dts, s->last_scr);
896 stream->buffer_ptr = 0;
897
898 if (s->is_vcd) {
899 /* Write one or more padding sectors, if necessary, to reach
900 the constant overall bitrate.*/
901 int vcd_pad_bytes;
902
903 while((vcd_pad_bytes = get_vcd_padding_size(ctx,stream->start_pts) ) >= s->packet_size)
904 put_vcd_padding_sector(ctx);
905 }
906
907 /* Make sure only the FIRST pes packet for this frame has
908 a timestamp */
909 stream->start_pts = AV_NOPTS_VALUE;
910 stream->start_dts = AV_NOPTS_VALUE;
911 }
912 }
913
914 return 0;
915 }
916
917 static int mpeg_mux_end(AVFormatContext *ctx)
918 {
919 MpegMuxContext *s = ctx->priv_data;
920 StreamInfo *stream;
921 int i;
922
923 /* flush each packet */
924 for(i=0;i<ctx->nb_streams;i++) {
925 stream = ctx->streams[i]->priv_data;
926 if (stream->buffer_ptr > 0) {
927 update_scr(ctx,i,stream->start_pts);
928
929 /* NOTE: we can always write the remaining data as it was
930 tested before in mpeg_mux_write_packet() */
931 flush_packet(ctx, i, stream->start_pts, stream->start_dts,
932 s->last_scr);
933 }
934 }
935
936 /* End header according to MPEG1 systems standard. We do not write
937 it as it is usually not needed by decoders and because it
938 complicates MPEG stream concatenation. */
939 //put_be32(&ctx->pb, ISO_11172_END_CODE);
940 //put_flush_packet(&ctx->pb);
941
942 for(i=0;i<ctx->nb_streams;i++)
943 av_freep(&ctx->streams[i]->priv_data);
944
945 return 0;
946 }
947 #endif //CONFIG_ENCODERS
948
949 /*********************************************/
950 /* demux code */
951
952 #define MAX_SYNC_SIZE 100000
953
954 static int mpegps_probe(AVProbeData *p)
955 {
956 int code, c, i;
957
958 code = 0xff;
959 /* we search the first start code. If it is a packet start code,
960 then we decide it is mpeg ps. We do not send highest value to
961 give a chance to mpegts */
962 /* NOTE: the search range was restricted to avoid too many false
963 detections */
964
965 if (p->buf_size < 6)
966 return 0;
967
968 for (i = 0; i < 20; i++) {
969 c = p->buf[i];
970 code = (code << 8) | c;
971 if ((code & 0xffffff00) == 0x100) {
972 if (code == PACK_START_CODE ||
973 code == SYSTEM_HEADER_START_CODE ||
974 (code >= 0x1e0 && code <= 0x1ef) ||
975 (code >= 0x1c0 && code <= 0x1df) ||
976 code == PRIVATE_STREAM_2 ||
977 code == PROGRAM_STREAM_MAP ||
978 code == PRIVATE_STREAM_1 ||
979 code == PADDING_STREAM)
980 return AVPROBE_SCORE_MAX - 2;
981 else
982 return 0;
983 }
984 }
985 return 0;
986 }
987
988
989 typedef struct MpegDemuxContext {
990 int header_state;
991 } MpegDemuxContext;
992
993 static int mpegps_read_header(AVFormatContext *s,
994 AVFormatParameters *ap)
995 {
996 MpegDemuxContext *m = s->priv_data;
997 m->header_state = 0xff;
998 s->ctx_flags |= AVFMTCTX_NOHEADER;
999
1000 /* no need to do more */
1001 return 0;
1002 }
1003
1004 static int64_t get_pts(ByteIOContext *pb, int c)
1005 {
1006 int64_t pts;
1007 int val;
1008
1009 if (c < 0)
1010 c = get_byte(pb);
1011 pts = (int64_t)((c >> 1) & 0x07) << 30;
1012 val = get_be16(pb);
1013 pts |= (int64_t)(val >> 1) << 15;
1014 val = get_be16(pb);
1015 pts |= (int64_t)(val >> 1);
1016 return pts;
1017 }
1018
1019 static int find_next_start_code(ByteIOContext *pb, int *size_ptr,
1020 uint32_t *header_state)
1021 {
1022 unsigned int state, v;
1023 int val, n;
1024
1025 state = *header_state;
1026 n = *size_ptr;
1027 while (n > 0) {
1028 if (url_feof(pb))
1029 break;
1030 v = get_byte(pb);
1031 n--;
1032 if (state == 0x000001) {
1033 state = ((state << 8) | v) & 0xffffff;
1034 val = state;
1035 goto found;
1036 }
1037 state = ((state << 8) | v) & 0xffffff;
1038 }
1039 val = -1;
1040 found:
1041 *header_state = state;
1042 *size_ptr = n;
1043 return val;
1044 }
1045
1046 /* XXX: optimize */
1047 static int find_prev_start_code(ByteIOContext *pb, int *size_ptr)
1048 {
1049 int64_t pos, pos_start;
1050 int max_size, start_code;
1051
1052 max_size = *size_ptr;
1053 pos_start = url_ftell(pb);
1054
1055 /* in order to go faster, we fill the buffer */
1056 pos = pos_start - 16386;
1057 if (pos < 0)
1058 pos = 0;
1059 url_fseek(pb, pos, SEEK_SET);
1060 get_byte(pb);
1061
1062 pos = pos_start;
1063 for(;;) {
1064 pos--;
1065 if (pos < 0 || (pos_start - pos) >= max_size) {
1066 start_code = -1;
1067 goto the_end;
1068 }
1069 url_fseek(pb, pos, SEEK_SET);
1070 start_code = get_be32(pb);
1071 if ((start_code & 0xffffff00) == 0x100)
1072 break;
1073 }
1074 the_end:
1075 *size_ptr = pos_start - pos;
1076 return start_code;
1077 }
1078
1079 /* read the next (or previous) PES header. Return its position in ppos
1080 (if not NULL), and its start code, pts and dts.
1081 */
1082 static int mpegps_read_pes_header(AVFormatContext *s,
1083 int64_t *ppos, int *pstart_code,
1084 int64_t *ppts, int64_t *pdts, int find_next)
1085 {
1086 MpegDemuxContext *m = s->priv_data;
1087 int len, size, startcode, c, flags, header_len;
1088 int64_t pts, dts, last_pos;
1089
1090 last_pos = -1;
1091 redo:
1092 if (find_next) {
1093 /* next start code (should be immediately after) */
1094 m->header_state = 0xff;
1095 size = MAX_SYNC_SIZE;
1096 startcode = find_next_start_code(&s->pb, &size, &m->header_state);
1097 } else {
1098 if (last_pos >= 0)
1099 url_fseek(&s->pb, last_pos, SEEK_SET);
1100 size = MAX_SYNC_SIZE;
1101 startcode = find_prev_start_code(&s->pb, &size);
1102 last_pos = url_ftell(&s->pb) - 4;
1103 }
1104 //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
1105 if (startcode < 0)
1106 return -EIO;
1107 if (startcode == PACK_START_CODE)
1108 goto redo;
1109 if (startcode == SYSTEM_HEADER_START_CODE)
1110 goto redo;
1111 if (startcode == PADDING_STREAM ||
1112 startcode == PRIVATE_STREAM_2) {
1113 /* skip them */
1114 len = get_be16(&s->pb);
1115 url_fskip(&s->pb, len);
1116 goto redo;
1117 }
1118 /* find matching stream */
1119 if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
1120 (startcode >= 0x1e0 && startcode <= 0x1ef) ||
1121 (startcode == 0x1bd)))
1122 goto redo;
1123 if (ppos) {
1124 *ppos = url_ftell(&s->pb) - 4;
1125 }
1126 len = get_be16(&s->pb);
1127 pts = AV_NOPTS_VALUE;
1128 dts = AV_NOPTS_VALUE;
1129 /* stuffing */
1130 for(;;) {
1131 if (len < 1)
1132 goto redo;
1133 c = get_byte(&s->pb);
1134 len--;
1135 /* XXX: for mpeg1, should test only bit 7 */
1136 if (c != 0xff)
1137 break;
1138 }
1139 if ((c & 0xc0) == 0x40) {
1140 /* buffer scale & size */
1141 if (len < 2)
1142 goto redo;
1143 get_byte(&s->pb);
1144 c = get_byte(&s->pb);
1145 len -= 2;
1146 }
1147 if ((c & 0xf0) == 0x20) {
1148 if (len < 4)
1149 goto redo;
1150 dts = pts = get_pts(&s->pb, c);
1151 len -= 4;
1152 } else if ((c & 0xf0) == 0x30) {
1153 if (len < 9)
1154 goto redo;
1155 pts = get_pts(&s->pb, c);
1156 dts = get_pts(&s->pb, -1);
1157 len -= 9;
1158 } else if ((c & 0xc0) == 0x80) {
1159 /* mpeg 2 PES */
1160 if ((c & 0x30) != 0) {
1161 /* Encrypted multiplex not handled */
1162 goto redo;
1163 }
1164 flags = get_byte(&s->pb);
1165 header_len = get_byte(&s->pb);
1166 len -= 2;
1167 if (header_len > len)
1168 goto redo;
1169 if ((flags & 0xc0) == 0x80) {
1170 dts = pts = get_pts(&s->pb, -1);
1171 if (header_len < 5)
1172 goto redo;
1173 header_len -= 5;
1174 len -= 5;
1175 } if ((flags & 0xc0) == 0xc0) {
1176 pts = get_pts(&s->pb, -1);
1177 dts = get_pts(&s->pb, -1);
1178 if (header_len < 10)
1179 goto redo;
1180 header_len -= 10;
1181 len -= 10;
1182 }
1183 len -= header_len;
1184 while (header_len > 0) {
1185 get_byte(&s->pb);
1186 header_len--;
1187 }
1188 }
1189 if (startcode == 0x1bd) {
1190 if (len < 1)
1191 goto redo;
1192 startcode = get_byte(&s->pb);
1193 len--;
1194 if (startcode >= 0x80 && startcode <= 0xbf) {
1195 /* audio: skip header */
1196 if (len < 3)
1197 goto redo;
1198 get_byte(&s->pb);
1199 get_byte(&s->pb);
1200 get_byte(&s->pb);
1201 len -= 3;
1202 }
1203 }
1204 if(dts != AV_NOPTS_VALUE && ppos){
1205 int i;
1206 for(i=0; i<s->nb_streams; i++){
1207 if(startcode == s->streams[i]->id) {
1208 av_add_index_entry(s->streams[i], *ppos, dts, 0, 0 /* FIXME keyframe? */);
1209 }
1210 }
1211 }
1212
1213 *pstart_code = startcode;
1214 *ppts = pts;
1215 *pdts = dts;
1216 return len;
1217 }
1218
1219 static int mpegps_read_packet(AVFormatContext *s,
1220 AVPacket *pkt)
1221 {
1222 AVStream *st;
1223 int len, startcode, i, type, codec_id;
1224 int64_t pts, dts, dummy_pos; //dummy_pos is needed for the index building to work
1225
1226 redo:
1227 len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts, 1);
1228 if (len < 0)
1229 return len;
1230
1231 /* now find stream */
1232 for(i=0;i<s->nb_streams;i++) {
1233 st = s->streams[i];
1234 if (st->id == startcode)
1235 goto found;
1236 }
1237 if (startcode >= 0x1e0 && startcode <= 0x1ef) {
1238 type = CODEC_TYPE_VIDEO;
1239 codec_id = CODEC_ID_MPEG2VIDEO;
1240 } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
1241 type = CODEC_TYPE_AUDIO;
1242 codec_id = CODEC_ID_MP2;
1243 } else if (startcode >= 0x80 && startcode <= 0x9f) {
1244 type = CODEC_TYPE_AUDIO;
1245 codec_id = CODEC_ID_AC3;
1246 } else if (startcode >= 0xa0 && startcode <= 0xbf) {
1247 type = CODEC_TYPE_AUDIO;
1248 codec_id = CODEC_ID_PCM_S16BE;
1249 } else {
1250 skip:
1251 /* skip packet */
1252 url_fskip(&s->pb, len);
1253 goto redo;
1254 }
1255 /* no stream found: add a new stream */
1256 st = av_new_stream(s, startcode);
1257 if (!st)
1258 goto skip;
1259 st->codec.codec_type = type;
1260 st->codec.codec_id = codec_id;
1261 if (codec_id != CODEC_ID_PCM_S16BE)
1262 st->need_parsing = 1;
1263 found:
1264 if (startcode >= 0xa0 && startcode <= 0xbf) {
1265 int b1, freq;
1266
1267 /* for LPCM, we just skip the header and consider it is raw
1268 audio data */
1269 if (len <= 3)
1270 goto skip;
1271 get_byte(&s->pb); /* emphasis (1), muse(1), reserved(1), frame number(5) */
1272 b1 = get_byte(&s->pb); /* quant (2), freq(2), reserved(1), channels(3) */
1273 get_byte(&s->pb); /* dynamic range control (0x80 = off) */
1274 len -= 3;
1275 freq = (b1 >> 4) & 3;
1276 st->codec.sample_rate = lpcm_freq_tab[freq];
1277 st->codec.channels = 1 + (b1 & 7);
1278 st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
1279 }
1280 av_new_packet(pkt, len);
1281 get_buffer(&s->pb, pkt->data, pkt->size);
1282 pkt->pts = pts;
1283 pkt->dts = dts;
1284 pkt->stream_index = st->index;
1285 #if 0
1286 printf("%d: pts=%0.3f dts=%0.3f\n",
1287 pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0);
1288 #endif
1289 return 0;
1290 }
1291
1292 static int mpegps_read_close(AVFormatContext *s)
1293 {
1294 return 0;
1295 }
1296
1297 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
1298 int64_t *ppos, int find_next)
1299 {
1300 int len, startcode;
1301 int64_t pos, pts, dts;
1302
1303 pos = *ppos;
1304 #ifdef DEBUG_SEEK
1305 printf("read_dts: pos=0x%llx next=%d -> ", pos, find_next);
1306 #endif
1307 url_fseek(&s->pb, pos, SEEK_SET);
1308 for(;;) {
1309 len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts, find_next);
1310 if (len < 0) {
1311 #ifdef DEBUG_SEEK
1312 printf("none (ret=%d)\n", len);
1313 #endif
1314 return AV_NOPTS_VALUE;
1315 }
1316 if (startcode == s->streams[stream_index]->id &&
1317 dts != AV_NOPTS_VALUE) {
1318 break;
1319 }
1320 if (find_next) {
1321 url_fskip(&s->pb, len);
1322 } else {
1323 url_fseek(&s->pb, pos, SEEK_SET);
1324 }
1325 }
1326 #ifdef DEBUG_SEEK
1327 printf("pos=0x%llx dts=0x%llx %0.3f\n", pos, dts, dts / 90000.0);
1328 #endif
1329 *ppos = pos;
1330 return dts;
1331 }
1332
1333 static int mpegps_read_seek(AVFormatContext *s,
1334 int stream_index, int64_t timestamp)
1335 {
1336 int64_t pos_min, pos_max, pos, pos_limit;
1337 int64_t dts_min, dts_max, dts;
1338 int index, no_change;
1339 AVStream *st;
1340
1341 timestamp = (timestamp * 90000) / AV_TIME_BASE;
1342
1343 #ifdef DEBUG_SEEK
1344 printf("read_seek: %d %0.3f\n", stream_index, timestamp / 90000.0);
1345 #endif
1346
1347 /* XXX: find stream_index by looking at the first PES packet found */
1348 if (stream_index < 0) {
1349 stream_index = av_find_default_stream_index(s);
1350 if (stream_index < 0)
1351 return -1;
1352 }
1353
1354 dts_max=
1355 dts_min= AV_NOPTS_VALUE;
1356 pos_limit= -1; //gcc falsely says it may be uninitalized
1357
1358 st= s->streams[stream_index];
1359 if(st->index_entries){
1360 AVIndexEntry *e;
1361
1362 index= av_index_search_timestamp(st, timestamp);
1363 e= &st->index_entries[index];
1364 if(e->timestamp <= timestamp){
1365 pos_min= e->pos;
1366 dts_min= e->timestamp;
1367 #ifdef DEBUG_SEEK
1368 printf("unsing cached pos_min=0x%llx dts_min=%0.3f\n",
1369 pos_min,dts_min / 90000.0);
1370 #endif
1371 }else{
1372 assert(index==0);
1373 }
1374 index++;
1375 if(index < st->nb_index_entries){
1376 e= &st->index_entries[index];
1377 assert(e->timestamp >= timestamp);
1378 pos_max= e->pos;
1379 dts_max= e->timestamp;
1380 pos_limit= pos_max - e->min_distance;
1381 #ifdef DEBUG_SEEK
1382 printf("unsing cached pos_max=0x%llx dts_max=%0.3f\n",
1383 pos_max,dts_max / 90000.0);
1384 #endif
1385 }
1386 }
1387
1388 if(dts_min == AV_NOPTS_VALUE){
1389 pos_min = 0;
1390 dts_min = mpegps_read_dts(s, stream_index, &pos_min, 1);
1391 if (dts_min == AV_NOPTS_VALUE) {
1392 /* we can reach this case only if no PTS are present in
1393 the whole stream */
1394 return -1;
1395 }
1396 }
1397 if(dts_max == AV_NOPTS_VALUE){
1398 pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1399 dts_max = mpegps_read_dts(s, stream_index, &pos_max, 0);
1400 pos_limit= pos_max;
1401 }
1402
1403 no_change=0;
1404 while (pos_min < pos_limit) {
1405 #ifdef DEBUG_SEEK
1406 printf("pos_min=0x%llx pos_max=0x%llx dts_min=%0.3f dts_max=%0.3f\n",
1407 pos_min, pos_max,
1408 dts_min / 90000.0, dts_max / 90000.0);
1409 #endif
1410 int64_t start_pos;
1411 assert(pos_limit <= pos_max);
1412
1413 if(no_change==0){
1414 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1415 // interpolate position (better than dichotomy)
1416 pos = (int64_t)((double)(pos_max - pos_min) *
1417 (double)(timestamp - dts_min) /
1418 (double)(dts_max - dts_min)) + pos_min - approximate_keyframe_distance;
1419 }else if(no_change==1){
1420 // bisection, if interpolation failed to change min or max pos last time
1421 pos = (pos_min + pos_limit)>>1;
1422 }else{
1423 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1424 pos=pos_min;
1425 }
1426 if(pos <= pos_min)
1427 pos= pos_min + 1;
1428 else if(pos > pos_limit)
1429 pos= pos_limit;
1430 start_pos= pos;
1431
1432 // read the next timestamp
1433 dts = mpegps_read_dts(s, stream_index, &pos, 1);
1434 if(pos == pos_max)
1435 no_change++;
1436 else
1437 no_change=0;
1438 #ifdef DEBUG_SEEK
1439 printf("%Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld noc:%d\n", pos_min, pos, pos_max, dts_min, dts, dts_max, timestamp, pos_limit, start_pos, no_change);
1440 #endif
1441 assert(dts != AV_NOPTS_VALUE);
1442 if (timestamp < dts) {
1443 pos_limit = start_pos - 1;
1444 pos_max = pos;
1445 dts_max = dts;
1446 } else {
1447 pos_min = pos;
1448 dts_min = dts;
1449 /* check if we are lucky */
1450 if (timestamp == dts)
1451 break;
1452 }
1453 }
1454
1455 pos = pos_min;
1456 #ifdef DEBUG_SEEK
1457 pos_min = pos;
1458 dts_min = mpegps_read_dts(s, stream_index, &pos_min, 1);
1459 pos_min++;
1460 dts_max = mpegps_read_dts(s, stream_index, &pos_min, 1);
1461 printf("pos=0x%llx %0.3f<=%0.3f<=%0.3f\n",
1462 pos, dts_min / 90000.0, timestamp / 90000.0, dts_max / 90000.0);
1463 #endif
1464 /* do the seek */
1465 url_fseek(&s->pb, pos, SEEK_SET);
1466 return 0;
1467 }
1468
1469 #ifdef CONFIG_ENCODERS
1470 static AVOutputFormat mpeg1system_mux = {
1471 "mpeg",
1472 "MPEG1 System format",
1473 "video/mpeg",
1474 "mpg,mpeg",
1475 sizeof(MpegMuxContext),
1476 CODEC_ID_MP2,
1477 CODEC_ID_MPEG1VIDEO,
1478 mpeg_mux_init,
1479 mpeg_mux_write_packet,
1480 mpeg_mux_end,
1481 };
1482
1483 static AVOutputFormat mpeg1vcd_mux = {
1484 "vcd",
1485 "MPEG1 System format (VCD)",
1486 "video/mpeg",
1487 NULL,
1488 sizeof(MpegMuxContext),
1489 CODEC_ID_MP2,
1490 CODEC_ID_MPEG1VIDEO,
1491 mpeg_mux_init,
1492 mpeg_mux_write_packet,
1493 mpeg_mux_end,
1494 };
1495
1496 static AVOutputFormat mpeg2vob_mux = {
1497 "vob",
1498 "MPEG2 PS format (VOB)",
1499 "video/mpeg",
1500 "vob",
1501 sizeof(MpegMuxContext),
1502 CODEC_ID_MP2,
1503 CODEC_ID_MPEG2VIDEO,
1504 mpeg_mux_init,
1505 mpeg_mux_write_packet,
1506 mpeg_mux_end,
1507 };
1508
1509 /* Same as mpeg2vob_mux except that the pack size is 2324 */
1510 static AVOutputFormat mpeg2svcd_mux = {
1511 "svcd",
1512 "MPEG2 PS format (VOB)",
1513 "video/mpeg",
1514 "vob",
1515 sizeof(MpegMuxContext),
1516 CODEC_ID_MP2,
1517 CODEC_ID_MPEG2VIDEO,
1518 mpeg_mux_init,
1519 mpeg_mux_write_packet,
1520 mpeg_mux_end,
1521 };
1522
1523
1524
1525 #endif //CONFIG_ENCODERS
1526
1527 AVInputFormat mpegps_demux = {
1528 "mpeg",
1529 "MPEG PS format",
1530 sizeof(MpegDemuxContext),
1531 mpegps_probe,
1532 mpegps_read_header,
1533 mpegps_read_packet,
1534 mpegps_read_close,
1535 mpegps_read_seek,
1536 };
1537
1538 int mpegps_init(void)
1539 {
1540 #ifdef CONFIG_ENCODERS
1541 av_register_output_format(&mpeg1system_mux);
1542 av_register_output_format(&mpeg1vcd_mux);
1543 av_register_output_format(&mpeg2vob_mux);
1544 av_register_output_format(&mpeg2svcd_mux);
1545 #endif //CONFIG_ENCODERS
1546 av_register_input_format(&mpegps_demux);
1547 return 0;
1548 }