?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix vf_tcdump's compilation
[mplayer/kovensky.git] / libmpdemux / muxer_mpeg.c
blob00bb9d07920318b6273513c80a4f17dfb8f39dd2
1 /*
2 * This file is part of MPlayer.
3 *
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <inttypes.h>
22 #include <string.h>
23 #include <sys/types.h>
24
25 #include "config.h"
26 #include "mp_msg.h"
27
28 #include "aviheader.h"
29 #include "ms_hdr.h"
30
31 #include "stream/stream.h"
32 #include "muxer.h"
33 #include "demuxer.h"
34 #include "demux_ts.h"
35 #include "stheader.h"
36 #include "m_option.h"
37 #include "aac_hdr.h"
38 #include "mpeg_hdr.h"
39 #include "mp3_hdr.h"
40 #include "liba52/a52.h"
41
42 #define PACK_HEADER_START_CODE 0x01ba
43 #define SYSTEM_HEADER_START_CODE 0x01bb
44 #define PSM_START_CODE 0x01bc
45
46 #define PES_PRIVATE1 0x01bd
47 #define PES_PRIVATE2 0x01bf
48
49 #define MUX_MPEG1 1
50 #define MUX_MPEG2 2
51
52 #define VIDEO_MPEG1 0x10000001
53 #define VIDEO_MPEG2 0x10000002
54 #define AUDIO_MP2 0x50
55 #define AUDIO_MP3 0x55
56 #define AUDIO_A52 0x2000
57 #define AUDIO_LPCM 0x10001 /* only a placeholder at the moment */
58 #define AUDIO_AAC1 0x706D
59 //#define AUDIO_AAC2 (short) mmioFOURCC('m','p','4','a')
60 #define AUDIO_AAC2 0x504D
61
62 #define ASPECT_1_1 1
63 #define ASPECT_4_3 2
64 #define ASPECT_16_9 3
65 #define ASPECT_2_21_1 4
66
67 #define FRAMERATE_23976 1
68 #define FRAMERATE_24 2
69 #define FRAMERATE_25 3
70 #define FRAMERATE_2997 4
71 #define FRAMERATE_30 5
72 #define FRAMERATE_50 6
73 #define FRAMERATE_5994 7
74 #define FRAMERATE_60 8
75
76 static char ftypes[] = {'?', 'I', 'P', 'B'};
77 #define FTYPE(x) (ftypes[(x)])
78
79 static const char *framerates[] = {
80 "unchanged", "23.976", "24", "25", "29.97", "30", "50", "59.94", "60"
81 };
82
83 static const char *aspect_ratios[] = {
84 "unchanged", "1/1", "4/3", "16/9", "2.21/1"
85 };
86
87 static char *conf_mux = "mpeg2";
88 static uint16_t conf_packet_size = 0; //dvd
89 static uint32_t conf_muxrate = 0; //kb/s
90 static float conf_vaspect = 0;
91 static float conf_vframerate = 0;
92 static uint32_t conf_vwidth = 0, conf_vheight = 0, conf_panscan_width = 0, conf_panscan_height = 0;
93 static uint32_t conf_vbitrate = 0;
94 static int conf_init_vpts = 200, conf_init_apts = 200;
95 static int conf_ts_allframes = 0;
96 static int conf_init_adelay = 0, conf_init_vdelay = 0;
97 static int conf_abuf_size = 0;
98 static int conf_vbuf_size = 0;
99 static int conf_drop = 0;
100 static int conf_telecine = 0;
101 static int conf_interleaving2 = 0;
102 static float conf_telecine_src = 0;
103 static float conf_telecine_dest = 0;
104
105 enum FRAME_TYPE {
106 I_FRAME = 1,
107 P_FRAME = 2,
108 B_FRAME = 3
109 };
110
111 typedef struct {
112 uint8_t *buffer;
113 size_t size;
114 size_t alloc_size;
115 uint8_t type;
116 uint64_t pts, dts, idur;
117 uint32_t pos; //start offset for the frame
118 } mpeg_frame_t;
119
120 typedef struct {
121 uint8_t cnt; // how many entries we use
122 struct {
123 uint8_t id, type;
124 uint32_t bufsize;
125 uint32_t format;
126 } streams[50]; //16 video + 16 audio mpa + 16 audio private + bd/bf for dvd
127 } sys_info_t;
128
129 typedef struct {
130 uint8_t cnt; // how many entries we use
131 struct {
132 uint8_t id;
133 uint8_t type;
134 uint32_t format;
135 } streams[50]; //16 video + 16 audio mpa + 16 audio private + bd/bf for dvd
136 } psm_info_t;
137
138 typedef struct {
139 int size;
140 uint64_t dts;
141 } buffer_track_t;
142
143 typedef struct {
144 uint64_t dts, pts;
145 uint64_t frame_dts, frame_pts;
146 int len, stflen;
147 } pack_stats_t;
148
149 typedef struct {
150 int mux;
151 sys_info_t sys_info;
152 psm_info_t psm_info;
153 uint16_t packet_size;
154 int is_dvd, is_xvcd, is_xsvcd, is_genmpeg1, is_genmpeg2, rawpes, ts_allframes, has_video, has_audio;
155 int update_system_header, use_psm;
156 off_t headers_size, data_size;
157 uint64_t scr;
158 uint64_t delta_scr;
159 uint64_t last_psm_scr;
160 uint32_t muxrate;
161 uint8_t *buff;
162 uint32_t headers_cnt;
163 double init_adelay;
164 int drop;
165
166 //video patching parameters
167 uint8_t vaspect, vframerate;
168 uint16_t vwidth, vheight, panscan_width, panscan_height;
169 uint32_t vbitrate;
170 int patch_seq, patch_sde;
171 int psm_streams_cnt;
172
173 //2 million frames are enough
174 #define MAX_PATTERN_LENGTH 2000000
175 uint8_t bff_mask[MAX_PATTERN_LENGTH];
176 } muxer_priv_t;
177
178
179 typedef struct {
180 int has_pts, has_dts, pes_is_aligned, type, min_pes_hlen;
181 int delay_rff;
182 uint64_t pts, last_pts, last_dts, dts, size, frame_duration, delta_pts, nom_delta_pts, last_saved_pts;
183 uint32_t buffer_size;
184 double delta_clock, timer;
185 int drop_delayed_frames;
186 mpeg_frame_t *framebuf;
187 uint16_t framebuf_cnt;
188 uint16_t framebuf_used;
189 int32_t last_tr;
190 int max_tr;
191 uint8_t id, is_mpeg12, telecine;
192 uint64_t vframes;
193 int64_t display_frame;
194 mp_mpeg_header_t picture;
195 int max_buffer_size;
196 buffer_track_t *buffer_track;
197 int track_pos, track_len, track_bufsize; //pos and len control the array, bufsize is the size of the buffer
198 unsigned char *pack;
199 int pack_offset, pes_offset, pes_set, payload_offset;
200 int frames;
201 int last_frame_rest; //the rest of the previous frame
202 int is_ready;
203 int mpa_layer;
204 } muxer_headers_t;
205
206 #define PULLDOWN32 1
207 #define TELECINE_FILM2PAL 2
208 #define TELECINE_DGPULLDOWN 3
209
210 m_option_t mpegopts_conf[] = {
211 {"format", &(conf_mux), CONF_TYPE_STRING, M_OPT_GLOBAL, 0 ,0, NULL},
212 {"size", &(conf_packet_size), CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 0, 65535, NULL},
213 {"muxrate", &(conf_muxrate), CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 0, 12000000, NULL}, //12 Mb/s
214 {"vaspect", &(conf_vaspect), CONF_TYPE_FLOAT, M_OPT_GLOBAL, 0, 0, NULL},
215 {"vframerate", &(conf_vframerate), CONF_TYPE_FLOAT, M_OPT_GLOBAL, 0, 0, NULL},
216 {"vwidth", &(conf_vwidth), CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 1, 4095, NULL},
217 {"vheight", &(conf_vheight), CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 1, 4095, NULL},
218 {"vpswidth", &(conf_panscan_width), CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 1, 16383, NULL},
219 {"vpsheight", &(conf_panscan_height), CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 1, 16383, NULL},
220 {"vbitrate", &(conf_vbitrate), CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 1, 104857599, NULL},
221 {"vdelay", &conf_init_vdelay, CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 0, 32760, NULL},
222 {"adelay", &conf_init_adelay, CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 0, 32760, NULL},
223 {"vbuf_size", &conf_vbuf_size, CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 40, 1194, NULL},
224 {"abuf_size", &conf_abuf_size, CONF_TYPE_INT, M_OPT_GLOBAL|M_OPT_RANGE, 4, 64, NULL},
225 {"drop", &conf_drop, CONF_TYPE_FLAG, M_OPT_GLOBAL, 0, 1, NULL},
226 {"tsaf", &conf_ts_allframes, CONF_TYPE_FLAG, M_OPT_GLOBAL, 0, 1, NULL},
227 {"telecine", &conf_telecine, CONF_TYPE_FLAG, M_OPT_GLOBAL, 0, PULLDOWN32, NULL},
228 {"interleaving2", &conf_interleaving2, CONF_TYPE_FLAG, M_OPT_GLOBAL, 0, 1, NULL},
229 {"film2pal", &conf_telecine, CONF_TYPE_FLAG, M_OPT_GLOBAL, 0, TELECINE_FILM2PAL, NULL},
230 {"tele_src", &(conf_telecine_src), CONF_TYPE_FLOAT, M_OPT_GLOBAL, 0, 0, NULL},
231 {"tele_dest", &(conf_telecine_dest), CONF_TYPE_FLOAT, M_OPT_GLOBAL, 0, 0, NULL},
232 {NULL, NULL, 0, 0, 0, 0, NULL}
233 };
234
235 static void fix_audio_sys_header(muxer_priv_t *priv, uint8_t id, uint8_t newid, uint32_t size)
236 {
237 uint8_t i;
238
239 for(i = 0; i < priv->sys_info.cnt; i++)
240 {
241 if(priv->sys_info.streams[i].id == id)
242 {
243 priv->sys_info.streams[i].id = newid;
244 priv->sys_info.streams[i].type = 1;
245 priv->sys_info.streams[i].bufsize = size;
246 }
247 }
248 }
249
250 static inline int is_mpeg1(uint32_t x)
251 {
252 return
253 (x == 0x10000001) ||
254 (x == mmioFOURCC('m','p','g','1')) ||
255 (x == mmioFOURCC('M','P','G','1'));
256 }
257
258 static inline int is_mpeg2(uint32_t x)
259 {
260 return
261 (x == 0x10000002) ||
262 (x == mmioFOURCC('m','p','g','2')) ||
263 (x == mmioFOURCC('M','P','G','2')) ||
264 (x == mmioFOURCC('m','p','e','g')) ||
265 (x == mmioFOURCC('M','P','E','G'));
266 }
267
268 static inline int is_mpeg4(uint32_t x)
269 {
270 return
271 (x == 0x10000004) ||
272 (x == mmioFOURCC('d','i','v','x')) ||
273 (x == mmioFOURCC('D','I','V','X')) ||
274 (x == mmioFOURCC('x','v','i','d')) ||
275 (x == mmioFOURCC('X','V','I','D')) ||
276 (x == mmioFOURCC('X','v','i','D')) ||
277 (x == mmioFOURCC('x','v','i','x')) ||
278 (x == mmioFOURCC('X','V','I','X')) ||
279 (x == mmioFOURCC('m','p','4','v')) ||
280 (x == mmioFOURCC('M','P','4','V')) ||
281 (x == mmioFOURCC('F', 'M','P','4')) ||
282 (x == mmioFOURCC('f', 'm','p','4')) ||
283 (x == mmioFOURCC('D', 'X','5','0')) ||
284 (x == mmioFOURCC('d', 'x','5','0'));
285 }
286
287 //from unrarlib.c
288 static uint32_t CalcCRC32(uint8_t *buff, uint32_t size)
289 {
290 uint32_t i, j, CRCTab[256], crc;
291
292 for(i = 0;i < 256; i++)
293 {
294 for(crc = i, j = 0; j < 8; j++)
295 crc= (crc & 1) ? (crc >> 1)^0xEDB88320L : (crc >> 1);
296 CRCTab[i] = crc;
297 }
298
299
300 crc = 0xffffffff;
301 for(i = 0; i < size; i++)
302 crc = (crc << 8) ^ CRCTab[((crc >> 24) ^ buff[i]) & 0xff];
303
304 return crc;
305 }
306
307
308 static void add_to_psm(muxer_priv_t *priv, uint8_t id, uint32_t format)
309 {
310 uint8_t i;
311
312 i = priv->psm_info.cnt;
313 priv->psm_info.streams[i].id = id;
314 priv->psm_info.streams[i].format = format;
315
316 if(is_mpeg1(format))
317 priv->psm_info.streams[i].type = 0x01;
318 else if(is_mpeg2(format))
319 priv->psm_info.streams[i].type = 0x02;
320 else if(is_mpeg4(format))
321 priv->psm_info.streams[i].type = 0x10;
322 else if(format == AUDIO_MP2 || format == AUDIO_MP3)
323 priv->psm_info.streams[i].type = 0x03;
324 else if(format == AUDIO_AAC1 || format == AUDIO_AAC2)
325 priv->psm_info.streams[i].type = 0x0f;
326 else
327 priv->psm_info.streams[i].type = 0x81;
328
329 if(format == AUDIO_A52)
330 memcpy((char*) &(priv->psm_info.streams[i].format), "AC-3", 4);
331
332 priv->psm_info.cnt++;
333 }
334
335
336 static mpeg_frame_t *init_frames(uint16_t num, size_t size)
337 {
338 mpeg_frame_t *tmp;
339 uint16_t i;
340
341 tmp = calloc(num, sizeof(mpeg_frame_t));
342 if(tmp == NULL)
343 return NULL;
344
345 for(i=0; i < num; i++)
346 {
347 tmp[i].buffer = calloc(1, size);
348 if(tmp[i].buffer == NULL)
349 return NULL;
350 tmp[i].size = 0;
351 tmp[i].pos = 0;
352 tmp[i].alloc_size = size;
353 tmp[i].pts = 0;
354 }
355
356 return tmp;
357 }
358
359 static int add_frame(muxer_headers_t *spriv, uint64_t idur, uint8_t *ptr, int len, uint8_t pt, uint64_t dts, uint64_t pts);
360
361 static muxer_stream_t* mpegfile_new_stream(muxer_t *muxer,int type){
362 muxer_priv_t *priv = (muxer_priv_t*) muxer->priv;
363 muxer_stream_t *s;
364 muxer_headers_t *spriv;
365
366 if (!muxer) return NULL;
367 if(muxer->avih.dwStreams>=MUXER_MAX_STREAMS){
368 mp_msg(MSGT_MUXER, MSGL_ERR, "Too many streams! increase MUXER_MAX_STREAMS !\n");
369 return NULL;
370 }
371 switch (type) {
372 case MUXER_TYPE_VIDEO:
373 if (muxer->num_videos >= 16) {
374 mp_msg(MSGT_MUXER, MSGL_ERR, "MPEG files can't contain more than 16 video streams!\n");
375 return NULL;
376 }
377 break;
378 case MUXER_TYPE_AUDIO:
379 if (muxer->num_audios >= 16) {
380 mp_msg(MSGT_MUXER, MSGL_ERR, "MPEG files can't contain more than 16 audio streams!\n");
381 return NULL;
382 }
383 break;
384 default:
385 mp_msg(MSGT_MUXER, MSGL_ERR, "Unknown stream type!\n");
386 return NULL;
387 }
388 s = calloc(1, sizeof(muxer_stream_t));
389 if(!s) return NULL; // no mem!?
390 if (!(s->b_buffer = malloc(priv->packet_size)))
391 goto init_fail;
392 s->b_buffer_size = priv->packet_size;
393 s->b_buffer_ptr = 0;
394 s->b_buffer_len = 0;
395 s->priv = calloc(1, sizeof(muxer_headers_t));
396 if(s->priv == NULL)
397 goto init_fail;
398 spriv = (muxer_headers_t *) s->priv;
399 spriv->pack = malloc(priv->packet_size);
400 if(! spriv->pack)
401 goto init_fail;
402 spriv->buffer_track = calloc(1, 4096*sizeof(buffer_track_t));
403 if(!spriv->buffer_track)
404 goto init_fail;
405 spriv->track_pos = 0;
406 spriv->track_len = 4096;
407 muxer->streams[muxer->avih.dwStreams]=s;
408 s->type=type;
409 s->id=muxer->avih.dwStreams;
410 s->muxer=muxer;
411
412 if (type == MUXER_TYPE_VIDEO) {
413 spriv->type = 1;
414 spriv->last_pts = conf_init_vpts * 90 * 300;
415 if(conf_init_vdelay) {
416 spriv->last_dts += conf_init_vdelay * 90 * 300;
417 spriv->last_pts += conf_init_vdelay * 90 * 300;
418 }
419 spriv->id = 0xe0 + muxer->num_videos;
420 s->ckid = be2me_32 (0x100 + spriv->id);
421 if(priv->is_genmpeg1 || priv->is_genmpeg2) {
422 int v = (conf_vbuf_size ? conf_vbuf_size*1024 :
423 (s->h.dwSuggestedBufferSize ? s->h.dwSuggestedBufferSize : 46*1024));
424 int n = priv->sys_info.cnt;
425
426 priv->sys_info.streams[n].id = spriv->id;
427 priv->sys_info.streams[n].type = 1;
428 priv->sys_info.streams[n].bufsize = v;
429 priv->sys_info.cnt++;
430 }
431 muxer->num_videos++;
432 priv->has_video++;
433 s->h.fccType=streamtypeVIDEO;
434 if(!muxer->def_v) muxer->def_v=s;
435 spriv->framebuf_cnt = 30;
436 spriv->framebuf_used = 0;
437 spriv->framebuf = init_frames(spriv->framebuf_cnt, (size_t) 5000);
438 if(spriv->framebuf == NULL) {
439 mp_msg(MSGT_MUXER, MSGL_FATAL, "Couldn't allocate initial frames structure, abort!\n");
440 goto init_fail;
441 }
442 memset(&(spriv->picture), 0, sizeof(spriv->picture));
443 if(priv->is_xvcd)
444 spriv->min_pes_hlen = 18;
445 else if(priv->is_xsvcd)
446 spriv->min_pes_hlen = 22;
447 spriv->telecine = conf_telecine;
448 mp_msg (MSGT_MUXER, MSGL_DBG2, "Added video stream %d, ckid=%X\n", muxer->num_videos, s->ckid);
449 } else { // MUXER_TYPE_AUDIO
450 spriv->type = 0;
451 spriv->drop_delayed_frames = conf_drop;
452 spriv->last_pts = conf_init_apts * 90 * 300;
453 if(conf_init_adelay && ! spriv->drop_delayed_frames)
454 spriv->last_pts += conf_init_adelay * 90 * 300;
455 spriv->pts = spriv->last_pts;
456 spriv->id = 0xc0 + muxer->num_audios;
457 s->ckid = be2me_32 (0x100 + spriv->id);
458 if(priv->is_genmpeg1 || priv->is_genmpeg2) {
459 int a1 = (conf_abuf_size ? conf_abuf_size*1024 :
460 (s->h.dwSuggestedBufferSize ? s->h.dwSuggestedBufferSize : 4*1024));
461 int n = priv->sys_info.cnt;
462
463 priv->sys_info.streams[n].id = spriv->id;
464 priv->sys_info.streams[n].type = 0;
465 priv->sys_info.streams[n].bufsize = a1;
466 priv->sys_info.cnt++;
467 }
468 if(priv->is_xvcd)
469 spriv->min_pes_hlen = 13;
470 else if(priv->is_xsvcd)
471 spriv->min_pes_hlen = 17;
472
473 muxer->num_audios++;
474 priv->has_audio++;
475 s->h.fccType=streamtypeAUDIO;
476
477 spriv->framebuf_cnt = 30;
478 spriv->framebuf_used = 0;
479 spriv->framebuf = init_frames(spriv->framebuf_cnt, (size_t) 2048);
480 if(spriv->framebuf == NULL) {
481 mp_msg(MSGT_MUXER, MSGL_FATAL, "Couldn't allocate initial frames structure, abort!\n");
482 goto init_fail;
483 }
484
485 mp_msg (MSGT_MUXER, MSGL_DBG2, "Added audio stream %d, ckid=%X\n", s->id - muxer->num_videos + 1, s->ckid);
486 }
487 muxer->avih.dwStreams++;
488 return s;
489
490 init_fail:
491 if(s)
492 {
493 if(s->priv)
494 {
495 spriv = s->priv;
496 if(spriv->pack)
497 free(spriv->pack);
498 if(spriv->buffer_track)
499 free(spriv->buffer_track);
500 free(s->priv);
501 }
502 if(s->b_buffer)
503 free(s->b_buffer);
504 free(s);
505 }
506 return NULL;
507 }
508
509 static void write_mpeg_ts(unsigned char *b, uint64_t ts, uint8_t mod) {
510 ts /= 300;
511 b[0] = mod | ((ts >> 29) & 0xf) | 1;
512 b[1] = (ts >> 22) & 0xff;
513 b[2] = ((ts >> 14) & 0xff) | 1;
514 b[3] = (ts >> 7) & 0xff;
515 b[4] = ((ts << 1) & 0xff) | 1;
516 }
517
518
519 static void write_mpeg_rate(int type, unsigned char *b, unsigned int rate)
520 {
521 rate = ((rate*8)+399) / 400;
522
523 if(type == MUX_MPEG1)
524 {
525 b[0] = ((rate >> 15) & 0x7f) | 0x80;
526 b[1] = (rate >> 7) & 0xff;
527 b[2] = ((rate << 1) & 0xff) | 1;
528 }
529 else
530 {
531 b[0] = (rate >> 14);
532 b[1] = (rate >> 6) & 0xff;
533 b[2] = ((rate & 0x3f) << 2) | 0x03;
534 }
535 }
536
537
538 static void write_mpeg_std(unsigned char *b, unsigned int size, unsigned int type, uint8_t mod)
539 {
540 //type = 0:mpeg audio/128, 1:video and pes private streams (including ac3/dts/lpcm)/1024
541 if(type == 0) //audio
542 size = (size + 127) / 128;
543 else //video or other
544 size = ((size + 1023) / 1024);
545
546 if(! size)
547 size++;
548
549 b[0] = ((size >> 8) & 0x3f) | (type==1 ? 0x60 : 0x40) | mod;
550 b[1] = size & 0xff;
551 }
552
553 static void write_mpeg2_scr(unsigned char *b, uint64_t ts)
554 {
555 uint16_t t1, t2, t3, scr_ext;
556 scr_ext = ts % 300ULL;
557 ts /= 300ULL;
558 ts &= 0x1FFFFFFFFULL; //33 bits
559 t1 = (ts >> 30) & 0x7;
560 t2 = (ts >> 15) & 0x7fff;
561 t3 = ts & 0x7fff;
562
563 b[0] = (t1 << 3 ) | 0x44 | ((t2 >> 13) & 0x3);
564 b[1] = (t2 >> 5);
565 b[2] = (t2 & 0x1f) << 3 | 0x4 | ((t3 >> 13) & 0x3);
566 b[3] = (t3 >> 5);
567 b[4] = (t3 & 0x1f) << 3 | ((scr_ext >> 7) & 0x03) | 0x4;
568 b[5] = ((scr_ext << 1) & 0xFF) | 1;
569 }
570
571
572 static int write_mpeg_pack_header(muxer_t *muxer, char *buff)
573 {
574 int len;
575 muxer_priv_t *priv;
576
577 priv = (muxer_priv_t *) muxer->priv;
578 *(uint32_t *)buff = be2me_32(PACK_HEADER_START_CODE);
579 if(priv->mux==MUX_MPEG1)
580 {
581 write_mpeg_ts(&buff[4], priv->scr, 0x20); // 0010 and SCR
582 write_mpeg_rate(priv->mux, &buff[9], muxer->sysrate);
583 len = 12;
584 }
585 else
586 {
587 write_mpeg2_scr(&buff[4], priv->scr); // 0010 and SCR
588 write_mpeg_rate(priv->mux, &buff[10], muxer->sysrate);
589 buff[13] = 0xf8; //5 bits reserved + 3 set to 0 to indicate 0 stuffing bytes
590 len = 14;
591 }
592
593 return len;
594 }
595
596
597 static int write_mpeg_system_header(muxer_t *muxer, char *buff)
598 {
599 int len;
600 uint8_t i;
601 muxer_priv_t *priv;
602 priv = (muxer_priv_t *) muxer->priv;
603
604 len = 0;
605 *(uint32_t *)(&buff[len]) = be2me_32(SYSTEM_HEADER_START_CODE);
606 len += 4;
607 *(uint16_t *)(&buff[len]) = 0; //fake length, we'll fix it later
608 len += 2;
609 write_mpeg_rate(MUX_MPEG1, &buff[len], muxer->sysrate);
610 len += 3;
611
612 buff[len++] = 0x4 | (priv->is_xvcd ? 1 : 0); //1 audio stream bound, no fixed, CSPS only for xvcd
613 //stolen from libavformat
614 if(priv->is_xvcd || priv->is_dvd)
615 buff[len++] = 0xe1; //system_audio_lock, system_video_lock, marker, 1 video stream bound
616 else
617 buff[len++] = 0x21; //marker, 1 video stream bound
618
619 buff[len++] = ((priv->mux == MUX_MPEG1) ? 0xff : 0x7f); //in mpeg2 there's the packet rate restriction
620
621 for(i = 0; i < priv->sys_info.cnt; i++)
622 {
623 buff[len++] = priv->sys_info.streams[i].id;
624 write_mpeg_std(&buff[len], priv->sys_info.streams[i].bufsize, priv->sys_info.streams[i].type,
625 (priv->sys_info.streams[i].type == 1 ? 0xe0: 0xc0));
626 len += 2;
627 }
628
629 *(uint16_t *)(&buff[4]) = be2me_16(len - 6); // length field fixed
630
631 return len;
632 }
633
634 static int write_mpeg_psm(muxer_t *muxer, char *buff)
635 {
636 int len;
637 uint8_t i;
638 uint16_t dlen;
639 muxer_priv_t *priv;
640 priv = (muxer_priv_t *) muxer->priv;
641
642 len = 0;
643 *(uint32_t *)(&buff[len]) = be2me_32(PSM_START_CODE);
644 len += 4;
645 *(uint16_t *)(&buff[len]) = 0; //fake length, we'll fix it later
646 len += 2;
647 buff[len++] = 0xe0; //1 current, 2 bits reserved, 5 version 0
648 buff[len++] = 0xff; //7 reserved, 1 marker
649 buff[len] = buff[len+1] = 0; //length of the program descriptors (unused)
650 len += 2;
651 *(uint16_t *)(&buff[len]) = 0; //length of the es descriptors
652 len += 2;
653
654 dlen = 0;
655 for(i = 0; i < priv->psm_info.cnt; i++)
656 {
657 if(
658 (priv->psm_info.streams[i].id == 0xbd) ||
659 (priv->psm_info.streams[i].id >= 0xe0 && priv->psm_info.streams[i].id <= 0xef) ||
660 (priv->psm_info.streams[i].id >= 0xc0 && priv->psm_info.streams[i].id <= 0xcf)
661 )
662 {
663 buff[len++] = priv->psm_info.streams[i].type;
664 buff[len++] = priv->psm_info.streams[i].id;
665 buff[len++] = 0; //len of descriptor upper ...
666 buff[len++] = 0; //... lower
667
668 dlen += 4;
669 }
670 }
671 *(uint16_t *)(&buff[10]) = be2me_16(dlen); //length of the es descriptors
672
673 *(uint16_t *)(&buff[4]) = be2me_16(len - 6 + 4); // length field fixed, including size of CRC32
674
675 *(uint32_t *)(&buff[len]) = be2me_32(CalcCRC32(buff, len));
676
677 len += 4; //for crc
678
679 return len;
680 }
681
682 static int psm_is_late(muxer_priv_t *priv)
683 {
684 return !priv->data_size || (priv->scr >= priv->last_psm_scr + 27000000ULL);
685 }
686
687 static int write_mpeg_pes_header(muxer_headers_t *h, uint8_t *pes_id, uint8_t *buff, uint16_t plen, int stuffing_len, int mux_type)
688 {
689 int len;
690
691 len = 0;
692 memcpy(&buff[len], pes_id, 4);
693 len += 4;
694
695 buff[len] = buff[len+1] = 0; //fake len
696 len += 2;
697
698 if(mux_type == MUX_MPEG1)
699 {
700 if(stuffing_len > 0)
701 {
702 memset(&buff[len], 0xff, stuffing_len);
703 len += stuffing_len;
704 }
705
706 if(h->buffer_size > 0)
707 {
708 write_mpeg_std(&buff[len], h->buffer_size, h->type, 0x40); // 01 is pes1 format
709 len += 2;
710 }
711 }
712 else //MPEG2
713 {
714 buff[len] = (h->pes_is_aligned ? 0x84 : 0x80); //0x10...
715 len++;
716 buff[len] = ((h->buffer_size > 0) ? 1 : 0) | (h->pts ? (h->dts ? 0xC0 : 0x80) : 0); //pes extension + pts/dts flags
717 len++;
718 buff[len] = (h->pts ? (h->dts ? 10 : 5) : 0) + ((h->buffer_size > 0) ? 3 : 0) + stuffing_len;//pts + std + stuffing
719 len++;
720 }
721
722
723 if(h->pts)
724 {
725 write_mpeg_ts(&buff[len], h->pts, (h->dts ? 0x30 : 0x20)); // 001x and both PTS/DTS
726 len += 5;
727
728 if(h->dts)
729 {
730 write_mpeg_ts(&buff[len], h->dts, 0x10); // 0001 before DTS
731 len += 5;
732 }
733 }
734 else
735 {
736 if(mux_type == MUX_MPEG1)
737 {
738 buff[len] = 0x0f;
739 len += 1;
740 }
741 }
742
743
744 if(mux_type == MUX_MPEG2)
745 {
746 if(h->buffer_size > 0)
747 {
748 buff[len] = 0x1e; //std flag
749 len++;
750
751 write_mpeg_std(&buff[len], h->buffer_size, h->type, 0x40);
752 len += 2;
753 }
754
755 if(stuffing_len > 0)
756 {
757 memset(&buff[len], 0xff, stuffing_len);
758 len += stuffing_len;
759 }
760 }
761
762 *((uint16_t*) &buff[4]) = be2me_16(len + plen - 6); //fix pes packet size
763 return len;
764 }
765
766
767 static void write_pes_padding(uint8_t *buff, uint16_t len)
768 {
769 //6 header bytes + len-6 0xff chars
770 buff[0] = buff[1] = 0;
771 buff[2] = 1;
772 buff[3] = 0xbe;
773 *((uint16_t*) &buff[4]) = be2me_16(len - 6);
774 memset(&buff[6], 0xff, len - 6);
775 }
776
777
778 static int write_nav_pack(uint8_t *buff)
779 {
780 // concatenation of pes_private2 + 03d4 x 0 and pes_private2 + 03fa x 0
781 int len;
782
783 mp_msg(MSGT_MUXER, MSGL_DBG3, "NAV\n");
784 len = 0;
785 *(uint32_t *)(&buff[len]) = be2me_32(PES_PRIVATE2);
786 len += 4;
787 buff[len++] = 0x3;
788 buff[len++] = 0xd4;
789 memset(&buff[len], 0, 0x03d4);
790 len += 0x03d4;
791
792 *(uint32_t *)(&buff[len]) = be2me_32(PES_PRIVATE2);
793 len += 4;
794 buff[len++] = 0x3;
795 buff[len++] = 0xfa;
796 memset(&buff[len], 0, 0x03fa);
797 len += 0x03fa;
798
799 return len;
800 }
801
802 static unsigned int calc_psm_len(muxer_priv_t *priv)
803 {
804 return 16 + 4*(priv->psm_info.cnt);
805 }
806
807 static uint32_t calc_pes_hlen(int format, muxer_headers_t *h, muxer_priv_t *priv)
808 {
809 uint32_t len;
810
811 if(format == MUX_MPEG1)
812 len = 6;
813 else
814 len = 9;
815
816 if(h->pts)
817 {
818 len += 5;
819 if(h->dts)
820 len += 5;
821 }
822 else if(format == MUX_MPEG1)
823 len += 1;
824
825 if(h->buffer_size > 0)
826 {
827 if(format == MUX_MPEG2)
828 len += 3;
829 else
830 len += 2;
831 }
832
833 //len = max(h->min_pes_hlen, len);
834
835 return len;
836 }
837
838
839 static int write_mpeg_pack(muxer_t *muxer, muxer_stream_t *s, stream_t *stream, int isoend)
840 {
841 size_t tot, offset;
842 muxer_priv_t *priv;
843 unsigned char *buff;
844 int stuffing_len;
845
846 priv = (muxer_priv_t *) muxer->priv;
847 buff = priv->buff;
848
849 if(isoend)
850 {
851 offset = priv->packet_size - 4;
852 write_pes_padding(buff, offset);
853 buff[offset + 0] = buff[offset + 1] = 0;
854 buff[offset + 2] = 1;
855 buff[offset + 3] = 0xb9;
856
857 stream_write_buffer(stream, buff, priv->packet_size);
858 return 1;
859 }
860 else //FAKE DVD NAV PACK
861 {
862 offset = write_mpeg_pack_header(muxer, buff);
863 offset += write_mpeg_system_header(muxer, &buff[offset]);
864
865 //priv->update_system_header = 0;
866
867 if(priv->is_dvd)
868 offset += write_nav_pack(&buff[offset]);
869
870 stuffing_len = priv->packet_size - offset;
871 if(stuffing_len > 0)
872 {
873 //insert a PES padding packet
874 write_pes_padding(&buff[offset], stuffing_len);
875 offset += stuffing_len;
876 }
877
878 stream_write_buffer(stream, buff, offset);
879 priv->headers_size += offset;
880 tot = offset;
881 muxer->movi_end += tot;
882
883 return tot;
884 }
885 }
886
887 static void update_demux_bufsize(muxer_headers_t *spriv, uint64_t dts, int framelen, int type)
888 {
889 int dim = (spriv->track_len+16)*sizeof(buffer_track_t);
890
891 if(spriv->track_pos+1 >= spriv->track_len)
892 {
893 buffer_track_t *tmp = realloc(spriv->buffer_track, dim);
894 if(!tmp)
895 {
896 mp_msg(MSGT_MUXER, MSGL_ERR, "\r\nERROR, couldn't realloc %d bytes for tracking buffer\r\n", dim);
897 return;
898 }
899 spriv->buffer_track = tmp;
900 memset(&(spriv->buffer_track[spriv->track_pos+1]), 0, 16*sizeof(buffer_track_t));
901 spriv->track_len += 16;
902 }
903
904 spriv->buffer_track[spriv->track_pos].size = framelen;
905 spriv->buffer_track[spriv->track_pos].dts = dts; //must be dts
906
907 spriv->track_pos++;
908 }
909
910 static void fix_a52_headers(muxer_stream_t *s)
911 {
912 muxer_headers_t *spriv = s->priv;
913 int x = spriv->payload_offset;
914
915 spriv->pack[x+0] = 0x80;
916 spriv->pack[x+1] = spriv->frames;
917 if(spriv->frames)
918 {
919 spriv->pack[x+2] = ((spriv->last_frame_rest+1) >> 8) & 0xff; //256 * 0 ...
920 spriv->pack[x+3] = (spriv->last_frame_rest+1) & 0xff; // + 1 byte(s) to skip
921 }
922 else
923 spriv->pack[x+2] = spriv->pack[x+3] = 0;
924 }
925
926 static inline void remove_frames(muxer_headers_t *spriv, int n)
927 {
928 mpeg_frame_t tmp;
929 int i;
930
931 for(i = n; i < spriv->framebuf_used; i++)
932 {
933 tmp = spriv->framebuf[i - n];
934 spriv->framebuf[i - n] = spriv->framebuf[i];
935 spriv->framebuf[i] = tmp;
936 }
937 spriv->framebuf_used -= n;
938 }
939
940 static int calc_packet_len(muxer_stream_t *s, int psize, int finalize)
941 {
942 muxer_headers_t *spriv = s->priv;
943 int n, len, frpos, m;
944
945 n = len = 0;
946 frpos = spriv->framebuf[0].pos;
947 while(len < psize && n < spriv->framebuf_used)
948 {
949 if(!frpos && len>0 && s->type == MUXER_TYPE_VIDEO && spriv->framebuf[n].type==I_FRAME)
950 return len;
951 m = FFMIN(spriv->framebuf[n].size - frpos, psize - len);
952 len += m;
953 frpos += m;
954 if(frpos == spriv->framebuf[n].size)
955 {
956 frpos = 0;
957 n++;
958 }
959 }
960
961 if(len < psize && !finalize)
962 return 0;
963 return len;
964 }
965
966 static int find_packet_timestamps(muxer_priv_t *priv, muxer_stream_t *s, unsigned int start, uint64_t *dts, uint64_t *pts)
967 {
968 muxer_headers_t *spriv = s->priv;
969 int i, m, pes_hlen, ret, threshold;
970 uint64_t spts, sdts, dpts;
971
972 if(!spriv->framebuf_used)
973 return 0;
974
975 spts = spriv->pts;
976 sdts = spriv->dts;
977 spriv->dts = spriv->pts = 0;
978 ret = 0;
979 if(spriv->framebuf[0].pos == 0) // start of frame
980 i = 0;
981 else
982 {
983 pes_hlen = calc_pes_hlen(priv->mux, spriv, priv);
984
985 if(pes_hlen < spriv->min_pes_hlen)
986 pes_hlen = spriv->min_pes_hlen;
987
988 m = spriv->framebuf[0].size - spriv->framebuf[0].pos;
989
990 if(start + pes_hlen + m >= priv->packet_size) //spriv->pack_offset
991 i = -1; //this pack won't have a pts: no space available
992 else
993 {
994 if(spriv->framebuf_used < 2)
995 goto fail;
996
997 if(spriv->framebuf[1].pts == spriv->framebuf[1].dts)
998 threshold = 5;
999 else
1000 threshold = 10;
1001
1002 //headers+frame 0 < space available including timestamps
1003 if(start + pes_hlen + m < priv->packet_size - threshold)
1004 i = 1;
1005 else
1006 i = -1;
1007 }
1008 }
1009
1010 if(i > -1)
1011 {
1012 dpts = FFMAX(spriv->last_saved_pts, spriv->framebuf[i].pts) -
1013 FFMIN(spriv->last_saved_pts, spriv->framebuf[i].pts) +
1014 spriv->framebuf[0].idur;
1015
1016 if(s->type != MUXER_TYPE_VIDEO)
1017 ret = 1;
1018 else if((spriv->framebuf[i].type == I_FRAME || priv->ts_allframes || dpts >= 36000*300)) //0.4 seconds
1019 ret = 1;
1020
1021 if(ret)
1022 {
1023 *pts = spriv->framebuf[i].pts;
1024 *dts = spriv->framebuf[i].dts;
1025 if(*dts == *pts)
1026 *dts = 0;
1027 }
1028 }
1029
1030 fail:
1031 spriv->pts = spts;
1032 spriv->dts = sdts;
1033 return ret;
1034 }
1035
1036 static int get_packet_stats(muxer_priv_t *priv, muxer_stream_t *s, pack_stats_t *p, int finalize)
1037 {
1038 muxer_headers_t *spriv = s->priv;
1039 int len, len2, pack_hlen, pes_hlen, hlen, target, stflen, stuffing_len;
1040 uint64_t pts, dts;
1041
1042 spriv->pts = spriv->dts = 0;
1043 p->dts = p->pts = p->frame_pts = p->frame_dts = 0;
1044 p->len = 0;
1045
1046 if(priv->rawpes)
1047 pack_hlen = 0;
1048 else if(priv->mux == MUX_MPEG1)
1049 pack_hlen = 12;
1050 else
1051 pack_hlen = 14;
1052 if(priv->use_psm && psm_is_late(priv))
1053 pack_hlen += calc_psm_len(priv);
1054
1055 if(find_packet_timestamps(priv, s, pack_hlen, &dts, &pts))
1056 {
1057 p->pts = p->frame_pts = pts;
1058 p->dts = p->frame_dts = dts;
1059
1060 spriv->pts = pts;
1061 spriv->dts = dts;
1062 }
1063 pes_hlen = calc_pes_hlen(priv->mux, spriv, priv);
1064
1065 p->stflen = stflen = (spriv->min_pes_hlen > pes_hlen ? spriv->min_pes_hlen - pes_hlen : 0);
1066
1067 target = len = priv->packet_size - pack_hlen - pes_hlen - stflen; //max space available
1068 if(s->type == MUXER_TYPE_AUDIO && s->wf->wFormatTag == AUDIO_A52)
1069 hlen = 4;
1070 else
1071 hlen = 0;
1072
1073 len -= hlen;
1074 target -= hlen;
1075
1076 len2 = calc_packet_len(s, target, finalize);
1077 if(!len2 || (len2 < target && s->type == MUXER_TYPE_AUDIO && !finalize))
1078 {
1079 //p->len = 0;
1080 //p->dts = p->pts = 0;
1081 spriv->pts = spriv->dts = 0;
1082 //fprintf(stderr, "\r\nLEN2: %d, target: %d, type: %d\r\n", len2, target, s->type);
1083 return 0;
1084 }
1085
1086 len = len2;
1087 stuffing_len = 0;
1088 if(len < target)
1089 {
1090 if(s->type == MUXER_TYPE_VIDEO)
1091 {
1092 if(spriv->pts)
1093 target += 5;
1094 if(spriv->dts)
1095 target += 5;
1096 spriv->pts = spriv->dts = 0;
1097 p->pts = p->dts = 0;
1098 }
1099
1100 stuffing_len = target - len;
1101 if(stuffing_len > 0 && stuffing_len < 7)
1102 {
1103 if(stflen + stuffing_len > 16)
1104 {
1105 int x = 7 - stuffing_len;
1106 stflen -= x;
1107 stuffing_len += x;
1108 }
1109 else
1110 {
1111 stflen += stuffing_len;
1112 stuffing_len = 0;
1113 }
1114 }
1115 }
1116
1117 len += hlen;
1118
1119 p->len = len;
1120 p->stflen = stflen;
1121
1122 return p->len;
1123 }
1124
1125 static int fill_packet(muxer_t *muxer, muxer_stream_t *s, int finalize)
1126 {
1127 //try to fill a packet as much as possible
1128 //spriv->pack_offset is the start position initialized to 0
1129 //data is taken from spriv->framebuf
1130 //if audio and a52 insert the headers
1131 muxer_priv_t *priv = (muxer_priv_t *) muxer->priv;
1132 muxer_headers_t *spriv = (muxer_headers_t *) s->priv;
1133 int len, m, n, dvd_pack = 0;
1134 int write_psm = 0;
1135 mpeg_frame_t *frm;
1136 pack_stats_t p;
1137
1138 spriv->dts = spriv->pts = 0;
1139
1140 if(! spriv->framebuf_used)
1141 {
1142 spriv->pack_offset = 0;
1143 return 0;
1144 }
1145
1146 if(!spriv->pack_offset)
1147 {
1148 if(priv->rawpes)
1149 spriv->pack_offset = 0;
1150 else
1151 spriv->pack_offset = write_mpeg_pack_header(muxer, spriv->pack);
1152 if(priv->update_system_header && (priv->is_genmpeg1 || priv->is_genmpeg2))
1153 {
1154 spriv->pack_offset += write_mpeg_system_header(muxer, &spriv->pack[spriv->pack_offset]);
1155 priv->update_system_header = 0;
1156 }
1157
1158 if(priv->use_psm && psm_is_late(priv))
1159 {
1160 spriv->pack_offset += write_mpeg_psm(muxer, &spriv->pack[spriv->pack_offset]);
1161 write_psm = 1;
1162 }
1163
1164 spriv->pes_set = 0;
1165 spriv->pes_offset = spriv->pack_offset;
1166 spriv->payload_offset = 0;
1167 spriv->frames = 0;
1168 spriv->last_frame_rest = 0;
1169 }
1170
1171 if(!spriv->pes_set)
1172 {
1173 int bufsize = 0;
1174 //search the pts. yes if either it's video && (I-frame or priv->ts_allframes) && framebuf[i].pos == 0
1175 //or it's audio && framebuf[i].pos == 0
1176 //NB pts and dts can only be relative to the first frame beginning in this pack
1177 if((priv->is_xsvcd || priv->is_xvcd || priv->rawpes) && spriv->size == 0)
1178 {
1179 if(s->type == MUXER_TYPE_VIDEO)
1180 bufsize = (conf_vbuf_size ? conf_vbuf_size : (priv->is_xvcd ? 46 : 232));
1181 else
1182 bufsize = (conf_abuf_size ? conf_abuf_size : 4);
1183 spriv->buffer_size = bufsize*1024;
1184 }
1185
1186 if(priv->is_dvd && s->type == MUXER_TYPE_VIDEO
1187 && spriv->framebuf[0].type==I_FRAME && spriv->framebuf[0].pos==0)
1188 dvd_pack = 1;
1189
1190 if(! get_packet_stats(priv, s, &p, finalize))
1191 {
1192 spriv->pack_offset = 0;
1193 return 0;
1194 }
1195 spriv->dts = p.dts;
1196 spriv->pts = p.pts;
1197 if(spriv->pts)
1198 spriv->last_saved_pts = p.pts;
1199
1200 spriv->pack_offset += write_mpeg_pes_header(spriv, (uint8_t *) &s->ckid, &(spriv->pack[spriv->pack_offset]),
1201 p.len, p.stflen, priv->mux);
1202
1203 if(s->type == MUXER_TYPE_AUDIO && s->wf->wFormatTag == AUDIO_A52)
1204 {
1205 spriv->payload_offset = spriv->pack_offset;
1206 spriv->pack_offset += 4; //for the 4 bytes of header
1207 if(!spriv->framebuf[0].pos)
1208 spriv->last_frame_rest = 0;
1209 else
1210 spriv->last_frame_rest = spriv->framebuf[0].size - spriv->framebuf[0].pos;
1211 }
1212
1213 spriv->pes_set = 1;
1214 }
1215
1216
1217 if(spriv->dts || spriv->pts)
1218 {
1219 if((spriv->dts && priv->scr >= spriv->dts) || priv->scr >= spriv->pts)
1220 mp_msg(MSGT_MUXER, MSGL_ERR, "\r\nERROR: scr %.3f, dts %.3f, pts %.3f\r\n", (double) priv->scr/27000000.0, (double) spriv->dts/27000000.0, (double) spriv->pts/27000000.0);
1221 else if(priv->scr + 63000*300 < spriv->dts)
1222 mp_msg(MSGT_MUXER, MSGL_INFO, "\r\nWARNING>: scr %.3f, dts %.3f, pts %.3f, diff %.3f, piff %.3f\r\n", (double) priv->scr/27000000.0, (double) spriv->dts/27000000.0, (double) spriv->pts/27000000.0, (double)(spriv->dts - priv->scr)/27000000.0, (double)(spriv->pts - priv->scr)/27000000.0);
1223 }
1224
1225 n = 0;
1226 len = 0;
1227
1228 frm = spriv->framebuf;
1229 while(spriv->pack_offset < priv->packet_size && n < spriv->framebuf_used)
1230 {
1231 if(!frm->pos)
1232 {
1233 //since iframes must always be aligned at block boundaries exit when we find the
1234 //beginning of one in the middle of the flush
1235 if(len > 0 && s->type == MUXER_TYPE_VIDEO && frm->type == I_FRAME)
1236 {
1237 break;
1238 }
1239 spriv->frames++;
1240 update_demux_bufsize(spriv, frm->dts, frm->size, s->type);
1241 }
1242
1243 m = FFMIN(frm->size - frm->pos, priv->packet_size - spriv->pack_offset);
1244 memcpy(&(spriv->pack[spriv->pack_offset]), &(frm->buffer[frm->pos]), m);
1245
1246 len += m;
1247 spriv->pack_offset += m;
1248 frm->pos += m;
1249
1250 if(frm->pos == frm->size) //end of frame
1251 {
1252 frm->pos = frm->size = 0;
1253 frm->pts = frm->dts = 0;
1254 n++;
1255 frm++;
1256 }
1257 }
1258
1259 if((priv->is_xsvcd || priv->is_xvcd || priv->rawpes) && spriv->size == 0)
1260 spriv->buffer_size = 0;
1261
1262 spriv->size += len;
1263
1264 if(dvd_pack && (spriv->pack_offset == priv->packet_size))
1265 write_mpeg_pack(muxer, NULL, muxer->stream, 0); //insert fake Nav Packet
1266
1267 if(n > 0)
1268 remove_frames(spriv, n);
1269
1270 spriv->track_bufsize += len;
1271 if(spriv->track_bufsize > spriv->max_buffer_size)
1272 mp_msg(MSGT_MUXER, MSGL_ERR, "\r\nBUFFER OVERFLOW: %d > %d, pts: %"PRIu64"\r\n", spriv->track_bufsize, spriv->max_buffer_size, spriv->pts);
1273
1274 if(s->type == MUXER_TYPE_AUDIO && s->wf->wFormatTag == AUDIO_A52)
1275 fix_a52_headers(s);
1276
1277 if(spriv->pack_offset < priv->packet_size && !priv->rawpes) //here finalize is set
1278 {
1279 int diff = priv->packet_size - spriv->pack_offset;
1280 write_pes_padding(&(spriv->pack[spriv->pack_offset]), diff);
1281 spriv->pack_offset += diff;
1282 }
1283
1284 stream_write_buffer(muxer->stream, spriv->pack, spriv->pack_offset);
1285
1286 priv->headers_size += spriv->pack_offset - len;
1287 priv->data_size += len;
1288 muxer->movi_end += spriv->pack_offset;
1289
1290 spriv->pack_offset = 0;
1291 spriv->pes_set = 0;
1292 spriv->frames = 0;
1293 if(write_psm)
1294 priv->last_psm_scr = priv->scr;
1295
1296 return len;
1297 }
1298
1299 static inline int find_best_stream(muxer_t *muxer)
1300 {
1301 int i, ndts;
1302 uint64_t dts = -1;
1303 muxer_priv_t *priv = muxer->priv;
1304 muxer_headers_t *spriv;
1305 pack_stats_t p;
1306 unsigned int perc, sperc;
1307
1308 ndts = -1;
1309 perc = -1;
1310
1311 //THIS RULE MUST ALWAYS apply: dts <= SCR + 0.7 seconds
1312 for(i = 0; i < muxer->avih.dwStreams; i++)
1313 {
1314 spriv = muxer->streams[i]->priv;
1315
1316 p.len = 0;
1317 get_packet_stats(priv, muxer->streams[i], &p, 0);
1318
1319 if(spriv->track_bufsize + p.len > spriv->max_buffer_size)
1320 continue;
1321 if(p.frame_pts && p.frame_dts > priv->scr + 63000*300)
1322 continue;
1323
1324 if(spriv->framebuf[0].dts <= dts)
1325 {
1326 dts = spriv->framebuf[0].dts;
1327 ndts = i;
1328 }
1329
1330 if(conf_interleaving2)
1331 {
1332 sperc = (spriv->track_bufsize * 1024) / spriv->max_buffer_size;
1333 if(sperc < perc)
1334 {
1335 ndts = i;
1336 perc = sperc;
1337 }
1338 }
1339 }
1340
1341 return ndts;
1342 }
1343
1344 static void patch_seq(muxer_priv_t *priv, unsigned char *buf)
1345 {
1346 if(priv->vwidth > 0)
1347 {
1348 buf[4] = (priv->vwidth >> 4) & 0xff;
1349 buf[5] &= 0x0f;
1350 buf[5] |= (priv->vwidth & 0x0f) << 4;
1351 }
1352
1353 if(priv->vheight > 0)
1354 {
1355 buf[5] &= 0xf0;
1356 buf[5] |= (priv->vheight >> 8) & 0x0f;
1357 buf[6] = priv->vheight & 0xff;
1358 }
1359
1360 if(priv->vaspect > 0)
1361 buf[7] = (buf[7] & 0x0f) | (priv->vaspect << 4);
1362
1363 if(priv->vframerate > 0)
1364 buf[7] = (buf[7] & 0xf0) | priv->vframerate;
1365
1366 if(priv->vbitrate > 0)
1367 {
1368 buf[8] = (priv->vbitrate >> 10);
1369 buf[9] = (priv->vbitrate >> 2);
1370 buf[10] = (buf[10] & 0x3f) | (unsigned char) ((priv->vbitrate & 0x4) << 2);
1371 }
1372 }
1373
1374 static void patch_panscan(muxer_priv_t *priv, unsigned char *buf)
1375 { //patches sequence display extension (display_horizontal_size and display_vertical_size)
1376 //1:
1377 int offset = 1;
1378
1379 if(buf[0] & 0x01)
1380 offset += 3;
1381
1382 if(priv->panscan_width > 0)
1383 {
1384 buf[offset] = (priv->panscan_width >> 6);
1385 buf[offset+1] = ((priv->panscan_width & 0x3F) << 2) | (buf[offset + 1] & 0x03);
1386 }
1387
1388 offset++;
1389
1390 if(priv->panscan_height > 0)
1391 {
1392 buf[offset] = (priv->panscan_height >> 13) << 7;
1393 buf[offset+1] = (priv->panscan_height >> 5) & 0xFF;
1394 buf[offset+2] = ((priv->panscan_height & 0x1F) << 3) | (buf[offset+2] & 0x07);
1395 }
1396 }
1397
1398
1399 static void update_scr(muxer_t *muxer)
1400 {
1401 muxer_priv_t *priv = muxer->priv;
1402 muxer_stream_t *stream;
1403 muxer_headers_t *spriv;
1404 int i, j;
1405 uint64_t mindts = (uint64_t) -1;
1406
1407 priv->scr += priv->delta_scr;
1408
1409 for(i = 0; i < muxer->avih.dwStreams; i++)
1410 {
1411 stream = muxer->streams[i];
1412 spriv = stream->priv;
1413 if(spriv->framebuf_used && spriv->framebuf[0].dts < mindts)
1414 mindts = spriv->framebuf[0].dts;
1415 }
1416
1417 mp_msg(MSGT_MUXER, MSGL_DBG2, "UPDATE SCR TO %"PRIu64" (%.3f)\n", priv->scr, (double) (priv->scr/27000000.0));
1418
1419 for(i = 0; i < muxer->avih.dwStreams; i++)
1420 {
1421 stream = muxer->streams[i];
1422 spriv = stream->priv;
1423
1424 j = 0;
1425 while(j < spriv->track_pos && priv->scr >= spriv->buffer_track[j].dts)
1426 {
1427 spriv->track_bufsize -= spriv->buffer_track[j].size;
1428 j++;
1429 }
1430 if(spriv->track_bufsize < 0)
1431 {
1432 double d;
1433 muxer->sysrate = (muxer->sysrate * 11) / 10; //raise by 10%
1434 d = (double) priv->packet_size / (double)muxer->sysrate;
1435 priv->delta_scr = (uint64_t) (d * 27000000.0f);
1436 mp_msg(MSGT_MUXER, MSGL_INFO, "\r\nBUFFER UNDEFLOW at stream %d, raising muxrate to %d kb/s, delta_scr: %"PRIu64"\r\n", i, muxer->sysrate/125, priv->delta_scr);
1437 spriv->track_bufsize = 0;
1438 }
1439
1440 if(j > 0)
1441 {
1442 memmove(spriv->buffer_track, &(spriv->buffer_track[j]), (spriv->track_len - j) * sizeof(buffer_track_t));
1443 spriv->track_pos -= j;
1444 for(j = spriv->track_pos; j < spriv->track_len; j++)
1445 spriv->buffer_track[j].size = 0;
1446 }
1447
1448 if(spriv->framebuf_used && spriv->framebuf[0].dts < mindts)
1449 mindts = spriv->framebuf[0].dts;
1450 }
1451 }
1452
1453
1454 static int calc_frames_to_flush(muxer_headers_t *vpriv)
1455 {
1456 int n, found = 0;
1457
1458 if(vpriv->framebuf_used > 0)
1459 {
1460 n = 0;
1461 //let's count how many frames we'll store in the next pack sequence
1462 mp_msg(MSGT_MUXER, MSGL_DBG2, "\n");
1463 while(n < vpriv->framebuf_used)
1464 {
1465 mp_msg(MSGT_MUXER, MSGL_DBG2, "CALC_FRAMES, n=%d, type=%c, pts=%.3f\n", n, FTYPE(vpriv->framebuf[n].type), (double)vpriv->framebuf[n].pts/27000000.0f);
1466 if(n+1 < vpriv->framebuf_used)
1467 mp_msg(MSGT_MUXER, MSGL_DBG2, "n+1=%d, type=%c, pts=%.3f\n", n+1, FTYPE(vpriv->framebuf[n+1].type), (double)vpriv->framebuf[n+1].pts/27000000.0f);
1468
1469 if(vpriv->framebuf[n].type == I_FRAME)
1470 {
1471 if(n > 0)
1472 {
1473 found = 1;
1474 break;
1475 }
1476 }
1477
1478 n++;
1479 }
1480 }
1481
1482 if(found && (n < vpriv->framebuf_used+1))
1483 return n;
1484 else
1485 return 0;
1486 }
1487
1488 static int flush_buffers(muxer_t *muxer, int finalize)
1489 {
1490 int i, n, found;
1491 int skip_cnt;
1492 uint64_t init_delay = 0;
1493 muxer_stream_t *s, *vs, *as;
1494 muxer_headers_t *vpriv = NULL, *apriv = NULL;
1495 muxer_priv_t *priv = (muxer_priv_t *) muxer->priv;
1496 double duration;
1497 uint64_t iduration, iaduration;
1498
1499 /*
1500 analyzes all streams and decides what to flush
1501 trying to respect an interleaving distribution
1502 equal to the v_bitrate/a_bitrate proportion
1503 */
1504 n = 0;
1505 vs = as = NULL;
1506 found = 0;
1507 for(i = 0; i < muxer->avih.dwStreams; i++)
1508 {
1509 s = muxer->streams[i];
1510 if(s->type == MUXER_TYPE_VIDEO)
1511 {
1512 vs = muxer->streams[i];
1513 vpriv = (muxer_headers_t*) vs->priv;
1514 if(!vpriv->is_ready)
1515 return 0;
1516 n = found = calc_frames_to_flush(vpriv);
1517 }
1518 else if(s->type == MUXER_TYPE_AUDIO)
1519 as = s;
1520 }
1521
1522 if((! found) && finalize)
1523 {
1524 if(vpriv != NULL)
1525 found = n = vpriv->framebuf_used;
1526 }
1527
1528 if(found)
1529 {
1530 mp_msg(MSGT_MUXER, MSGL_DBG2, "\nVIDEO, FLUSH %d frames (of %d), 0 to %d\n", n, vpriv->framebuf_used, n-1);
1531
1532 vpriv = (muxer_headers_t*) vs->priv;
1533
1534 duration = 0;
1535 iduration = 0;
1536 for(i = 0; i < n; i++)
1537 iduration += vpriv->framebuf[i].idur;
1538 duration = (double) (iduration / 27000000.0);
1539
1540 if(as != NULL)
1541 {
1542 apriv = (muxer_headers_t*) as->priv;
1543 iaduration = 0;
1544 for(i = 0; i < apriv->framebuf_used; i++)
1545 {
1546 iaduration += apriv->framebuf[i].idur;
1547 }
1548 if(iaduration < iduration)
1549 {
1550 mp_msg(MSGT_MUXER, MSGL_DBG2, "Not enough audio data exit\n");
1551 return 0;
1552 }
1553 }
1554
1555 if(as != NULL && (apriv->size == 0))
1556 {
1557 init_delay = vpriv->framebuf[0].pts - vpriv->framebuf[0].dts;
1558
1559 for(i = 0; i < apriv->framebuf_cnt; i++)
1560 {
1561 apriv->framebuf[i].pts += init_delay;
1562 apriv->framebuf[i].dts += init_delay;
1563 }
1564 apriv->last_pts += init_delay;
1565 mp_msg(MSGT_MUXER, MSGL_DBG2, "\r\nINITIAL VIDEO DELAY: %.3f, currAPTS: %.3f\r\n", (double) init_delay/27000000.0f, (double) apriv->last_pts/27000000.0f);
1566 }
1567
1568 if((priv->is_xvcd || priv->is_xsvcd) && (vpriv->size == 0))
1569 vpriv->buffer_size = (conf_vbuf_size ? conf_vbuf_size : (priv->is_xvcd ? 46 : 230))*1024;
1570
1571 i = 0;
1572 skip_cnt = 0;
1573
1574 while(1)
1575 {
1576 update_scr(muxer);
1577 i = find_best_stream(muxer);
1578 if(i < 0)
1579 continue;
1580 if(!fill_packet(muxer, muxer->streams[i], finalize))
1581 skip_cnt++;
1582
1583 if(skip_cnt == muxer->avih.dwStreams)
1584 {
1585 found = 0;
1586 break;
1587 }
1588 }
1589 }
1590
1591 muxer->file_end = priv->scr;
1592 return found;
1593 }
1594
1595
1596 static inline uint64_t parse_fps(float fps)
1597 {
1598 // 90000 * 300 * 1001 / d , there's no rounding error with any of the admitted framerates
1599 int d = (int)(fps*1001+0.5);
1600
1601 return 27027000000ULL / d;
1602 }
1603
1604
1605 static int soft_telecine(muxer_priv_t *priv, muxer_headers_t *vpriv, uint8_t *fps_ptr, uint8_t *se_ptr, uint8_t *pce_ptr, int n)
1606 {
1607 if(! pce_ptr)
1608 return 0;
1609 if(fps_ptr != NULL)
1610 {
1611 *fps_ptr = (*fps_ptr & 0xf0) | priv->vframerate;
1612 vpriv->nom_delta_pts = parse_fps(conf_vframerate);
1613 }
1614
1615 //in pce_ptr starting from bit 0 bit 24 is tff, bit 30 is rff,
1616 if(pce_ptr[3] & 0x2)
1617 {
1618 mp_msg(MSGT_MUXER, MSGL_ERR, "\nERROR! RFF bit is already set, disabling telecining\n");
1619 vpriv->telecine = 0;
1620 return 0;
1621 }
1622
1623 vpriv->picture.progressive_sequence = 0;
1624 vpriv->picture.progressive_frame = 1;
1625 if(se_ptr)
1626 se_ptr[1] &= 0xf7;
1627
1628 //disable tff and rff and overwrite them with the value in bff_mask
1629 pce_ptr[3] = (pce_ptr[3] & 0x7d) | priv->bff_mask[vpriv->display_frame % MAX_PATTERN_LENGTH];
1630 pce_ptr[4] |= 0x80; //sets progressive frame
1631
1632 vpriv->display_frame += n;
1633 if(! vpriv->vframes)
1634 mp_msg(MSGT_MUXER, MSGL_INFO, "\nENABLED SOFT TELECINING, FPS=%.3f\n",conf_vframerate);
1635
1636 return 1;
1637 }
1638
1639 static size_t parse_mpeg12_video(muxer_stream_t *s, muxer_priv_t *priv, muxer_headers_t *spriv, float fps, size_t len)
1640 {
1641 uint8_t *fps_ptr = NULL; //pointer to the fps byte in the sequence header
1642 uint8_t *se_ptr = NULL; //pointer to sequence extension
1643 uint8_t *pce_ptr = NULL; //pointer to picture coding extension
1644 int frames_diff, d1, gop_reset = 0; //how any frames we advanced respect to the last one
1645 int ret;
1646 int i, err;
1647 uint32_t temp_ref;
1648 int pt;
1649
1650 mp_msg(MSGT_MUXER, MSGL_DBG2,"parse_mpeg12_video, len=%u\n", (uint32_t) len);
1651 if(s->buffer[0] != 0 || s->buffer[1] != 0 || s->buffer[2] != 1 || len<6)
1652 {
1653 mp_msg(MSGT_MUXER, MSGL_ERR,"Unknown video format, possibly non-MPEG1/2 stream, len=%d!\n", len);
1654 return 0;
1655 }
1656
1657 temp_ref = 0;
1658 pt = 0;
1659 err = 0;
1660 i = 0;
1661 while(i + 4 < len)
1662 { // Video (0) Sequence header (b3) or GOP (b8)
1663 if((s->buffer[i] == 0) && (s->buffer[i+1] == 0) && (s->buffer[i+2] == 1))
1664 {
1665 switch(s->buffer[i+3])
1666 {
1667 case 0xb3: //sequence
1668 {
1669 if(i + 11 > len)
1670 {
1671 err=1;
1672 break;
1673 }
1674 fps_ptr = &(s->buffer[i+7]);
1675 mp_header_process_sequence_header(&(spriv->picture), &(s->buffer[i+4]));
1676 spriv->delta_pts = spriv->nom_delta_pts = parse_fps(spriv->picture.fps);
1677
1678 spriv->delta_clock = (double) 1/fps;
1679 //the 2 lines below are needed to handle non-standard frame rates (such as 18)
1680 if(! spriv->delta_pts)
1681 spriv->delta_pts = spriv->nom_delta_pts = (uint64_t) ((double)27000000.0 * spriv->delta_clock );
1682 mp_msg(MSGT_MUXER, MSGL_DBG2, "\nFPS: %.3f, FRAMETIME: %.3f\n", fps, (double)1/fps);
1683 if(priv->patch_seq)
1684 patch_seq(priv, &(s->buffer[i]));
1685 }
1686 break;
1687
1688 case 0xb5:
1689 if(i + 9 > len)
1690 {
1691 err = 1;
1692 break;
1693 }
1694 mp_header_process_extension(&(spriv->picture), &(s->buffer[i+4]));
1695 if(((s->buffer[i+4] & 0xf0) == 0x10))
1696 se_ptr = &(s->buffer[i+4]);
1697 if(((s->buffer[i+4] & 0xf0) == 0x20))
1698 {
1699 if(priv->patch_sde)
1700 patch_panscan(priv, &(s->buffer[i+4]));
1701 }
1702 if((s->buffer[i+4] & 0xf0) == 0x80)
1703 {
1704 pce_ptr = &(s->buffer[i+4]);
1705 }
1706 break;
1707
1708 case 0xb8:
1709 gop_reset = 1;
1710 break;
1711
1712 case 0x00:
1713 if(i + 5 > len)
1714 {
1715 err = 1;
1716 break;
1717 }
1718 pt = (s->buffer[i+5] & 0x1c) >> 3;
1719 temp_ref = (s->buffer[i+4]<<2)+(s->buffer[i+5]>>6);
1720 break;
1721 }
1722 if(err) break; //something went wrong
1723 if(s->buffer[i+3] >= 0x01 && s->buffer[i+3] <= 0xAF) break; //slice, we have already analized what we need
1724 }
1725 i++;
1726 }
1727 if(err)
1728 mp_msg(MSGT_MUXER, MSGL_ERR,"Warning: picture too short or broken!\n");
1729
1730 //following 2 lines are workaround: lavf doesn't sync to sequence headers before passing demux_packets
1731 if(!spriv->nom_delta_pts)
1732 spriv->delta_pts = spriv->nom_delta_pts = parse_fps(fps);
1733 if(!spriv->vframes)
1734 spriv->last_tr = spriv->max_tr = temp_ref;
1735 d1 = temp_ref - spriv->last_tr;
1736 if(gop_reset)
1737 frames_diff = spriv->max_tr + 1 + temp_ref - spriv->last_tr;
1738 else
1739 {
1740 if(d1 < -6) //there's a wraparound
1741 frames_diff = spriv->max_tr + 1 + temp_ref - spriv->last_tr;
1742 else if(d1 > 6) //there's a wraparound
1743 frames_diff = spriv->max_tr + 1 + spriv->last_tr - temp_ref;
1744 else if(!d1) //pre-emptive fix against broken sequences
1745 frames_diff = 1;
1746 else
1747 frames_diff = d1;
1748 }
1749 mp_msg(MSGT_MUXER, MSGL_DBG2, "\nLAST: %d, TR: %d, GOP: %d, DIFF: %d, MAX: %d, d1: %d\n",
1750 spriv->last_tr, temp_ref, gop_reset, frames_diff, spriv->max_tr, d1);
1751
1752 if(temp_ref > spriv->max_tr || gop_reset)
1753 spriv->max_tr = temp_ref;
1754
1755 spriv->last_tr = temp_ref;
1756 if(spriv->picture.mpeg1 == 0)
1757 {
1758 if(spriv->telecine && pce_ptr)
1759 {
1760 soft_telecine(priv, spriv, fps_ptr, se_ptr, pce_ptr, frames_diff);
1761 spriv->picture.display_time = 100;
1762 mp_header_process_extension(&(spriv->picture), pce_ptr);
1763 if(spriv->picture.display_time >= 50 && spriv->picture.display_time <= 300)
1764 spriv->delta_pts = (spriv->nom_delta_pts * spriv->picture.display_time) / 100;
1765 }
1766 }
1767
1768 if(! spriv->vframes)
1769 frames_diff = 1;
1770
1771 spriv->last_dts += spriv->delta_pts;
1772 spriv->last_pts += spriv->nom_delta_pts*(frames_diff-1) + spriv->delta_pts;
1773
1774 ret = add_frame(spriv, spriv->delta_pts, s->buffer, len, pt, spriv->last_dts, spriv->last_pts);
1775 if(ret < 0)
1776 {
1777 mp_msg(MSGT_MUXER, MSGL_FATAL, "\r\nPARSE_MPEG12: add_frames(%d) failed, exit\r\n", len);
1778 return 0;
1779 }
1780 mp_msg(MSGT_MUXER, MSGL_DBG2, "\r\nVIDEO FRAME, PT: %C, tr: %d, diff: %d, dts: %.3f, pts: %.3f, pdt: %u, gop_reset: %d\r\n",
1781 ftypes[pt], temp_ref, frames_diff, ((double) spriv->last_dts/27000000.0f),
1782 ((double) spriv->last_pts/27000000.0f), spriv->picture.display_time, gop_reset);
1783
1784 if(pt == B_FRAME)
1785 {
1786 int j, n, adj = 0;
1787 int64_t diff = spriv->last_dts - spriv->last_pts;
1788
1789 if(diff != 0)
1790 {
1791 n = spriv->framebuf_used - 1;
1792
1793 for(j = n; j >= 0; j--)
1794 {
1795 if(spriv->framebuf[j].pts >= spriv->last_pts)
1796 {
1797 spriv->framebuf[j].pts += diff;
1798 adj++;
1799 }
1800 }
1801 mp_msg(MSGT_MUXER, MSGL_V, "\r\nResynced B-frame by %d units, DIFF: %"PRId64" (%.3f),[pd]ts=%.3f\r\n",
1802 n, diff, (double) diff/27000000.0f, (double) spriv->last_pts/27000000.0f);
1803 spriv->last_pts = spriv->last_dts;
1804 }
1805 }
1806 spriv->vframes++;
1807
1808 mp_msg(MSGT_MUXER, MSGL_DBG2,"parse_mpeg12_video, return %u\n", (uint32_t) len);
1809 return len;
1810 }
1811
1812
1813 static uint64_t fix_mp4_frame_duration(muxer_headers_t *vpriv)
1814 {
1815 uint64_t mn, md, mx, diff;
1816 uint32_t i;
1817
1818 mn = mx = vpriv->framebuf[0].pts;
1819 for(i = 0; i < 3; i++)
1820 {
1821 mp_msg(MSGT_DECVIDEO,MSGL_DBG2, "PTS: %"PRIu64"\n", vpriv->framebuf[i].pts);
1822 if(vpriv->framebuf[i].pts < mn)
1823 mn = vpriv->framebuf[i].pts;
1824 if(vpriv->framebuf[i].pts > mx)
1825 mx = vpriv->framebuf[i].pts;
1826 }
1827 md = mn;
1828 for(i=0; i<3; i++)
1829 {
1830 if((vpriv->framebuf[i].pts > mn) && (vpriv->framebuf[i].pts < mx))
1831 md = vpriv->framebuf[i].pts;
1832 }
1833
1834 if(mx - md > md - mn)
1835 diff = md - mn;
1836 else
1837 diff = mx - md;
1838
1839 mp_msg(MSGT_DECVIDEO,MSGL_DBG2, "MIN: %"PRIu64", mid: %"PRIu64", max: %"PRIu64", diff: %"PRIu64"\n", mn, md, mx, diff);
1840 if(diff > 0)
1841 {
1842 for(i=0; i<3; i++)
1843 {
1844 vpriv->framebuf[i].pts += diff;
1845 vpriv->framebuf[i].dts += i * diff;
1846 mp_msg(MSGT_MUXER, MSGL_DBG2, "FIXED_PTS: %.3f, FIXED_DTS: %.3f\n",
1847 (double) (vpriv->framebuf[i].pts/27000000.0), (double) (vpriv->framebuf[i].dts/27000000.0));
1848 }
1849 return diff;
1850 }
1851 else
1852 return 0;
1853 }
1854
1855
1856 static size_t parse_mpeg4_video(muxer_stream_t *s, muxer_priv_t *priv, muxer_headers_t *vpriv, float fps, size_t len)
1857 {
1858 size_t ptr = 0;
1859 int64_t delta_pts=0;
1860 uint8_t pt;
1861 int ret;
1862
1863 mp_msg(MSGT_MUXER, MSGL_DBG2,"parse_mpeg4_video, len=%u\n", (uint32_t) len);
1864 if(len<6)
1865 {
1866 mp_msg(MSGT_MUXER, MSGL_ERR,"Frame too short: %d, exit!\n", len);
1867 return 0;
1868 }
1869
1870 pt = 0;
1871 while(ptr < len - 5)
1872 {
1873 if(s->buffer[ptr] != 0 || s->buffer[ptr+1] != 0 || s->buffer[ptr+2] != 1)
1874 {
1875 ptr++;
1876 continue;
1877 }
1878
1879 if(s->buffer[ptr+3] >= 0x20 && s->buffer[ptr+3] <= 0x2f) //VOL
1880 {
1881 mp4_header_process_vol(&(vpriv->picture), &(s->buffer[ptr+4]));
1882 }
1883 else if(s->buffer[ptr+3] == 0xb3) //gov
1884 {
1885 //fprintf(stderr, "\nGOV\n");
1886 }
1887 else if(s->buffer[ptr+3] == 0xb6) //vop
1888 {
1889 int32_t delta;
1890 mp4_header_process_vop(&(vpriv->picture), &(s->buffer[ptr+4]));
1891
1892 delta = vpriv->picture.timeinc_unit - vpriv->last_tr;
1893 if((delta > 0) && (delta > (vpriv->picture.timeinc_resolution/2)))
1894 delta -= vpriv->picture.timeinc_resolution;
1895 else if((delta < 0) && (delta < (-(vpriv->picture.timeinc_resolution/2))))
1896 delta += vpriv->picture.timeinc_resolution;
1897
1898 delta_pts = (27000000 * (int64_t) delta) / vpriv->picture.timeinc_resolution;
1899 //warning, it seems that packed bops can lead to delta == 0
1900
1901 pt = vpriv->picture.picture_type + 1;
1902 mp_msg(MSGT_MUXER, MSGL_DBG2, "\nTYPE: %c, RESOLUTION: %d, TEMP: %d, delta: %d, delta_pts: %"PRId64" = %.3f, delta2: %.3f\n",
1903 FTYPE(pt), vpriv->picture.timeinc_resolution, vpriv->picture.timeinc_unit, delta, delta_pts, (double) (delta_pts/27000000.0),
1904 (double) delta / (double) vpriv->picture.timeinc_resolution);
1905
1906 vpriv->last_tr = vpriv->picture.timeinc_unit;
1907
1908 break;
1909 }
1910
1911 ptr++;
1912 }
1913
1914 if(vpriv->vframes)
1915 {
1916 vpriv->last_dts += vpriv->frame_duration;
1917 vpriv->last_pts += delta_pts;
1918 }
1919
1920 ret = add_frame(vpriv, delta_pts, s->buffer, len, pt, vpriv->last_dts, vpriv->last_pts);
1921 if(ret < 0)
1922 {
1923 mp_msg(MSGT_MUXER, MSGL_FATAL, "\r\nPARSE_MPEG4: add_frames(%d) failed, exit\r\n", len);
1924 return 0;
1925 }
1926
1927 if(!vpriv->frame_duration && vpriv->framebuf_used == 3)
1928 {
1929 vpriv->frame_duration = fix_mp4_frame_duration(vpriv);
1930 if(vpriv->frame_duration)
1931 {
1932 vpriv->last_pts += vpriv->frame_duration;
1933 vpriv->last_dts = vpriv->framebuf[vpriv->framebuf_used-1].dts;
1934 vpriv->delta_clock = ((double) vpriv->frame_duration)/27000000.0;
1935 mp_msg(MSGT_MUXER, MSGL_INFO, "FRAME DURATION: %"PRIu64" %.3f\n",
1936 vpriv->frame_duration, (double) (vpriv->frame_duration/27000000.0));
1937 vpriv->is_ready = 1;
1938 }
1939 }
1940
1941 mp_msg(MSGT_MUXER, MSGL_DBG2, "LAST_PTS: %.3f, LAST_DTS: %.3f\n",
1942 (double) (vpriv->last_pts/27000000.0), (double) (vpriv->last_dts/27000000.0));
1943
1944 vpriv->vframes++;
1945
1946 return len;
1947 }
1948
1949
1950 static int fill_last_frame(muxer_headers_t *spriv, uint8_t *ptr, int len)
1951 {
1952 int idx;
1953
1954 if(!len)
1955 return 0;
1956
1957 if(spriv->framebuf_used == 0)
1958 idx = spriv->framebuf_used;
1959 else
1960 idx = spriv->framebuf_used - 1;
1961
1962 if(spriv->framebuf[idx].alloc_size < spriv->framebuf[idx].size + len)
1963 {
1964 if(spriv->framebuf[idx].size > SIZE_MAX - (size_t)len)
1965 return 0;
1966 spriv->framebuf[idx].buffer = realloc(spriv->framebuf[idx].buffer, spriv->framebuf[idx].size + len);
1967 if(! spriv->framebuf[idx].buffer)
1968 return 0;
1969 spriv->framebuf[idx].alloc_size = spriv->framebuf[idx].size + len;
1970 }
1971
1972 memcpy(&(spriv->framebuf[idx].buffer[spriv->framebuf[idx].size]), ptr, len);
1973 spriv->framebuf[idx].size += len;
1974
1975 return len;
1976 }
1977
1978 static int add_frame(muxer_headers_t *spriv, uint64_t idur, uint8_t *ptr, int len, uint8_t pt, uint64_t dts, uint64_t pts)
1979 {
1980 int idx;
1981
1982 idx = spriv->framebuf_used;
1983 if(idx >= spriv->framebuf_cnt)
1984 {
1985 spriv->framebuf = realloc_struct(spriv->framebuf, (spriv->framebuf_cnt+1), sizeof(mpeg_frame_t));
1986 if(spriv->framebuf == NULL)
1987 {
1988 mp_msg(MSGT_MUXER, MSGL_FATAL, "Couldn't realloc frame buffer(idx), abort\n");
1989 return -1;
1990 }
1991
1992 spriv->framebuf[spriv->framebuf_cnt].size = 0;
1993 spriv->framebuf[spriv->framebuf_cnt].alloc_size = 0;
1994 spriv->framebuf[spriv->framebuf_cnt].pos = 0;
1995
1996 spriv->framebuf[spriv->framebuf_cnt].buffer = malloc(len);
1997 if(spriv->framebuf[spriv->framebuf_cnt].buffer == NULL)
1998 {
1999 mp_msg(MSGT_MUXER, MSGL_FATAL, "Couldn't realloc frame buffer(frame), abort\n");
2000 return -1;
2001 }
2002 spriv->framebuf[spriv->framebuf_cnt].alloc_size = len;
2003 spriv->framebuf_cnt++;
2004 }
2005
2006 if(spriv->framebuf[idx].alloc_size < spriv->framebuf[idx].size + len)
2007 {
2008 if(spriv->framebuf[idx].size > SIZE_MAX - (size_t)len)
2009 {
2010 mp_msg(MSGT_MUXER, MSGL_FATAL, "Size overflow, couldn't realloc frame buffer(frame), abort\n");
2011 return -1;
2012 }
2013 spriv->framebuf[idx].buffer = realloc(spriv->framebuf[idx].buffer, spriv->framebuf[idx].size + len);
2014 if(spriv->framebuf[idx].buffer == NULL)
2015 {
2016 mp_msg(MSGT_MUXER, MSGL_FATAL, "Couldn't realloc frame buffer(frame), abort\n");
2017 return -1;
2018 }
2019 spriv->framebuf[idx].alloc_size = spriv->framebuf[idx].size + len;
2020 }
2021
2022 memcpy(&(spriv->framebuf[idx].buffer[spriv->framebuf[idx].size]), ptr, len);
2023 spriv->framebuf[idx].size += len;
2024 spriv->framebuf[idx].pos = 0;
2025 spriv->framebuf[idx].type = pt;
2026
2027 spriv->framebuf[idx].idur = idur;
2028 spriv->framebuf[idx].dts = dts;
2029 spriv->framebuf[idx].pts = pts;
2030 spriv->framebuf_used++;
2031 mp_msg(MSGT_MUXER, MSGL_DBG2, "\r\nAdded frame, size: %u, idur: %"PRIu64", dts: %"PRIu64", pts: %"PRIu64", used: %u\r\n", len, idur, dts, pts, spriv->framebuf_used);
2032
2033 return idx;
2034 }
2035
2036 static int analyze_mpa(muxer_stream_t *s)
2037 {
2038 int i = 0, len, max, chans, srate, spf, layer;
2039 int score[4] = {0, 0, 0, 0};
2040
2041 while(i < s->b_buffer_len + 3)
2042 {
2043 if(s->b_buffer[i] == 0xFF && ((s->b_buffer[i+1] & 0xE0) == 0xE0))
2044 {
2045 len = mp_get_mp3_header(&(s->b_buffer[i]), &chans, &srate, &spf, &layer, NULL);
2046 if(len > 0 && (srate == s->wf->nSamplesPerSec) && (i + len <= s->b_buffer_len))
2047 {
2048 score[layer]++;
2049 i += len;
2050 }
2051 }
2052 i++;
2053 }
2054
2055 max = 0;
2056 layer = 2;
2057 for(i = 1; i <= 3; i++)
2058 {
2059 if(score[i] >= max)
2060 {
2061 max = score[i];
2062 layer = i;
2063 }
2064 }
2065
2066 return layer; //actual layer with the highest score
2067 }
2068
2069 static int parse_audio(muxer_stream_t *s, int finalize, unsigned int *nf, double *timer, double delay, int drop)
2070 {
2071 int i, j, len, chans, srate, spf, layer, dummy, tot, num, frm_idx;
2072 int finished;
2073 unsigned int frames;
2074 uint64_t idur;
2075 double dur;
2076 muxer_headers_t *spriv = (muxer_headers_t *) s->priv;
2077
2078 i = tot = frames = 0;
2079 finished = 0;
2080 while(1)
2081 {
2082 len = 0;
2083 switch(s->wf->wFormatTag)
2084 {
2085 case AUDIO_MP2:
2086 case AUDIO_MP3:
2087 {
2088 if(i + 3 >= s->b_buffer_len)
2089 {
2090 finished = 1;
2091 break;
2092 }
2093
2094 if(s->b_buffer[i] == 0xFF && ((s->b_buffer[i+1] & 0xE0) == 0xE0))
2095 {
2096 len = mp_get_mp3_header(&(s->b_buffer[i]), &chans, &srate, &spf, &layer, NULL);
2097 if(len > 0 && (srate == s->wf->nSamplesPerSec) && (i + len <= s->b_buffer_len)
2098 && layer == spriv->mpa_layer)
2099 {
2100 dur = (double) spf / (double) srate;
2101 idur = (27000000ULL * spf) / srate;
2102 }
2103 else
2104 len = 0;
2105 }
2106 }
2107 break;
2108
2109 case AUDIO_A52:
2110 {
2111 if(i + 6 >= s->b_buffer_len)
2112 {
2113 finished = 1;
2114 break;
2115 }
2116
2117 if(s->b_buffer[i] == 0x0B && s->b_buffer[i+1] == 0x77)
2118 {
2119 srate = 0;
2120 #ifdef CONFIG_LIBA52
2121 len = a52_syncinfo(&(s->b_buffer[i]), &dummy, &srate, &dummy);
2122 #else
2123 len = mp_a52_framesize(&(s->b_buffer[i]), &srate);
2124 #endif
2125 if((len > 0) && (srate == s->wf->nSamplesPerSec) && (i + len <= s->b_buffer_len))
2126 {
2127 dur = (double) 1536 / (double) srate;
2128 idur = (27000000ULL * 1536) / srate;
2129 }
2130 else
2131 len = 0;
2132 }
2133 }
2134 break;
2135
2136 case AUDIO_AAC1:
2137 case AUDIO_AAC2:
2138 {
2139 if(i + 7 >= s->b_buffer_len)
2140 {
2141 finished = 1;
2142 break;
2143 }
2144
2145 if(s->b_buffer[i] == 0xFF && ((s->b_buffer[i+1] & 0xF6) == 0xF0))
2146 {
2147 len = aac_parse_frame(&(s->b_buffer[i]), &srate, &num);
2148 if((len > 0) && (srate == s->wf->nSamplesPerSec) && (i + len <= s->b_buffer_len))
2149 {
2150 dur = (double) 1024 / (double) srate;
2151 idur = (27000000ULL * 1024 * num) / srate;
2152 }
2153 else
2154 len = 0;
2155 }
2156 }
2157 }
2158
2159 if(finished)
2160 break;
2161
2162 if(!len)
2163 {
2164 i++;
2165 continue;
2166 }
2167
2168 spriv->timer += dur;
2169 if(spriv->drop_delayed_frames && delay < 0 && spriv->timer <= -delay)
2170 {
2171 i += len;
2172 tot = i;
2173 continue;
2174 }
2175
2176 frames++;
2177 fill_last_frame(spriv, &(s->b_buffer[tot]), i - tot);
2178 frm_idx = add_frame(spriv, idur, &(s->b_buffer[i]), len, 0, spriv->last_pts, spriv->last_pts);
2179 if(frm_idx < 0)
2180 {
2181 mp_msg(MSGT_MUXER, MSGL_FATAL, "Couldn't add audio frame buffer(frame), abort\n");
2182 goto audio_exit;
2183 }
2184 for(j = frm_idx; j < spriv->framebuf_cnt; j++)
2185 spriv->framebuf[j].pts = spriv->last_pts;
2186 spriv->last_pts += idur;
2187
2188 i += len;
2189 tot = i;
2190 }
2191
2192 audio_exit:
2193 if(tot)
2194 {
2195 memmove(s->b_buffer, &(s->b_buffer[tot]), s->b_buffer_len - tot);
2196 s->b_buffer_len -= tot;
2197 s->b_buffer_ptr += tot;
2198 if(s->b_buffer_len > 0)
2199 memmove(s->b_buffer, &(s->b_buffer[s->b_buffer_ptr]), s->b_buffer_len);
2200 s->b_buffer_ptr = 0;
2201 }
2202
2203 if(finalize)
2204 {
2205 frm_idx = add_frame(spriv, 0, s->b_buffer, s->b_buffer_len, 0, spriv->last_pts, spriv->last_pts);
2206 if(frm_idx >= 0)
2207 {
2208 for(j = frm_idx; j < spriv->framebuf_cnt; j++)
2209 spriv->framebuf[j].pts = spriv->last_pts;
2210 }
2211 }
2212
2213 *nf = frames;
2214 *timer = spriv->timer;
2215
2216 return tot;
2217 }
2218
2219 static void fix_parameters(muxer_stream_t *stream)
2220 {
2221 muxer_headers_t *spriv = stream->priv;
2222 muxer_t *muxer = stream->muxer;
2223 muxer_priv_t *priv = muxer->priv;
2224 uint32_t stream_format;
2225 int needs_psm = 0;
2226
2227 if(stream->type == MUXER_TYPE_AUDIO)
2228 {
2229 stream_format = stream->wf->wFormatTag;
2230 spriv->is_ready = 1;
2231 if(conf_abuf_size)
2232 spriv->max_buffer_size = conf_abuf_size*1024;
2233 else
2234 spriv->max_buffer_size = 4*1024;
2235 if(stream->wf->wFormatTag == AUDIO_A52)
2236 {
2237 stream->ckid = be2me_32 (0x1bd);
2238 if(priv->is_genmpeg1 || priv->is_genmpeg2)
2239 fix_audio_sys_header(priv, spriv->id, 0xbd, FFMAX(conf_abuf_size, 58)*1024); //only one audio at the moment
2240 spriv->id = 0xbd;
2241 if(!conf_abuf_size)
2242 spriv->max_buffer_size = 16*1024;
2243 }
2244 else if(stream->wf->wFormatTag == AUDIO_AAC1 || stream->wf->wFormatTag == AUDIO_AAC2)
2245 needs_psm = 1;
2246 else if(stream->wf->wFormatTag == AUDIO_MP2 || stream->wf->wFormatTag == AUDIO_MP3)
2247 spriv->is_ready = 0;
2248 }
2249 else //video
2250 {
2251 stream_format = stream->bih->biCompression;
2252 if(conf_vbuf_size)
2253 spriv->max_buffer_size = conf_vbuf_size*1024;
2254 else
2255 {
2256 if(priv->is_dvd)
2257 spriv->max_buffer_size = 232*1024;
2258 else if(priv->is_xsvcd)
2259 spriv->max_buffer_size = 230*1024;
2260 else if(priv->is_xvcd)
2261 spriv->max_buffer_size = 46*1024;
2262 else
2263 spriv->max_buffer_size = 232*1024; //no profile => unconstrained :) FIXME!!!
2264 }
2265
2266 if(is_mpeg4(stream->bih->biCompression))
2267 spriv->is_ready = 0;
2268 else
2269 spriv->is_ready = 1;
2270
2271 if(!is_mpeg1(stream_format) && !is_mpeg2(stream_format))
2272 needs_psm = 1;
2273 }
2274
2275 if(priv->is_genmpeg2 && needs_psm)
2276 {
2277 priv->use_psm = 1;
2278 add_to_psm(priv, spriv->id, stream_format);
2279 priv->psm_streams_cnt++;
2280 }
2281 }
2282
2283
2284 static void mpegfile_write_chunk(muxer_stream_t *s,size_t len,unsigned int flags, double dts_arg, double pts_arg)
2285 {
2286 size_t sz = 0;
2287 uint64_t tmp;
2288 muxer_t *muxer = s->muxer;
2289 muxer_priv_t *priv = (muxer_priv_t *)muxer->priv;
2290 muxer_headers_t *spriv = (muxer_headers_t*) s->priv;
2291 float fps;
2292 uint32_t stream_format, nf;
2293
2294 if(s->buffer == NULL || len == -1)
2295 return;
2296
2297 if (s->type == MUXER_TYPE_VIDEO)
2298 { // try to recognize frame type...
2299 fps = (float) s->h.dwRate/ (float) s->h.dwScale;
2300 spriv->type = 1;
2301 stream_format = s->bih->biCompression;
2302 if(! spriv->vframes)
2303 {
2304 spriv->last_dts = spriv->last_pts - (uint64_t)(27000000.0f/fps);
2305 mp_msg(MSGT_MUXER, MSGL_INFO,"INITV: %.3f, %.3f, fps: %.3f\r\n", (double) spriv->last_pts/27000000.0f, (double) spriv->last_dts/27000000.0f, fps);
2306 }
2307
2308 if(is_mpeg1(stream_format) || is_mpeg2(stream_format))
2309 {
2310 spriv->is_mpeg12 = 1;
2311 spriv->is_ready = 1;
2312 if(len)
2313 sz = parse_mpeg12_video(s, priv, spriv, fps, len);
2314 else
2315 {
2316 tmp = (uint64_t) (27000000.0f / fps);
2317 spriv->last_pts += tmp;
2318 spriv->last_dts += tmp;
2319 }
2320 }
2321 else if(is_mpeg4(stream_format))
2322 {
2323 spriv->is_mpeg12 = 0;
2324 spriv->telecine = 0;
2325 if(len)
2326 sz = parse_mpeg4_video(s, priv, spriv, fps, len);
2327 else
2328 {
2329 tmp = (uint64_t) (27000000.0f / fps);
2330 spriv->last_pts += tmp;
2331 spriv->last_dts += tmp;
2332 }
2333 }
2334
2335 mp_msg(MSGT_MUXER, MSGL_DBG2,"mpegfile_write_chunk, Video codec=%x, len=%u, mpeg12 returned %u\n", stream_format, (uint32_t) len, (uint32_t) sz);
2336 }
2337 else
2338 { // MUXER_TYPE_AUDIO
2339 double fake_timer;
2340 spriv->type = 0;
2341 stream_format = s->wf->wFormatTag;
2342
2343 if(s->b_buffer_size - s->b_buffer_len < len)
2344 {
2345 void *tmp;
2346
2347 if(s->b_buffer_len > SIZE_MAX - len)
2348 {
2349 mp_msg(MSGT_MUXER, MSGL_FATAL, "\nFATAL! couldn't realloc, integer overflow\n");
2350 return;
2351 }
2352 tmp = realloc(s->b_buffer, len + s->b_buffer_len);
2353 if(!tmp)
2354 {
2355 mp_msg(MSGT_MUXER, MSGL_FATAL, "\nFATAL! couldn't realloc %d bytes\n", len + s->b_buffer_len);
2356 return;
2357 }
2358 s->b_buffer = tmp;
2359
2360 s->b_buffer_size = len + s->b_buffer_len;
2361 mp_msg(MSGT_MUXER, MSGL_DBG2, "REALLOC(%d) bytes to AUDIO backbuffer\n", s->b_buffer_size);
2362 }
2363 memcpy(&(s->b_buffer[s->b_buffer_ptr + s->b_buffer_len]), s->buffer, len);
2364 s->b_buffer_len += len;
2365
2366 if(!spriv->is_ready)
2367 {
2368 if(s->b_buffer_len >= 32*1024)
2369 {
2370 spriv->mpa_layer = analyze_mpa(s);
2371 spriv->is_ready = 1;
2372 }
2373 }
2374 else
2375 {
2376 parse_audio(s, 0, &nf, &fake_timer, priv->init_adelay, priv->drop);
2377 spriv->vframes += nf;
2378 if(! spriv->vframes)
2379 mp_msg(MSGT_MUXER, MSGL_INFO, "AINIT: %.3f\r\n", (double) spriv->last_pts/27000000.0f);
2380 }
2381 }
2382
2383 flush_buffers(muxer, 0);
2384 }
2385
2386
2387 static void mpegfile_write_index(muxer_t *muxer)
2388 {
2389 int i, nf;
2390 double fake_timer;
2391 muxer_priv_t *priv = (muxer_priv_t *) muxer->priv;
2392
2393 mp_tmsg(MSGT_MUXER, MSGL_INFO, "Writing index...\n");
2394
2395 for(i = 0; i < muxer->avih.dwStreams; i++)
2396 {
2397 if(muxer->streams[i]->type == MUXER_TYPE_AUDIO)
2398 parse_audio(muxer->streams[i], 1, &nf, &fake_timer, priv->init_adelay, priv->drop);
2399 }
2400 while(flush_buffers(muxer, 0) > 0);
2401 flush_buffers(muxer, 1);
2402 if(priv->is_genmpeg1 || priv->is_genmpeg2)
2403 {
2404 priv->scr = 0;
2405 write_mpeg_pack(muxer, NULL, muxer->stream, 1); //insert fake Nav Packet
2406 }
2407
2408 mp_msg(MSGT_MUXER, MSGL_INFO, "\nOverhead: %.3f%% (%"PRIu64" / %"PRIu64")\n", 100.0 * (double)priv->headers_size / (double)priv->data_size, priv->headers_size, priv->data_size);
2409 }
2410
2411 static void mpegfile_write_header(muxer_t *muxer)
2412 {
2413 muxer_priv_t *priv = (muxer_priv_t*) muxer->priv;
2414
2415 mp_tmsg(MSGT_MUXER, MSGL_INFO, "Writing header...\n");
2416
2417 priv->headers_cnt++;
2418
2419 //write the first system header only for generic mpeg1/2 muxes, and only when we have collected all necessary infos
2420 if(priv->is_genmpeg1 || priv->is_genmpeg2 || ((priv->is_xvcd || priv->is_xsvcd) && (priv->headers_cnt == 1)))
2421 {
2422 write_mpeg_pack(muxer, NULL, muxer->stream, 0);
2423 priv->update_system_header = 0;
2424 }
2425
2426 return;
2427 }
2428
2429 static void setup_sys_params(muxer_priv_t *priv)
2430 {
2431 if(priv->is_dvd)
2432 {
2433 int v = (conf_vbuf_size ? conf_vbuf_size : 232);
2434 int a1 = (conf_abuf_size ? conf_abuf_size : 4);
2435 int a2 = (conf_abuf_size>58 ? conf_abuf_size : 58);
2436
2437 priv->sys_info.cnt = 4;
2438
2439 priv->sys_info.streams[0].id = 0xb9;
2440 priv->sys_info.streams[0].type = 1;
2441 priv->sys_info.streams[0].bufsize = v*1024;
2442
2443 priv->sys_info.streams[1].id = 0xb8;
2444 priv->sys_info.streams[1].type = 0;
2445 priv->sys_info.streams[1].bufsize = a1*1024;
2446
2447 priv->sys_info.streams[2].id = 0xbd;
2448 priv->sys_info.streams[2].type = 1;
2449 priv->sys_info.streams[2].bufsize = a2*1024;
2450
2451 priv->sys_info.streams[3].id = 0xbf;
2452 priv->sys_info.streams[3].type = 1;
2453 priv->sys_info.streams[3].bufsize = 2*1024;
2454 }
2455 else if(priv->is_xvcd || priv->is_xsvcd)
2456 {
2457 int v = (conf_vbuf_size ? conf_vbuf_size : (priv->is_xvcd ? 46: 230));
2458 int a1 = (conf_abuf_size ? conf_abuf_size : 4);
2459
2460 priv->sys_info.cnt = 2;
2461
2462 priv->sys_info.streams[0].id = 0xe0;
2463 priv->sys_info.streams[0].type = 1;
2464 priv->sys_info.streams[0].bufsize = v*1024;
2465
2466 priv->sys_info.streams[1].id = 0xc0;
2467 priv->sys_info.streams[1].type = 0;
2468 priv->sys_info.streams[1].bufsize = a1*1024;
2469 }
2470 else
2471 priv->sys_info.cnt = 0;
2472 }
2473
2474 /* excerpt from DGPulldown Copyright (C) 2005-2006, Donald Graft */
2475 static void generate_flags(uint8_t *bff_mask, int source, int target)
2476 {
2477 unsigned int i, trfp;
2478 uint64_t dfl,tfl;
2479 unsigned char ormask[4] = {0x0, 0x2, 0x80, 0x82};
2480
2481 dfl = (target - source) << 1;
2482 tfl = source >> 1;
2483
2484 trfp = 0;
2485 for(i = 0; i < MAX_PATTERN_LENGTH; i++)
2486 {
2487 tfl += dfl;
2488 if(tfl >= source)
2489 {
2490 tfl -= source;
2491 bff_mask[i] = ormask[trfp + 1];
2492 trfp ^= 2;
2493 }
2494 else
2495 bff_mask[i] = ormask[trfp];
2496 }
2497 }
2498
2499 int muxer_init_muxer_mpeg(muxer_t *muxer)
2500 {
2501 muxer_priv_t *priv;
2502 priv = calloc(1, sizeof(muxer_priv_t));
2503 if(priv == NULL)
2504 return 0;
2505 priv->update_system_header = 1;
2506
2507 //calloc() already zero-ed all flags, so we assign only the ones we need
2508
2509 if(conf_mux != NULL)
2510 {
2511 if(! strcasecmp(conf_mux, "mpeg1"))
2512 {
2513 priv->mux = MUX_MPEG1;
2514 priv->packet_size = 2048;
2515 priv->is_genmpeg1 = 1;
2516 priv->muxrate = 1800 * 125; //Constrained parameters
2517 }
2518 else if(! strcasecmp(conf_mux, "dvd"))
2519 {
2520 priv->mux = MUX_MPEG2;
2521 priv->is_dvd = 1;
2522 priv->packet_size = 2048;
2523 priv->muxrate = 10080 * 125;
2524 }
2525 else if(! strcasecmp(conf_mux, "xsvcd"))
2526 {
2527 priv->mux = MUX_MPEG2;
2528 priv->is_xsvcd = 1;
2529 priv->packet_size = 2324;
2530 priv->muxrate = 150*2324;
2531 priv->ts_allframes = 1;
2532 }
2533 else if(! strcasecmp(conf_mux, "xvcd"))
2534 {
2535 priv->mux = MUX_MPEG1;
2536 priv->is_xvcd = 1;
2537 priv->packet_size = 2324;
2538 priv->muxrate = 75*2352;
2539 priv->ts_allframes = 1;
2540 }
2541 else if(! strcasecmp(conf_mux, "pes1"))
2542 {
2543 priv->mux = MUX_MPEG1;
2544 priv->rawpes = 1;
2545 priv->packet_size = 2048;
2546 priv->muxrate = 10080 * 125;
2547 priv->ts_allframes = 1;
2548 }
2549 else if(! strcasecmp(conf_mux, "pes2"))
2550 {
2551 priv->mux = MUX_MPEG2;
2552 priv->rawpes = 1;
2553 priv->packet_size = 2048;
2554 priv->muxrate = 10080 * 125;
2555 priv->ts_allframes = 1;
2556 }
2557 else
2558 {
2559 if(strcasecmp(conf_mux, "mpeg2"))
2560 mp_msg(MSGT_MUXER, MSGL_ERR, "Unknown format %s, default to mpeg2\n", conf_mux);
2561 priv->mux = MUX_MPEG2;
2562 priv->is_genmpeg2 = 1;
2563 priv->packet_size = 2048;
2564 priv->muxrate = 1800 * 125; //Constrained parameters
2565 }
2566 }
2567
2568 if(conf_ts_allframes)
2569 priv->ts_allframes = 1;
2570 if(conf_muxrate > 0)
2571 priv->muxrate = conf_muxrate * 125; // * 1000 / 8
2572 if(conf_packet_size)
2573 priv->packet_size = conf_packet_size;
2574 priv->delta_scr = (uint64_t) (90000.0f*300.0f*(double)priv->packet_size/(double)priv->muxrate);
2575 mp_msg(MSGT_MUXER, MSGL_INFO, "PACKET SIZE: %u bytes, deltascr: %"PRIu64"\n", priv->packet_size, priv->delta_scr);
2576 setup_sys_params(priv);
2577
2578 if(conf_vaspect > 0)
2579 {
2580 int asp = (int) (conf_vaspect * 1000.0f);
2581 if(asp >= 1332 && asp <= 1334)
2582 priv->vaspect = ASPECT_4_3;
2583 else if(asp >= 1776 && asp <= 1778)
2584 priv->vaspect = ASPECT_16_9;
2585 else if(asp >= 2209 && asp <= 2211)
2586 priv->vaspect = ASPECT_2_21_1;
2587 else if(asp == 1000)
2588 priv->vaspect = ASPECT_1_1;
2589 else
2590 mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR: unrecognized aspect %.3f\n", conf_vaspect);
2591 }
2592
2593 priv->vframerate = 0; // no change
2594 if(conf_telecine && conf_vframerate > 0)
2595 {
2596 mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR: options 'telecine' and 'vframerate' are mutually exclusive, vframerate disabled\n");
2597 conf_vframerate = 0;
2598 }
2599
2600 if(conf_telecine == TELECINE_FILM2PAL)
2601 {
2602 if(conf_telecine_src==0.0f) conf_telecine_src = 24000.0/1001.0;
2603 conf_telecine_dest = 25;
2604 conf_telecine = TELECINE_DGPULLDOWN;
2605 }
2606 else if(conf_telecine == PULLDOWN32)
2607 {
2608 if(conf_telecine_src==0.0f) conf_telecine_src = 24000.0/1001.0;
2609 conf_telecine_dest = 30000.0/1001.0;
2610 conf_telecine = TELECINE_DGPULLDOWN;
2611 }
2612
2613 if(conf_telecine_src>0 && conf_telecine_dest>0 && conf_telecine_src < conf_telecine_dest)
2614 {
2615 int sfps, tfps;
2616
2617 sfps = (int) (conf_telecine_src * 1001 + 0.5);
2618 tfps = (int) (conf_telecine_dest * 1001 + 0.5);
2619 if(sfps % 2 || tfps % 2)
2620 {
2621 sfps *= 2;
2622 tfps *= 2;
2623 }
2624
2625 if(((tfps - sfps)>>1) > sfps)
2626 {
2627 mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR! Framerate increment must be <= 1.5, telecining disabled\n");
2628 conf_telecine = 0;
2629 }
2630 else
2631 {
2632 generate_flags(priv->bff_mask, sfps, tfps);
2633 conf_telecine = TELECINE_DGPULLDOWN;
2634 conf_vframerate = conf_telecine_dest;
2635 }
2636 }
2637
2638 if(conf_vframerate)
2639 {
2640 int fps;
2641
2642 fps = (int) (conf_vframerate * 1001 + 0.5);
2643 switch(fps)
2644 {
2645 case 24000:
2646 priv->vframerate = FRAMERATE_23976;
2647 break;
2648 case 24024:
2649 priv->vframerate = FRAMERATE_24;
2650 break;
2651 case 25025:
2652 priv->vframerate = FRAMERATE_25;
2653 break;
2654 case 30000:
2655 priv->vframerate = FRAMERATE_2997;
2656 break;
2657 case 30030:
2658 priv->vframerate = FRAMERATE_30;
2659 break;
2660 case 50050:
2661 priv->vframerate = FRAMERATE_50;
2662 break;
2663 case 60000:
2664 priv->vframerate = FRAMERATE_5994;
2665 break;
2666 case 60060:
2667 priv->vframerate = FRAMERATE_60;
2668 break;
2669 default:
2670 {
2671 mp_msg(MSGT_MUXER, MSGL_ERR, "WRONG FPS: %d/1000, ignoring\n", fps);
2672 if(conf_telecine)
2673 mp_msg(MSGT_MUXER, MSGL_ERR, "DISABLED TELECINING\n");
2674 conf_telecine = 0;
2675 }
2676 }
2677 }
2678
2679 priv->vwidth = (uint16_t) conf_vwidth;
2680 priv->vheight = (uint16_t) conf_vheight;
2681 priv->panscan_width = (uint16_t) conf_panscan_width;
2682 priv->panscan_height = (uint16_t) conf_panscan_height;
2683 priv->vbitrate = ((conf_vbitrate) * 10) >> 2; //*1000 / 400
2684
2685 if(priv->vaspect || priv->vframerate || priv->vwidth || priv->vheight || priv->vbitrate || priv->panscan_width || priv->panscan_height)
2686 {
2687 priv->patch_seq = priv->vaspect || priv->vframerate || priv->vwidth || priv->vheight || priv->vbitrate;
2688 priv->patch_sde = priv->panscan_width || priv->panscan_height;
2689 mp_msg(MSGT_MUXER, MSGL_INFO, "MPEG MUXER, patching");
2690 if(priv->vwidth || priv->vheight)
2691 mp_msg(MSGT_MUXER, MSGL_INFO, " resolution to %dx%d", priv->vwidth, priv->vheight);
2692 if(priv->panscan_width || priv->panscan_height)
2693 mp_msg(MSGT_MUXER, MSGL_INFO, " panscan to to %dx%d", priv->panscan_width, priv->panscan_height);
2694 if(priv->vframerate)
2695 mp_msg(MSGT_MUXER, MSGL_INFO, " framerate to %s fps", framerates[priv->vframerate]);
2696 if(priv->vaspect)
2697 mp_msg(MSGT_MUXER, MSGL_INFO, " aspect ratio to %s", aspect_ratios[priv->vaspect]);
2698 if(priv->vbitrate)
2699 mp_msg(MSGT_MUXER, MSGL_INFO, " bitrate to %u", conf_vbitrate);
2700 mp_msg(MSGT_MUXER, MSGL_INFO, "\n");
2701 }
2702
2703 priv->has_video = priv->has_audio = 0;
2704
2705 muxer->sysrate = priv->muxrate; // initial muxrate = constrained stream parameter
2706 priv->scr = muxer->file_end = 0;
2707
2708 if(conf_init_vdelay && conf_drop)
2709 {
2710 mp_msg(MSGT_MUXER, MSGL_ERR, "\nmuxer_mpg, :drop and :vdelay used together are not supported, exiting\n");
2711 return 0;
2712 }
2713 if(conf_init_adelay)
2714 priv->init_adelay = - (double) conf_init_adelay / (double) 1000.0;
2715
2716 priv->drop = conf_drop;
2717
2718 priv->buff = malloc(priv->packet_size);
2719 if((priv->buff == NULL))
2720 {
2721 mp_msg(MSGT_MUXER, MSGL_ERR, "\nCouldn't allocate %d bytes, exit\n", priv->packet_size);
2722 return 0;
2723 }
2724
2725 muxer->priv = (void *) priv;
2726 muxer->cont_new_stream = &mpegfile_new_stream;
2727 muxer->cont_write_chunk = &mpegfile_write_chunk;
2728 muxer->cont_write_header = &mpegfile_write_header;
2729 muxer->cont_write_index = &mpegfile_write_index;
2730 muxer->fix_stream_parameters = &fix_parameters;
2731 return 1;
2732 }
Sources used to build Kovensky's MPlayer