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