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