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