suppressed mpeg demux mess - use now dynamic stream creation api
[ffmpeg.git] / libav / mpeg.c
1 /*
2  * MPEG1 mux/demux
3  * Copyright (c) 2000, 2001, 2002 Gerard Lantau.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program 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
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */
19 #include "avformat.h"
20 #include "tick.h"
21
22 #define MAX_PAYLOAD_SIZE 4096
23 #define NB_STREAMS 2
24
25 typedef struct {
26     UINT8 buffer[MAX_PAYLOAD_SIZE];
27     int buffer_ptr;
28     UINT8 id;
29     int max_buffer_size; /* in bytes */
30     int packet_number;
31     INT64 pts;
32     Ticker pts_ticker;
33     INT64 start_pts;
34 } StreamInfo;
35
36 typedef struct {
37     int packet_size; /* required packet size */
38     int packet_data_max_size; /* maximum data size inside a packet */
39     int packet_number;
40     int pack_header_freq;     /* frequency (in packets^-1) at which we send pack headers */
41     int system_header_freq;
42     int mux_rate; /* bitrate in units of 50 bytes/s */
43     /* stream info */
44     int audio_bound;
45     int video_bound;
46 } MpegMuxContext;
47
48 #define PACK_START_CODE             ((unsigned int)0x000001ba)
49 #define SYSTEM_HEADER_START_CODE    ((unsigned int)0x000001bb)
50 #define SEQUENCE_END_CODE           ((unsigned int)0x000001b7)
51 #define PACKET_START_CODE_MASK      ((unsigned int)0xffffff00)
52 #define PACKET_START_CODE_PREFIX    ((unsigned int)0x00000100)
53 #define ISO_11172_END_CODE          ((unsigned int)0x000001b9)
54   
55 /* mpeg2 */
56 #define PROGRAM_STREAM_MAP 0x1bc
57 #define PRIVATE_STREAM_1   0x1bd
58 #define PADDING_STREAM     0x1be
59 #define PRIVATE_STREAM_2   0x1bf
60
61
62 #define AUDIO_ID 0xc0
63 #define VIDEO_ID 0xe0
64
65 static int put_pack_header(AVFormatContext *ctx, 
66                            UINT8 *buf, INT64 timestamp)
67 {
68     MpegMuxContext *s = ctx->priv_data;
69     PutBitContext pb;
70     
71     init_put_bits(&pb, buf, 128, NULL, NULL);
72
73     put_bits(&pb, 32, PACK_START_CODE);
74     put_bits(&pb, 4, 0x2);
75     put_bits(&pb, 3, (UINT32)((timestamp >> 30) & 0x07));
76     put_bits(&pb, 1, 1);
77     put_bits(&pb, 15, (UINT32)((timestamp >> 15) & 0x7fff));
78     put_bits(&pb, 1, 1);
79     put_bits(&pb, 15, (UINT32)((timestamp) & 0x7fff));
80     put_bits(&pb, 1, 1);
81     put_bits(&pb, 1, 1);
82     put_bits(&pb, 22, s->mux_rate);
83     put_bits(&pb, 1, 1);
84
85     flush_put_bits(&pb);
86     return pbBufPtr(&pb) - pb.buf;
87 }
88
89 static int put_system_header(AVFormatContext *ctx, UINT8 *buf)
90 {
91     MpegMuxContext *s = ctx->priv_data;
92     int size, rate_bound, i, private_stream_coded, id;
93     PutBitContext pb;
94
95     init_put_bits(&pb, buf, 128, NULL, NULL);
96
97     put_bits(&pb, 32, SYSTEM_HEADER_START_CODE);
98     put_bits(&pb, 16, 0);
99     put_bits(&pb, 1, 1);
100     
101     rate_bound = s->mux_rate; /* maximum bit rate of the multiplexed stream */
102     put_bits(&pb, 22, rate_bound);
103     put_bits(&pb, 1, 1); /* marker */
104     put_bits(&pb, 6, s->audio_bound);
105
106     put_bits(&pb, 1, 1); /* variable bitrate */
107     put_bits(&pb, 1, 1); /* non constrainted bit stream */
108     
109     put_bits(&pb, 1, 0); /* audio locked */
110     put_bits(&pb, 1, 0); /* video locked */
111     put_bits(&pb, 1, 1); /* marker */
112
113     put_bits(&pb, 5, s->video_bound);
114     put_bits(&pb, 8, 0xff); /* reserved byte */
115     
116     /* audio stream info */
117     private_stream_coded = 0;
118     for(i=0;i<ctx->nb_streams;i++) {
119         StreamInfo *stream = ctx->streams[i]->priv_data;
120         id = stream->id;
121         if (id < 0xc0) {
122             /* special case for private streams (AC3 use that) */
123             if (private_stream_coded)
124                 continue;
125             private_stream_coded = 1;
126             id = 0xbd;
127         }
128         put_bits(&pb, 8, id); /* stream ID */
129         put_bits(&pb, 2, 3);
130         if (id < 0xe0) {
131             /* audio */
132             put_bits(&pb, 1, 0);
133             put_bits(&pb, 13, stream->max_buffer_size / 128);
134         } else {
135             /* video */
136             put_bits(&pb, 1, 1);
137             put_bits(&pb, 13, stream->max_buffer_size / 1024);
138         }
139     }
140     flush_put_bits(&pb);
141     size = pbBufPtr(&pb) - pb.buf;
142     /* patch packet size */
143     buf[4] = (size - 6) >> 8;
144     buf[5] = (size - 6) & 0xff;
145
146     return size;
147 }
148
149 static int mpeg_mux_init(AVFormatContext *ctx)
150 {
151     MpegMuxContext *s = ctx->priv_data;
152     int bitrate, i, mpa_id, mpv_id, ac3_id;
153     AVStream *st;
154     StreamInfo *stream;
155
156     s->packet_number = 0;
157
158     /* XXX: hardcoded */
159     if (ctx->flags & AVF_FLAG_VCD)
160         s->packet_size = 2324; /* VCD packet size */
161     else
162         s->packet_size = 2048;
163         
164     /* startcode(4) + length(2) + flags(1) */
165     s->packet_data_max_size = s->packet_size - 7;
166     s->audio_bound = 0;
167     s->video_bound = 0;
168     mpa_id = AUDIO_ID;
169     ac3_id = 0x80;
170     mpv_id = VIDEO_ID;
171     for(i=0;i<ctx->nb_streams;i++) {
172         st = ctx->streams[i];
173         stream = av_mallocz(sizeof(StreamInfo));
174         if (!stream)
175             goto fail;
176         st->priv_data = stream;
177
178         switch(st->codec.codec_type) {
179         case CODEC_TYPE_AUDIO:
180             if (st->codec.codec_id == CODEC_ID_AC3)
181                 stream->id = ac3_id++;
182             else
183                 stream->id = mpa_id++;
184             stream->max_buffer_size = 4 * 1024; 
185             s->audio_bound++;
186             break;
187         case CODEC_TYPE_VIDEO:
188             stream->id = mpv_id++;
189             stream->max_buffer_size = 46 * 1024; 
190             s->video_bound++;
191             break;
192         default:
193             abort();
194         }
195     }
196
197     /* we increase slightly the bitrate to take into account the
198        headers. XXX: compute it exactly */
199     bitrate = 2000;
200     for(i=0;i<ctx->nb_streams;i++) {
201         st = ctx->streams[i];
202         bitrate += st->codec.bit_rate;
203     }
204     s->mux_rate = (bitrate + (8 * 50) - 1) / (8 * 50);
205     
206     if (ctx->flags & AVF_FLAG_VCD)
207         /* every packet */
208         s->pack_header_freq = 1;
209     else
210         /* every 2 seconds */
211         s->pack_header_freq = 2 * bitrate / s->packet_size / 8;
212     
213     if (ctx->flags & AVF_FLAG_VCD)
214         /* every 40 packets, this is my invention */
215         s->system_header_freq = s->pack_header_freq * 40;
216     else
217         /* every 10 seconds */
218         s->system_header_freq = s->pack_header_freq * 5;
219     
220     
221     for(i=0;i<ctx->nb_streams;i++) {
222         stream = ctx->streams[i]->priv_data;
223         stream->buffer_ptr = 0;
224         stream->packet_number = 0;
225         stream->pts = 0;
226         stream->start_pts = -1;
227
228         st = ctx->streams[i];
229         switch (st->codec.codec_type) {
230         case CODEC_TYPE_AUDIO:
231             ticker_init(&stream->pts_ticker,
232                         st->codec.sample_rate,
233                         90000 * st->codec.frame_size);
234             break;
235         case CODEC_TYPE_VIDEO:
236             ticker_init(&stream->pts_ticker,
237                         st->codec.frame_rate,
238                         90000 * FRAME_RATE_BASE);
239             break;
240         default:
241             abort();
242         }
243     }
244     return 0;
245  fail:
246     for(i=0;i<ctx->nb_streams;i++) {
247         av_free(ctx->streams[i]->priv_data);
248     }
249     return -ENOMEM;
250 }
251
252 /* flush the packet on stream stream_index */
253 static void flush_packet(AVFormatContext *ctx, int stream_index, int last_pkt)
254 {
255     MpegMuxContext *s = ctx->priv_data;
256     StreamInfo *stream = ctx->streams[stream_index]->priv_data;
257     UINT8 *buf_ptr;
258     int size, payload_size, startcode, id, len, stuffing_size, i;
259     INT64 timestamp;
260     UINT8 buffer[128];
261     int last = last_pkt ? 4 : 0;
262     
263     id = stream->id;
264     timestamp = stream->start_pts;
265
266 #if 0
267     printf("packet ID=%2x PTS=%0.3f\n", 
268            id, timestamp / 90000.0);
269 #endif
270
271     buf_ptr = buffer;
272     if (((s->packet_number % s->pack_header_freq) == 0)) {
273         /* output pack and systems header if needed */
274         size = put_pack_header(ctx, buf_ptr, timestamp);
275         buf_ptr += size;
276         if ((s->packet_number % s->system_header_freq) == 0) {
277             size = put_system_header(ctx, buf_ptr);
278             buf_ptr += size;
279         }
280     }
281     size = buf_ptr - buffer;
282     put_buffer(&ctx->pb, buffer, size);
283
284     /* packet header */
285     payload_size = s->packet_size - (size + 6 + 5 + last);
286     if (id < 0xc0) {
287         startcode = PRIVATE_STREAM_1;
288         payload_size -= 4;
289     } else {
290         startcode = 0x100 + id;
291     }
292     stuffing_size = payload_size - stream->buffer_ptr;
293     if (stuffing_size < 0)
294         stuffing_size = 0;
295
296     put_be32(&ctx->pb, startcode);
297
298     put_be16(&ctx->pb, payload_size + 5);
299     /* stuffing */
300     for(i=0;i<stuffing_size;i++)
301         put_byte(&ctx->pb, 0xff);
302     
303     /* presentation time stamp */
304     put_byte(&ctx->pb, 
305              (0x02 << 4) | 
306              (((timestamp >> 30) & 0x07) << 1) | 
307              1);
308     put_be16(&ctx->pb, (UINT16)((((timestamp >> 15) & 0x7fff) << 1) | 1));
309     put_be16(&ctx->pb, (UINT16)((((timestamp) & 0x7fff) << 1) | 1));
310
311     if (startcode == PRIVATE_STREAM_1) {
312         put_byte(&ctx->pb, id);
313         if (id >= 0x80 && id <= 0xbf) {
314             /* XXX: need to check AC3 spec */
315             put_byte(&ctx->pb, 1);
316             put_byte(&ctx->pb, 0);
317             put_byte(&ctx->pb, 2);
318         }
319     }
320
321     if (last_pkt) {
322         put_be32(&ctx->pb, ISO_11172_END_CODE);
323     }
324     /* output data */
325     put_buffer(&ctx->pb, stream->buffer, payload_size - stuffing_size);
326     put_flush_packet(&ctx->pb);
327     
328     /* preserve remaining data */
329     len = stream->buffer_ptr - payload_size;
330     if (len < 0) 
331         len = 0;
332     memmove(stream->buffer, stream->buffer + stream->buffer_ptr - len, len);
333     stream->buffer_ptr = len;
334
335     s->packet_number++;
336     stream->packet_number++;
337     stream->start_pts = -1;
338 }
339
340 static int mpeg_mux_write_packet(AVFormatContext *ctx, int stream_index,
341                                  UINT8 *buf, int size, int force_pts)
342 {
343     MpegMuxContext *s = ctx->priv_data;
344     AVStream *st = ctx->streams[stream_index];
345     StreamInfo *stream = st->priv_data;
346     int len;
347     
348     while (size > 0) {
349         /* set pts */
350         if (stream->start_pts == -1) {
351             if (force_pts)
352                 stream->pts = force_pts;
353             stream->start_pts = stream->pts;
354         }
355         len = s->packet_data_max_size - stream->buffer_ptr;
356         if (len > size)
357             len = size;
358         memcpy(stream->buffer + stream->buffer_ptr, buf, len);
359         stream->buffer_ptr += len;
360         buf += len;
361         size -= len;
362         while (stream->buffer_ptr >= s->packet_data_max_size) {
363             /* output the packet */
364             if (stream->start_pts == -1)
365                 stream->start_pts = stream->pts;
366             flush_packet(ctx, stream_index, 0);
367         }
368     }
369
370     stream->pts += ticker_tick(&stream->pts_ticker, 1);
371     //if (st->codec.codec_type == CODEC_TYPE_VIDEO)
372     //    fprintf(stderr,"\nVideo PTS: %6lld", stream->pts);
373     //else
374     //    fprintf(stderr,"\nAudio PTS: %6lld", stream->pts);
375     return 0;
376 }
377
378 static int mpeg_mux_end(AVFormatContext *ctx)
379 {
380     StreamInfo *stream;
381     int i;
382
383     /* flush each packet */
384     for(i=0;i<ctx->nb_streams;i++) {
385         stream = ctx->streams[i]->priv_data;
386         if (stream->buffer_ptr > 0) {
387             if (i == (ctx->nb_streams - 1)) 
388                 flush_packet(ctx, i, 1);
389             else
390                 flush_packet(ctx, i, 0);
391         }
392     }
393
394     /* write the end header */
395     //put_be32(&ctx->pb, ISO_11172_END_CODE);
396     //put_flush_packet(&ctx->pb);
397     return 0;
398 }
399
400 /*********************************************/
401 /* demux code */
402
403 #define MAX_SYNC_SIZE 100000
404
405 static int mpegps_probe(AVProbeData *p)
406 {
407     int code, c, i;
408     code = 0xff;
409
410     /* we search the first start code. If it is a packet start code,
411        then we decide it is mpeg ps. We do not send highest value to
412        give a chance to mpegts */
413     for(i=0;i<p->buf_size;i++) {
414         c = p->buf[i];
415         code = (code << 8) | c;
416         if ((code & 0xffffff00) == 0x100) {
417             if (code == PACK_START_CODE ||
418                 code == SYSTEM_HEADER_START_CODE ||
419                 (code >= 0x1e0 && code <= 0x1ef) ||
420                 (code >= 0x1c0 && code <= 0x1df) ||
421                 code == PRIVATE_STREAM_2 ||
422                 code == PROGRAM_STREAM_MAP ||
423                 code == PRIVATE_STREAM_1 ||
424                 code == PADDING_STREAM)
425                 return AVPROBE_SCORE_MAX - 1;
426             else
427                 return 0;
428         }
429     }
430     return 0;
431 }
432
433
434 typedef struct MpegDemuxContext {
435     int header_state;
436 } MpegDemuxContext;
437
438 static int find_start_code(ByteIOContext *pb, int *size_ptr, 
439                            UINT32 *header_state)
440 {
441     unsigned int state, v;
442     int val, n;
443
444     state = *header_state;
445     n = *size_ptr;
446     while (n > 0) {
447         if (url_feof(pb))
448             break;
449         v = get_byte(pb);
450         n--;
451         if (state == 0x000001) {
452             state = ((state << 8) | v) & 0xffffff;
453             val = state;
454             goto found;
455         }
456         state = ((state << 8) | v) & 0xffffff;
457     }
458     val = -1;
459  found:
460     *header_state = state;
461     *size_ptr = n;
462     return val;
463 }
464
465 static int mpegps_read_header(AVFormatContext *s,
466                                   AVFormatParameters *ap)
467 {
468     MpegDemuxContext *m = s->priv_data;
469     m->header_state = 0xff;
470     /* no need to do more */
471     return 0;
472 }
473
474 static INT64 get_pts(ByteIOContext *pb, int c)
475 {
476     INT64 pts;
477     int val;
478
479     if (c < 0)
480         c = get_byte(pb);
481     pts = (INT64)((c >> 1) & 0x07) << 30;
482     val = get_be16(pb);
483     pts |= (INT64)(val >> 1) << 15;
484     val = get_be16(pb);
485     pts |= (INT64)(val >> 1);
486     return pts;
487 }
488
489 static int mpegps_read_packet(AVFormatContext *s,
490                                   AVPacket *pkt)
491 {
492     MpegDemuxContext *m = s->priv_data;
493     AVStream *st;
494     int len, size, startcode, i, c, flags, header_len, type, codec_id;
495     INT64 pts, dts;
496
497     /* next start code (should be immediately after */
498  redo:
499     m->header_state = 0xff;
500     size = MAX_SYNC_SIZE;
501     startcode = find_start_code(&s->pb, &size, &m->header_state);
502     //printf("startcode=%x pos=0x%Lx\n", startcode, url_ftell(&s->pb));
503     if (startcode < 0)
504         return -EIO;
505     if (startcode == PACK_START_CODE)
506         goto redo;
507     if (startcode == SYSTEM_HEADER_START_CODE)
508         goto redo;
509     if (startcode == PADDING_STREAM ||
510         startcode == PRIVATE_STREAM_2) {
511         /* skip them */
512         len = get_be16(&s->pb);
513         url_fskip(&s->pb, len);
514         goto redo;
515     }
516     /* find matching stream */
517     if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
518           (startcode >= 0x1e0 && startcode <= 0x1ef) ||
519           (startcode == 0x1bd)))
520         goto redo;
521
522     len = get_be16(&s->pb);
523     pts = 0;
524     dts = 0;
525     /* stuffing */
526     for(;;) {
527         c = get_byte(&s->pb);
528         len--;
529         /* XXX: for mpeg1, should test only bit 7 */
530         if (c != 0xff) 
531             break;
532     }
533     if ((c & 0xc0) == 0x40) {
534         /* buffer scale & size */
535         get_byte(&s->pb);
536         c = get_byte(&s->pb);
537         len -= 2;
538     }
539     if ((c & 0xf0) == 0x20) {
540         pts = get_pts(&s->pb, c);
541         len -= 4;
542         dts = pts;
543     } else if ((c & 0xf0) == 0x30) {
544         pts = get_pts(&s->pb, c);
545         dts = get_pts(&s->pb, -1);
546         len -= 9;
547     } else if ((c & 0xc0) == 0x80) {
548         /* mpeg 2 PES */
549         if ((c & 0x30) != 0) {
550             fprintf(stderr, "Encrypted multiplex not handled\n");
551             return -EIO;
552         }
553         flags = get_byte(&s->pb);
554         header_len = get_byte(&s->pb);
555         len -= 2;
556         if (header_len > len)
557             goto redo;
558         if ((flags & 0xc0) == 0x40) {
559             pts = get_pts(&s->pb, -1);
560             dts = pts;
561             header_len -= 5;
562             len -= 5;
563         } if ((flags & 0xc0) == 0xc0) {
564             pts = get_pts(&s->pb, -1);
565             dts = get_pts(&s->pb, -1);
566             header_len -= 10;
567             len -= 10;
568         }
569         len -= header_len;
570         while (header_len > 0) {
571             get_byte(&s->pb);
572             header_len--;
573         }
574     }
575     if (startcode == 0x1bd) {
576         startcode = get_byte(&s->pb);
577         len--;
578         if (startcode >= 0x80 && startcode <= 0xbf) {
579             /* audio: skip header */
580             get_byte(&s->pb);
581             get_byte(&s->pb);
582             get_byte(&s->pb);
583             len -= 3;
584         }
585     }
586
587     /* now find stream */
588     for(i=0;i<s->nb_streams;i++) {
589         st = s->streams[i];
590         if (st->id == startcode)
591             goto found;
592     }
593     /* no stream found: add a new stream */
594     st = av_new_stream(s, startcode);
595     if (!st) 
596         goto skip;
597     if (startcode >= 0x1e0 && startcode <= 0x1ef) {
598         type = CODEC_TYPE_VIDEO;
599         codec_id = CODEC_ID_MPEG1VIDEO;
600     } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
601         type = CODEC_TYPE_AUDIO;
602         codec_id = CODEC_ID_MP2;
603     } else if (startcode >= 0x80 && startcode <= 0x9f) {
604         type = CODEC_TYPE_AUDIO;
605         codec_id = CODEC_ID_AC3;
606     } else {
607     skip:
608         /* skip packet */
609         url_fskip(&s->pb, len);
610         goto redo;
611     }
612     st->codec.codec_type = type;
613     st->codec.codec_id = codec_id;
614  found:
615     av_new_packet(pkt, len);
616     //printf("\nRead Packet ID: %x PTS: %f Size: %d", startcode,
617     //       (float)pts/90000, len);
618     get_buffer(&s->pb, pkt->data, pkt->size);
619     pkt->pts = pts;
620     pkt->stream_index = st->index;
621     return 0;
622 }
623
624 static int mpegps_read_close(AVFormatContext *s)
625 {
626     return 0;
627 }
628
629 static AVOutputFormat mpegps_mux = {
630     "mpeg",
631     "MPEG PS format",
632     "video/x-mpeg",
633     "mpg,mpeg,vob",
634     sizeof(MpegMuxContext),
635     CODEC_ID_MP2,
636     CODEC_ID_MPEG1VIDEO,
637     mpeg_mux_init,
638     mpeg_mux_write_packet,
639     mpeg_mux_end,
640 };
641
642 static AVInputFormat mpegps_demux = {
643     "mpeg",
644     "MPEG PS format",
645     sizeof(MpegDemuxContext),
646     mpegps_probe,
647     mpegps_read_header,
648     mpegps_read_packet,
649     mpegps_read_close,
650     flags: AVFMT_NOHEADER,
651 };
652
653 int mpegps_init(void)
654 {
655     av_register_output_format(&mpegps_mux);
656     av_register_input_format(&mpegps_demux);
657     return 0;
658 }