projects / libav.git / blob
? search:


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