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