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