12 #include "aviheader.h"
15 #include "stream/stream.h"
22 #include "liba52/a52.h"
24 #define PACK_HEADER_START_CODE 0x01ba
25 #define SYSTEM_HEADER_START_CODE 0x01bb
26 #define PSM_START_CODE 0x01bc
28 #define PES_PRIVATE1 0x01bd
29 #define PES_PRIVATE2 0x01bf
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
47 #define ASPECT_2_21_1 4
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
58 static char ftypes
[] = {'?', 'I', 'P', 'B'};
59 #define FTYPE(x) (ftypes[(x)])
61 static const char *framerates
[] = {
62 "unchanged", "23.976", "24", "25", "29.97", "30", "50", "59.94", "60"
65 static const char *aspect_ratios
[] = {
66 "unchanged", "1/1", "4/3", "16/9", "2.21/1"
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;
98 uint64_t pts
, dts
, idur
;
99 uint32_t pos
; //start offset for the frame
103 uint8_t cnt
; // how many entries we use
108 } streams
[50]; //16 video + 16 audio mpa + 16 audio private + bd/bf for dvd
112 uint8_t cnt
; // how many entries we use
117 } streams
[50]; //16 video + 16 audio mpa + 16 audio private + bd/bf for dvd
127 uint64_t frame_dts
, frame_pts
;
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
;
141 uint64_t last_psm_scr
;
144 uint32_t headers_cnt
;
148 //video patching parameters
149 uint8_t vaspect
, vframerate
;
150 uint16_t vwidth
, vheight
, panscan_width
, panscan_height
;
152 int patch_seq
, patch_sde
;
155 //2 million frames are enough
156 #define MAX_PATTERN_LENGTH 2000000
157 uint8_t bff_mask
[MAX_PATTERN_LENGTH
];
162 int has_pts
, has_dts
, pes_is_aligned
, type
, min_pes_hlen
;
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
;
173 uint8_t id
, is_mpeg12
, telecine
;
175 int64_t display_frame
;
176 mp_mpeg_header_t picture
;
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
181 int pack_offset
, pes_offset
, pes_set
, payload_offset
;
183 int last_frame_rest
; //the rest of the previous frame
189 #define TELECINE_FILM2PAL 2
190 #define TELECINE_DGPULLDOWN 3
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
}
217 int mp_a52_framesize(uint8_t *buf
, int *srate
);
219 static void fix_audio_sys_header(muxer_priv_t
*priv
, uint8_t id
, uint8_t newid
, uint32_t size
)
223 for(i
= 0; i
< priv
->sys_info
.cnt
; i
++)
225 if(priv
->sys_info
.streams
[i
].id
== id
)
227 priv
->sys_info
.streams
[i
].id
= newid
;
228 priv
->sys_info
.streams
[i
].type
= 1;
229 priv
->sys_info
.streams
[i
].bufsize
= size
;
234 static inline int is_mpeg1(uint32_t x
)
238 (x
== mmioFOURCC('m','p','g','1')) ||
239 (x
== mmioFOURCC('M','P','G','1'));
242 static inline int is_mpeg2(uint32_t x
)
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'));
252 static inline int is_mpeg4(uint32_t x
)
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'));
272 static uint32_t CalcCRC32(uint8_t *buff
, uint32_t size
)
274 uint32_t i
, j
, CRCTab
[256], crc
;
276 for(i
= 0;i
< 256; i
++)
278 for(crc
= i
, j
= 0; j
< 8; j
++)
279 crc
= (crc
& 1) ? (crc
>> 1)^0xEDB88320L
: (crc
>> 1);
285 for(i
= 0; i
< size
; i
++)
286 crc
= (crc
<< 8) ^ CRCTab
[((crc
>> 24) ^ buff
[i
]) & 0xff];
292 static void add_to_psm(muxer_priv_t
*priv
, uint8_t id
, uint32_t format
)
296 i
= priv
->psm_info
.cnt
;
297 priv
->psm_info
.streams
[i
].id
= id
;
298 priv
->psm_info
.streams
[i
].format
= 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;
311 priv
->psm_info
.streams
[i
].type
= 0x81;
313 if(format
== AUDIO_A52
)
314 memcpy((char*) &(priv
->psm_info
.streams
[i
].format
), "AC-3", 4);
316 priv
->psm_info
.cnt
++;
320 static mpeg_frame_t
*init_frames(uint16_t num
, size_t size
)
325 tmp
= (mpeg_frame_t
*) calloc(num
, sizeof(mpeg_frame_t
));
329 for(i
=0; i
< num
; i
++)
331 tmp
[i
].buffer
= (uint8_t *) calloc(1, size
);
332 if(tmp
[i
].buffer
== NULL
)
336 tmp
[i
].alloc_size
= size
;
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
);
345 static muxer_stream_t
* mpegfile_new_stream(muxer_t
*muxer
,int type
){
346 muxer_priv_t
*priv
= (muxer_priv_t
*) muxer
->priv
;
348 muxer_headers_t
*spriv
;
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");
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");
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");
369 mp_msg(MSGT_MUXER
, MSGL_ERR
, "Unknown stream type!\n");
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
)))
376 s
->b_buffer_size
= priv
->packet_size
;
379 s
->priv
= (muxer_headers_t
*) calloc(1, sizeof(muxer_headers_t
));
382 spriv
= (muxer_headers_t
*) s
->priv
;
383 spriv
->pack
= malloc(priv
->packet_size
);
386 spriv
->buffer_track
= calloc(1, 4096*sizeof(buffer_track_t
));
387 if(!spriv
->buffer_track
)
389 spriv
->track_pos
= 0;
390 spriv
->track_len
= 4096;
391 muxer
->streams
[muxer
->avih
.dwStreams
]=s
;
393 s
->id
=muxer
->avih
.dwStreams
;
396 if (type
== MUXER_TYPE_VIDEO
) {
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;
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
;
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
++;
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");
426 memset(&(spriv
->picture
), 0, sizeof(spriv
->picture
));
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
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
;
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
++;
453 spriv
->min_pes_hlen
= 13;
454 else if(priv
->is_xsvcd
)
455 spriv
->min_pes_hlen
= 17;
459 s
->h
.fccType
=streamtypeAUDIO
;
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");
469 mp_msg (MSGT_MUXER
, MSGL_DBG2
, "Added audio stream %d, ckid=%X\n", s
->id
- muxer
->num_videos
+ 1, s
->ckid
);
471 muxer
->avih
.dwStreams
++;
482 if(spriv
->buffer_track
)
483 free(spriv
->buffer_track
);
493 static void write_mpeg_ts(unsigned char *b
, uint64_t ts
, uint8_t mod
) {
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;
503 static void write_mpeg_rate(int type
, unsigned char *b
, unsigned int rate
)
505 rate
= ((rate
*8)+399) / 400;
507 if(type
== MUX_MPEG1
)
509 b
[0] = ((rate
>> 15) & 0x7f) | 0x80;
510 b
[1] = (rate
>> 7) & 0xff;
511 b
[2] = ((rate
<< 1) & 0xff) | 1;
516 b
[1] = (rate
>> 6) & 0xff;
517 b
[2] = ((rate
& 0x3f) << 2) | 0x03;
522 static void write_mpeg_std(unsigned char *b
, unsigned int size
, unsigned int type
, uint8_t mod
)
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);
533 b
[0] = ((size
>> 8) & 0x3f) | (type
==1 ? 0x60 : 0x40) | mod
;
537 static void write_mpeg2_scr(unsigned char *b
, uint64_t ts
)
539 uint16_t t1
, t2
, t3
, scr_ext
;
540 scr_ext
= ts
% 300ULL;
542 ts
&= 0x1FFFFFFFFULL
; //33 bits
543 t1
= (ts
>> 30) & 0x7;
544 t2
= (ts
>> 15) & 0x7fff;
547 b
[0] = (t1
<< 3 ) | 0x44 | ((t2
>> 13) & 0x3);
549 b
[2] = (t2
& 0x1f) << 3 | 0x4 | ((t3
>> 13) & 0x3);
551 b
[4] = (t3
& 0x1f) << 3 | ((scr_ext
>> 7) & 0x03) | 0x4;
552 b
[5] = ((scr_ext
<< 1) & 0xFF) | 1;
556 static int write_mpeg_pack_header(muxer_t
*muxer
, char *buff
)
561 priv
= (muxer_priv_t
*) muxer
->priv
;
562 *(uint32_t *)buff
= be2me_32(PACK_HEADER_START_CODE
);
563 if(priv
->mux
==MUX_MPEG1
)
565 write_mpeg_ts(&buff
[4], priv
->scr
, 0x20); // 0010 and SCR
566 write_mpeg_rate(priv
->mux
, &buff
[9], muxer
->sysrate
);
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
581 static int write_mpeg_system_header(muxer_t
*muxer
, char *buff
)
586 priv
= (muxer_priv_t
*) muxer
->priv
;
589 *(uint32_t *)(&buff
[len
]) = be2me_32(SYSTEM_HEADER_START_CODE
);
591 *(uint16_t *)(&buff
[len
]) = 0; //fake length, we'll fix it later
593 write_mpeg_rate(MUX_MPEG1
, &buff
[len
], muxer
->sysrate
);
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
601 buff
[len
++] = 0x21; //marker, 1 video stream bound
603 buff
[len
++] = ((priv
->mux
== MUX_MPEG1
) ? 0xff : 0x7f); //in mpeg2 there's the packet rate restriction
605 for(i
= 0; i
< priv
->sys_info
.cnt
; i
++)
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));
613 *(uint16_t *)(&buff
[4]) = be2me_16(len
- 6); // length field fixed
618 static int write_mpeg_psm(muxer_t
*muxer
, char *buff
)
624 priv
= (muxer_priv_t
*) muxer
->priv
;
627 *(uint32_t *)(&buff
[len
]) = be2me_32(PSM_START_CODE
);
629 *(uint16_t *)(&buff
[len
]) = 0; //fake length, we'll fix it later
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)
635 *(uint16_t *)(&buff
[len
]) = 0; //length of the es descriptors
639 for(i
= 0; i
< priv
->psm_info
.cnt
; i
++)
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)
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
655 *(uint16_t *)(&buff
[10]) = be2me_16(dlen
); //length of the es descriptors
657 *(uint16_t *)(&buff
[4]) = be2me_16(len
- 6 + 4); // length field fixed, including size of CRC32
659 *(uint32_t *)(&buff
[len
]) = be2me_32(CalcCRC32(buff
, len
));
666 static int psm_is_late(muxer_priv_t
*priv
)
668 return !priv
->data_size
|| (priv
->scr
>= priv
->last_psm_scr
+ 27000000ULL);
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
)
676 memcpy(&buff
[len
], pes_id
, 4);
679 buff
[len
] = buff
[len
+1] = 0; //fake len
682 if(mux_type
== MUX_MPEG1
)
686 memset(&buff
[len
], 0xff, stuffing_len
);
690 if(h
->buffer_size
> 0)
692 write_mpeg_std(&buff
[len
], h
->buffer_size
, h
->type
, 0x40); // 01 is pes1 format
698 buff
[len
] = (h
->pes_is_aligned
? 0x84 : 0x80); //0x10...
700 buff
[len
] = ((h
->buffer_size
> 0) ? 1 : 0) | (h
->pts
? (h
->dts
? 0xC0 : 0x80) : 0); //pes extension + pts/dts flags
702 buff
[len
] = (h
->pts
? (h
->dts
? 10 : 5) : 0) + ((h
->buffer_size
> 0) ? 3 : 0) + stuffing_len
;//pts + std + stuffing
709 write_mpeg_ts(&buff
[len
], h
->pts
, (h
->dts
? 0x30 : 0x20)); // 001x and both PTS/DTS
714 write_mpeg_ts(&buff
[len
], h
->dts
, 0x10); // 0001 before DTS
720 if(mux_type
== MUX_MPEG1
)
728 if(mux_type
== MUX_MPEG2
)
730 if(h
->buffer_size
> 0)
732 buff
[len
] = 0x1e; //std flag
735 write_mpeg_std(&buff
[len
], h
->buffer_size
, h
->type
, 0x40);
741 memset(&buff
[len
], 0xff, stuffing_len
);
746 *((uint16_t*) &buff
[4]) = be2me_16(len
+ plen
- 6); //fix pes packet size
751 static void write_pes_padding(uint8_t *buff
, uint16_t len
)
753 //6 header bytes + len-6 0xff chars
754 buff
[0] = buff
[1] = 0;
757 *((uint16_t*) &buff
[4]) = be2me_16(len
- 6);
758 memset(&buff
[6], 0xff, len
- 6);
762 static int write_nav_pack(uint8_t *buff
)
764 // concatenation of pes_private2 + 03d4 x 0 and pes_private2 + 03fa x 0
767 mp_msg(MSGT_MUXER
, MSGL_DBG3
, "NAV\n");
769 *(uint32_t *)(&buff
[len
]) = be2me_32(PES_PRIVATE2
);
773 memset(&buff
[len
], 0, 0x03d4);
776 *(uint32_t *)(&buff
[len
]) = be2me_32(PES_PRIVATE2
);
780 memset(&buff
[len
], 0, 0x03fa);
786 static unsigned int calc_psm_len(muxer_priv_t
*priv
)
788 return 16 + 4*(priv
->psm_info
.cnt
);
791 static uint32_t calc_pes_hlen(int format
, muxer_headers_t
*h
, muxer_priv_t
*priv
)
795 if(format
== MUX_MPEG1
)
806 else if(format
== MUX_MPEG1
)
809 if(h
->buffer_size
> 0)
811 if(format
== MUX_MPEG2
)
817 //len = max(h->min_pes_hlen, len);
823 static int write_mpeg_pack(muxer_t
*muxer
, muxer_stream_t
*s
, stream_t
*stream
, int isoend
)
830 priv
= (muxer_priv_t
*) muxer
->priv
;
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;
841 stream_write_buffer(stream
, buff
, priv
->packet_size
);
844 else //FAKE DVD NAV PACK
846 offset
= write_mpeg_pack_header(muxer
, buff
);
847 offset
+= write_mpeg_system_header(muxer
, &buff
[offset
]);
849 //priv->update_system_header = 0;
852 offset
+= write_nav_pack(&buff
[offset
]);
854 stuffing_len
= priv
->packet_size
- offset
;
857 //insert a PES padding packet
858 write_pes_padding(&buff
[offset
], stuffing_len
);
859 offset
+= stuffing_len
;
862 stream_write_buffer(stream
, buff
, offset
);
863 priv
->headers_size
+= offset
;
865 muxer
->movi_end
+= tot
;
871 static void update_demux_bufsize(muxer_headers_t
*spriv
, uint64_t dts
, int framelen
, int type
)
873 int dim
= (spriv
->track_len
+16)*sizeof(buffer_track_t
);
875 if(spriv
->track_pos
+1 >= spriv
->track_len
)
877 buffer_track_t
*tmp
= realloc(spriv
->buffer_track
, dim
);
880 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\r\nERROR, couldn't realloc %d bytes for tracking buffer\r\n", dim
);
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;
888 spriv
->buffer_track
[spriv
->track_pos
].size
= framelen
;
889 spriv
->buffer_track
[spriv
->track_pos
].dts
= dts
; //must be dts
894 static void fix_a52_headers(muxer_stream_t
*s
)
896 muxer_headers_t
*spriv
= s
->priv
;
897 int x
= spriv
->payload_offset
;
899 spriv
->pack
[x
+0] = 0x80;
900 spriv
->pack
[x
+1] = spriv
->frames
;
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
907 spriv
->pack
[x
+2] = spriv
->pack
[x
+3] = 0;
910 static inline void remove_frames(muxer_headers_t
*spriv
, int n
)
915 for(i
= n
; i
< spriv
->framebuf_used
; i
++)
917 tmp
= spriv
->framebuf
[i
- n
];
918 spriv
->framebuf
[i
- n
] = spriv
->framebuf
[i
];
919 spriv
->framebuf
[i
] = tmp
;
921 spriv
->framebuf_used
-= n
;
924 static int calc_packet_len(muxer_stream_t
*s
, int psize
, int finalize
)
926 muxer_headers_t
*spriv
= s
->priv
;
927 int n
, len
, frpos
, m
;
930 frpos
= spriv
->framebuf
[0].pos
;
931 while(len
< psize
&& n
< spriv
->framebuf_used
)
933 if(!frpos
&& len
>0 && s
->type
== MUXER_TYPE_VIDEO
&& spriv
->framebuf
[n
].type
==I_FRAME
)
935 m
= FFMIN(spriv
->framebuf
[n
].size
- frpos
, psize
- len
);
938 if(frpos
== spriv
->framebuf
[n
].size
)
945 if(len
< psize
&& !finalize
)
950 static int find_packet_timestamps(muxer_priv_t
*priv
, muxer_stream_t
*s
, unsigned int start
, uint64_t *dts
, uint64_t *pts
)
952 muxer_headers_t
*spriv
= s
->priv
;
953 int i
, m
, pes_hlen
, ret
, threshold
;
954 uint64_t spts
, sdts
, dpts
;
956 if(!spriv
->framebuf_used
)
961 spriv
->dts
= spriv
->pts
= 0;
963 if(spriv
->framebuf
[0].pos
== 0) // start of frame
967 pes_hlen
= calc_pes_hlen(priv
->mux
, spriv
, priv
);
969 if(pes_hlen
< spriv
->min_pes_hlen
)
970 pes_hlen
= spriv
->min_pes_hlen
;
972 m
= spriv
->framebuf
[0].size
- spriv
->framebuf
[0].pos
;
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
978 if(spriv
->framebuf_used
< 2)
981 if(spriv
->framebuf
[1].pts
== spriv
->framebuf
[1].dts
)
986 //headers+frame 0 < space available including timestamps
987 if(start
+ pes_hlen
+ m
< priv
->packet_size
- threshold
)
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
;
1000 if(s
->type
!= MUXER_TYPE_VIDEO
)
1002 else if((spriv
->framebuf
[i
].type
== I_FRAME
|| priv
->ts_allframes
|| dpts
>= 36000*300)) //0.4 seconds
1007 *pts
= spriv
->framebuf
[i
].pts
;
1008 *dts
= spriv
->framebuf
[i
].dts
;
1020 static int get_packet_stats(muxer_priv_t
*priv
, muxer_stream_t
*s
, pack_stats_t
*p
, int finalize
)
1022 muxer_headers_t
*spriv
= s
->priv
;
1023 int len
, len2
, pack_hlen
, pes_hlen
, hlen
, target
, stflen
, stuffing_len
;
1026 spriv
->pts
= spriv
->dts
= 0;
1027 p
->dts
= p
->pts
= p
->frame_pts
= p
->frame_dts
= 0;
1032 else if(priv
->mux
== MUX_MPEG1
)
1036 if(priv
->use_psm
&& psm_is_late(priv
))
1037 pack_hlen
+= calc_psm_len(priv
);
1039 if(find_packet_timestamps(priv
, s
, pack_hlen
, &dts
, &pts
))
1041 p
->pts
= p
->frame_pts
= pts
;
1042 p
->dts
= p
->frame_dts
= dts
;
1047 pes_hlen
= calc_pes_hlen(priv
->mux
, spriv
, priv
);
1049 p
->stflen
= stflen
= (spriv
->min_pes_hlen
> pes_hlen
? spriv
->min_pes_hlen
- pes_hlen
: 0);
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
)
1060 len2
= calc_packet_len(s
, target
, finalize
);
1061 if(!len2
|| (len2
< target
&& s
->type
== MUXER_TYPE_AUDIO
&& !finalize
))
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);
1074 if(s
->type
== MUXER_TYPE_VIDEO
)
1080 spriv
->pts
= spriv
->dts
= 0;
1081 p
->pts
= p
->dts
= 0;
1084 stuffing_len
= target
- len
;
1085 if(stuffing_len
> 0 && stuffing_len
< 7)
1087 if(stflen
+ stuffing_len
> 16)
1089 int x
= 7 - stuffing_len
;
1095 stflen
+= stuffing_len
;
1109 static int fill_packet(muxer_t
*muxer
, muxer_stream_t
*s
, int finalize
)
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;
1122 spriv
->dts
= spriv
->pts
= 0;
1124 if(! spriv
->framebuf_used
)
1126 spriv
->pack_offset
= 0;
1130 if(!spriv
->pack_offset
)
1133 spriv
->pack_offset
= 0;
1135 spriv
->pack_offset
= write_mpeg_pack_header(muxer
, spriv
->pack
);
1136 if(priv
->update_system_header
&& (priv
->is_genmpeg1
|| priv
->is_genmpeg2
))
1138 spriv
->pack_offset
+= write_mpeg_system_header(muxer
, &spriv
->pack
[spriv
->pack_offset
]);
1139 priv
->update_system_header
= 0;
1142 if(priv
->use_psm
&& psm_is_late(priv
))
1144 spriv
->pack_offset
+= write_mpeg_psm(muxer
, &spriv
->pack
[spriv
->pack_offset
]);
1149 spriv
->pes_offset
= spriv
->pack_offset
;
1150 spriv
->payload_offset
= 0;
1152 spriv
->last_frame_rest
= 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)
1163 if(s
->type
== MUXER_TYPE_VIDEO
)
1164 bufsize
= (conf_vbuf_size
? conf_vbuf_size
: (priv
->is_xvcd
? 46 : 232));
1166 bufsize
= (conf_abuf_size
? conf_abuf_size
: 4);
1167 spriv
->buffer_size
= bufsize
*1024;
1170 if(priv
->is_dvd
&& s
->type
== MUXER_TYPE_VIDEO
1171 && spriv
->framebuf
[0].type
==I_FRAME
&& spriv
->framebuf
[0].pos
==0)
1174 if(! get_packet_stats(priv
, s
, &p
, finalize
))
1176 spriv
->pack_offset
= 0;
1182 spriv
->last_saved_pts
= p
.pts
;
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
);
1187 if(s
->type
== MUXER_TYPE_AUDIO
&& s
->wf
->wFormatTag
== AUDIO_A52
)
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;
1194 spriv
->last_frame_rest
= spriv
->framebuf
[0].size
- spriv
->framebuf
[0].pos
;
1201 if(spriv
->dts
|| spriv
->pts
)
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);
1212 frm
= spriv
->framebuf
;
1213 while(spriv
->pack_offset
< priv
->packet_size
&& n
< spriv
->framebuf_used
)
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
)
1224 update_demux_bufsize(spriv
, frm
->dts
, frm
->size
, s
->type
);
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
);
1231 spriv
->pack_offset
+= m
;
1234 if(frm
->pos
== frm
->size
) //end of frame
1236 frm
->pos
= frm
->size
= 0;
1237 frm
->pts
= frm
->dts
= 0;
1243 if((priv
->is_xsvcd
|| priv
->is_xvcd
|| priv
->rawpes
) && spriv
->size
== 0)
1244 spriv
->buffer_size
= 0;
1248 if(dvd_pack
&& (spriv
->pack_offset
== priv
->packet_size
))
1249 write_mpeg_pack(muxer
, NULL
, muxer
->stream
, 0); //insert fake Nav Packet
1252 remove_frames(spriv
, n
);
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
);
1258 if(s
->type
== MUXER_TYPE_AUDIO
&& s
->wf
->wFormatTag
== AUDIO_A52
)
1261 if(spriv
->pack_offset
< priv
->packet_size
&& !priv
->rawpes
) //here finalize is set
1263 int diff
= priv
->packet_size
- spriv
->pack_offset
;
1264 write_pes_padding(&(spriv
->pack
[spriv
->pack_offset
]), diff
);
1265 spriv
->pack_offset
+= diff
;
1268 stream_write_buffer(muxer
->stream
, spriv
->pack
, spriv
->pack_offset
);
1270 priv
->headers_size
+= spriv
->pack_offset
- len
;
1271 priv
->data_size
+= len
;
1272 muxer
->movi_end
+= spriv
->pack_offset
;
1274 spriv
->pack_offset
= 0;
1278 priv
->last_psm_scr
= priv
->scr
;
1283 static inline int find_best_stream(muxer_t
*muxer
)
1287 muxer_priv_t
*priv
= muxer
->priv
;
1288 muxer_headers_t
*spriv
;
1290 unsigned int perc
, sperc
;
1295 //THIS RULE MUST ALWAYS apply: dts <= SCR + 0.7 seconds
1296 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
1298 spriv
= muxer
->streams
[i
]->priv
;
1301 get_packet_stats(priv
, muxer
->streams
[i
], &p
, 0);
1303 if(spriv
->track_bufsize
+ p
.len
> spriv
->max_buffer_size
)
1305 if(p
.frame_pts
&& p
.frame_dts
> priv
->scr
+ 63000*300)
1308 if(spriv
->framebuf
[0].dts
<= dts
)
1310 dts
= spriv
->framebuf
[0].dts
;
1314 if(conf_interleaving2
)
1316 sperc
= (spriv
->track_bufsize
* 1024) / spriv
->max_buffer_size
;
1328 static void patch_seq(muxer_priv_t
*priv
, unsigned char *buf
)
1330 if(priv
->vwidth
> 0)
1332 buf
[4] = (priv
->vwidth
>> 4) & 0xff;
1334 buf
[5] |= (priv
->vwidth
& 0x0f) << 4;
1337 if(priv
->vheight
> 0)
1340 buf
[5] |= (priv
->vheight
>> 8) & 0x0f;
1341 buf
[6] = priv
->vheight
& 0xff;
1344 if(priv
->vaspect
> 0)
1345 buf
[7] = (buf
[7] & 0x0f) | (priv
->vaspect
<< 4);
1347 if(priv
->vframerate
> 0)
1348 buf
[7] = (buf
[7] & 0xf0) | priv
->vframerate
;
1350 if(priv
->vbitrate
> 0)
1352 buf
[8] = (priv
->vbitrate
>> 10);
1353 buf
[9] = (priv
->vbitrate
>> 2);
1354 buf
[10] = (buf
[10] & 0x3f) | (unsigned char) ((priv
->vbitrate
& 0x4) << 2);
1358 static void patch_panscan(muxer_priv_t
*priv
, unsigned char *buf
)
1359 { //patches sequence display extension (display_horizontal_size and display_vertical_size)
1366 if(priv
->panscan_width
> 0)
1368 buf
[offset
] = (priv
->panscan_width
>> 6);
1369 buf
[offset
+1] = ((priv
->panscan_width
& 0x3F) << 2) | (buf
[offset
+ 1] & 0x03);
1374 if(priv
->panscan_height
> 0)
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);
1383 static void update_scr(muxer_t
*muxer
)
1385 muxer_priv_t
*priv
= muxer
->priv
;
1386 muxer_stream_t
*stream
;
1387 muxer_headers_t
*spriv
;
1389 uint64_t mindts
= (uint64_t) -1;
1391 priv
->scr
+= priv
->delta_scr
;
1393 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
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
;
1401 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "UPDATE SCR TO %"PRIu64
" (%.3lf)\n", priv
->scr
, (double) (priv
->scr
/27000000.0));
1403 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
1405 stream
= muxer
->streams
[i
];
1406 spriv
= stream
->priv
;
1409 while(j
< spriv
->track_pos
&& priv
->scr
>= spriv
->buffer_track
[j
].dts
)
1411 spriv
->track_bufsize
-= spriv
->buffer_track
[j
].size
;
1414 if(spriv
->track_bufsize
< 0)
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;
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;
1432 if(spriv
->framebuf_used
&& spriv
->framebuf
[0].dts
< mindts
)
1433 mindts
= spriv
->framebuf
[0].dts
;
1438 static int calc_frames_to_flush(muxer_headers_t
*vpriv
)
1442 if(vpriv
->framebuf_used
> 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
)
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
);
1453 if(vpriv
->framebuf
[n
].type
== I_FRAME
)
1466 if(found
&& (n
< vpriv
->framebuf_used
+1))
1472 static int flush_buffers(muxer_t
*muxer
, int finalize
)
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
;
1481 uint64_t iduration
, iaduration
;
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
1491 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
1493 s
= muxer
->streams
[i
];
1494 if(s
->type
== MUXER_TYPE_VIDEO
)
1496 vs
= muxer
->streams
[i
];
1497 vpriv
= (muxer_headers_t
*) vs
->priv
;
1498 if(!vpriv
->is_ready
)
1500 n
= found
= calc_frames_to_flush(vpriv
);
1502 else if(s
->type
== MUXER_TYPE_AUDIO
)
1506 if((! found
) && finalize
)
1509 found
= n
= vpriv
->framebuf_used
;
1514 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "\nVIDEO, FLUSH %d frames (of %d), 0 to %d\n", n
, vpriv
->framebuf_used
, n
-1);
1516 vpriv
= (muxer_headers_t
*) vs
->priv
;
1520 for(i
= 0; i
< n
; i
++)
1521 iduration
+= vpriv
->framebuf
[i
].idur
;
1522 duration
= (double) (iduration
/ 27000000.0);
1526 apriv
= (muxer_headers_t
*) as
->priv
;
1528 for(i
= 0; i
< apriv
->framebuf_used
; i
++)
1530 iaduration
+= apriv
->framebuf
[i
].idur
;
1532 if(iaduration
< iduration
)
1534 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "Not enough audio data exit\n");
1539 if(as
!= NULL
&& (apriv
->size
== 0))
1541 init_delay
= vpriv
->framebuf
[0].pts
- vpriv
->framebuf
[0].dts
;
1543 for(i
= 0; i
< apriv
->framebuf_cnt
; i
++)
1545 apriv
->framebuf
[i
].pts
+= init_delay
;
1546 apriv
->framebuf
[i
].dts
+= init_delay
;
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
);
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;
1561 i
= find_best_stream(muxer
);
1564 if(!fill_packet(muxer
, muxer
->streams
[i
], finalize
))
1567 if(skip_cnt
== muxer
->avih
.dwStreams
)
1575 muxer
->file_end
= priv
->scr
;
1580 static inline uint64_t parse_fps(float fps
)
1582 // 90000 * 300 * 1001 / d , there's no rounding error with any of the admitted framerates
1583 int d
= (int)(fps
*1001+0.5);
1585 return 27027000000ULL / d
;
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
)
1595 *fps_ptr
= (*fps_ptr
& 0xf0) | priv
->vframerate
;
1596 vpriv
->nom_delta_pts
= parse_fps(conf_vframerate
);
1599 //in pce_ptr starting from bit 0 bit 24 is tff, bit 30 is rff,
1600 if(pce_ptr
[3] & 0x2)
1602 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\nERROR! RFF bit is already set, disabling telecining\n");
1603 vpriv
->telecine
= 0;
1607 vpriv
->picture
.progressive_sequence
= 0;
1608 vpriv
->picture
.progressive_frame
= 1;
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
1616 vpriv
->display_frame
+= n
;
1617 if(! vpriv
->vframes
)
1618 mp_msg(MSGT_MUXER
, MSGL_INFO
, "\nENABLED SOFT TELECINING, FPS=%.3f\n",conf_vframerate
);
1623 static size_t parse_mpeg12_video(muxer_stream_t
*s
, muxer_priv_t
*priv
, muxer_headers_t
*spriv
, float fps
, size_t len
)
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
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)
1637 mp_msg(MSGT_MUXER
, MSGL_ERR
,"Unknown video format, possibly non-MPEG1/2 stream, len=%d!\n", 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))
1649 switch(s
->buffer
[i
+3])
1651 case 0xb3: //sequence
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
);
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
);
1668 patch_seq(priv
, &(s
->buffer
[i
]));
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))
1684 patch_panscan(priv
, &(s
->buffer
[i
+4]));
1686 if((s
->buffer
[i
+4] & 0xf0) == 0x80)
1688 pce_ptr
= &(s
->buffer
[i
+4]);
1702 pt
= (s
->buffer
[i
+5] & 0x1c) >> 3;
1703 temp_ref
= (s
->buffer
[i
+4]<<2)+(s
->buffer
[i
+5]>>6);
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
1712 mp_msg(MSGT_MUXER
, MSGL_ERR
,"Warning: picture too short or broken!\n");
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
);
1718 spriv
->last_tr
= spriv
->max_tr
= temp_ref
;
1719 d1
= temp_ref
- spriv
->last_tr
;
1721 frames_diff
= spriv
->max_tr
+ 1 + temp_ref
- spriv
->last_tr
;
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
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
);
1736 if(temp_ref
> spriv
->max_tr
|| gop_reset
)
1737 spriv
->max_tr
= temp_ref
;
1739 spriv
->last_tr
= temp_ref
;
1740 if(spriv
->picture
.mpeg1
== 0)
1742 if(spriv
->telecine
&& pce_ptr
)
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;
1752 if(! spriv
->vframes
)
1755 spriv
->last_dts
+= spriv
->delta_pts
;
1756 spriv
->last_pts
+= spriv
->nom_delta_pts
*(frames_diff
-1) + spriv
->delta_pts
;
1758 ret
= add_frame(spriv
, spriv
->delta_pts
, s
->buffer
, len
, pt
, spriv
->last_dts
, spriv
->last_pts
);
1761 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "\r\nPARSE_MPEG12: add_frames(%d) failed, exit\r\n", len
);
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
);
1771 int64_t diff
= spriv
->last_dts
- spriv
->last_pts
;
1775 n
= spriv
->framebuf_used
- 1;
1777 for(j
= n
; j
>= 0; j
--)
1779 if(spriv
->framebuf
[j
].pts
>= spriv
->last_pts
)
1781 spriv
->framebuf
[j
].pts
+= diff
;
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
;
1792 mp_msg(MSGT_MUXER
, MSGL_DBG2
,"parse_mpeg12_video, return %u\n", (uint32_t) len
);
1797 static uint64_t fix_mp4_frame_duration(muxer_headers_t
*vpriv
)
1799 uint64_t mn
, md
, mx
, diff
;
1802 mn
= mx
= vpriv
->framebuf
[0].pts
;
1803 for(i
= 0; i
< 3; i
++)
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
;
1814 if((vpriv
->framebuf
[i
].pts
> mn
) && (vpriv
->framebuf
[i
].pts
< mx
))
1815 md
= vpriv
->framebuf
[i
].pts
;
1818 if(mx
- md
> md
- mn
)
1823 mp_msg(MSGT_DECVIDEO
,MSGL_DBG2
, "MIN: %"PRIu64
", mid: %"PRIu64
", max: %"PRIu64
", diff: %"PRIu64
"\n", mn
, md
, mx
, diff
);
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));
1840 static size_t parse_mpeg4_video(muxer_stream_t
*s
, muxer_priv_t
*priv
, muxer_headers_t
*vpriv
, float fps
, size_t len
)
1843 int64_t delta_pts
=0;
1847 mp_msg(MSGT_MUXER
, MSGL_DBG2
,"parse_mpeg4_video, len=%u\n", (uint32_t) len
);
1850 mp_msg(MSGT_MUXER
, MSGL_ERR
,"Frame too short: %d, exit!\n", len
);
1855 while(ptr
< len
- 5)
1857 if(s
->buffer
[ptr
] != 0 || s
->buffer
[ptr
+1] != 0 || s
->buffer
[ptr
+2] != 1)
1863 if(s
->buffer
[ptr
+3] >= 0x20 && s
->buffer
[ptr
+3] <= 0x2f) //VOL
1865 mp4_header_process_vol(&(vpriv
->picture
), &(s
->buffer
[ptr
+4]));
1867 else if(s
->buffer
[ptr
+3] == 0xb3) //gov
1869 //fprintf(stderr, "\nGOV\n");
1871 else if(s
->buffer
[ptr
+3] == 0xb6) //vop
1874 mp4_header_process_vop(&(vpriv
->picture
), &(s
->buffer
[ptr
+4]));
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
;
1882 delta_pts
= (27000000 * (int64_t) delta
) / vpriv
->picture
.timeinc_resolution
;
1883 //warning, it seems that packed bops can lead to delta == 0
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
);
1890 vpriv
->last_tr
= vpriv
->picture
.timeinc_unit
;
1900 vpriv
->last_dts
+= vpriv
->frame_duration
;
1901 vpriv
->last_pts
+= delta_pts
;
1904 ret
= add_frame(vpriv
, delta_pts
, s
->buffer
, len
, pt
, vpriv
->last_dts
, vpriv
->last_pts
);
1907 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "\r\nPARSE_MPEG4: add_frames(%d) failed, exit\r\n", len
);
1911 if(!vpriv
->frame_duration
&& vpriv
->framebuf_used
== 3)
1913 vpriv
->frame_duration
= fix_mp4_frame_duration(vpriv
);
1914 if(vpriv
->frame_duration
)
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;
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));
1934 static int fill_last_frame(muxer_headers_t
*spriv
, uint8_t *ptr
, int len
)
1941 if(spriv
->framebuf_used
== 0)
1942 idx
= spriv
->framebuf_used
;
1944 idx
= spriv
->framebuf_used
- 1;
1946 if(spriv
->framebuf
[idx
].alloc_size
< spriv
->framebuf
[idx
].size
+ len
)
1948 if(spriv
->framebuf
[idx
].size
> SIZE_MAX
- (size_t)len
)
1950 spriv
->framebuf
[idx
].buffer
= (uint8_t*) realloc(spriv
->framebuf
[idx
].buffer
, spriv
->framebuf
[idx
].size
+ len
);
1951 if(! spriv
->framebuf
[idx
].buffer
)
1953 spriv
->framebuf
[idx
].alloc_size
= spriv
->framebuf
[idx
].size
+ len
;
1956 memcpy(&(spriv
->framebuf
[idx
].buffer
[spriv
->framebuf
[idx
].size
]), ptr
, len
);
1957 spriv
->framebuf
[idx
].size
+= len
;
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
)
1966 idx
= spriv
->framebuf_used
;
1967 if(idx
>= spriv
->framebuf_cnt
)
1969 spriv
->framebuf
= (mpeg_frame_t
*) realloc_struct(spriv
->framebuf
, (spriv
->framebuf_cnt
+1), sizeof(mpeg_frame_t
));
1970 if(spriv
->framebuf
== NULL
)
1972 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't realloc frame buffer(idx), abort\n");
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;
1980 spriv
->framebuf
[spriv
->framebuf_cnt
].buffer
= (uint8_t*) malloc(len
);
1981 if(spriv
->framebuf
[spriv
->framebuf_cnt
].buffer
== NULL
)
1983 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't realloc frame buffer(frame), abort\n");
1986 spriv
->framebuf
[spriv
->framebuf_cnt
].alloc_size
= len
;
1987 spriv
->framebuf_cnt
++;
1990 if(spriv
->framebuf
[idx
].alloc_size
< spriv
->framebuf
[idx
].size
+ len
)
1992 if(spriv
->framebuf
[idx
].size
> SIZE_MAX
- (size_t)len
)
1994 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Size overflow, couldn't realloc frame buffer(frame), abort\n");
1997 spriv
->framebuf
[idx
].buffer
= realloc(spriv
->framebuf
[idx
].buffer
, spriv
->framebuf
[idx
].size
+ len
);
1998 if(spriv
->framebuf
[idx
].buffer
== NULL
)
2000 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't realloc frame buffer(frame), abort\n");
2003 spriv
->framebuf
[idx
].alloc_size
= spriv
->framebuf
[idx
].size
+ len
;
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
;
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
);
2020 static int analyze_mpa(muxer_stream_t
*s
)
2022 int i
= 0, len
, max
, chans
, srate
, spf
, layer
;
2023 int score
[4] = {0, 0, 0, 0};
2025 while(i
< s
->b_buffer_len
+ 3)
2027 if(s
->b_buffer
[i
] == 0xFF && ((s
->b_buffer
[i
+1] & 0xE0) == 0xE0))
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
))
2041 for(i
= 1; i
<= 3; i
++)
2050 return layer
; //actual layer with the highest score
2053 int aac_parse_frame(uint8_t *buf
, int *srate
, int *num
);
2055 static int parse_audio(muxer_stream_t
*s
, int finalize
, unsigned int *nf
, double *timer
, double delay
, int drop
)
2057 int i
, j
, len
, chans
, srate
, spf
, layer
, dummy
, tot
, num
, frm_idx
;
2059 unsigned int frames
;
2062 muxer_headers_t
*spriv
= (muxer_headers_t
*) s
->priv
;
2064 i
= tot
= frames
= 0;
2069 switch(s
->wf
->wFormatTag
)
2074 if(i
+ 3 >= s
->b_buffer_len
)
2080 if(s
->b_buffer
[i
] == 0xFF && ((s
->b_buffer
[i
+1] & 0xE0) == 0xE0))
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
)
2086 dur
= (double) spf
/ (double) srate
;
2087 idur
= (27000000ULL * spf
) / srate
;
2097 if(i
+ 6 >= s
->b_buffer_len
)
2103 if(s
->b_buffer
[i
] == 0x0B && s
->b_buffer
[i
+1] == 0x77)
2106 #ifdef CONFIG_LIBA52
2107 len
= a52_syncinfo(&(s
->b_buffer
[i
]), &dummy
, &srate
, &dummy
);
2109 len
= mp_a52_framesize(&(s
->b_buffer
[i
]), &srate
);
2111 if((len
> 0) && (srate
== s
->wf
->nSamplesPerSec
) && (i
+ len
<= s
->b_buffer_len
))
2113 dur
= (double) 1536 / (double) srate
;
2114 idur
= (27000000ULL * 1536) / srate
;
2125 if(i
+ 7 >= s
->b_buffer_len
)
2131 if(s
->b_buffer
[i
] == 0xFF && ((s
->b_buffer
[i
+1] & 0xF6) == 0xF0))
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
))
2136 dur
= (double) 1024 / (double) srate
;
2137 idur
= (27000000ULL * 1024 * num
) / srate
;
2154 spriv
->timer
+= dur
;
2155 if(spriv
->drop_delayed_frames
&& delay
< 0 && spriv
->timer
<= -delay
)
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
);
2167 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't add audio frame buffer(frame), abort\n");
2170 for(j
= frm_idx
; j
< spriv
->framebuf_cnt
; j
++)
2171 spriv
->framebuf
[j
].pts
= spriv
->last_pts
;
2172 spriv
->last_pts
+= idur
;
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;
2191 frm_idx
= add_frame(spriv
, 0, s
->b_buffer
, s
->b_buffer_len
, 0, spriv
->last_pts
, spriv
->last_pts
);
2194 for(j
= frm_idx
; j
< spriv
->framebuf_cnt
; j
++)
2195 spriv
->framebuf
[j
].pts
= spriv
->last_pts
;
2200 *timer
= spriv
->timer
;
2205 static void fix_parameters(muxer_stream_t
*stream
)
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
;
2213 if(stream
->type
== MUXER_TYPE_AUDIO
)
2215 stream_format
= stream
->wf
->wFormatTag
;
2216 spriv
->is_ready
= 1;
2218 spriv
->max_buffer_size
= conf_abuf_size
*1024;
2220 spriv
->max_buffer_size
= 4*1024;
2221 if(stream
->wf
->wFormatTag
== AUDIO_A52
)
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
2228 spriv
->max_buffer_size
= 16*1024;
2230 else if(stream
->wf
->wFormatTag
== AUDIO_AAC1
|| stream
->wf
->wFormatTag
== AUDIO_AAC2
)
2232 else if(stream
->wf
->wFormatTag
== AUDIO_MP2
|| stream
->wf
->wFormatTag
== AUDIO_MP3
)
2233 spriv
->is_ready
= 0;
2237 stream_format
= stream
->bih
->biCompression
;
2239 spriv
->max_buffer_size
= conf_vbuf_size
*1024;
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;
2249 spriv
->max_buffer_size
= 232*1024; //no profile => unconstrained :) FIXME!!!
2252 if(is_mpeg4(stream
->bih
->biCompression
))
2253 spriv
->is_ready
= 0;
2255 spriv
->is_ready
= 1;
2257 if(!is_mpeg1(stream_format
) && !is_mpeg2(stream_format
))
2261 if(priv
->is_genmpeg2
&& needs_psm
)
2264 add_to_psm(priv
, spriv
->id
, stream_format
);
2265 priv
->psm_streams_cnt
++;
2270 static void mpegfile_write_chunk(muxer_stream_t
*s
,size_t len
,unsigned int flags
, double dts_arg
, double pts_arg
)
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
;
2278 uint32_t stream_format
, nf
;
2280 if(s
->buffer
== NULL
|| len
== -1)
2283 if (s
->type
== MUXER_TYPE_VIDEO
)
2284 { // try to recognize frame type...
2285 fps
= (float) s
->h
.dwRate
/ (float) s
->h
.dwScale
;
2287 stream_format
= s
->bih
->biCompression
;
2288 if(! spriv
->vframes
)
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
);
2294 if(is_mpeg1(stream_format
) || is_mpeg2(stream_format
))
2296 spriv
->is_mpeg12
= 1;
2297 spriv
->is_ready
= 1;
2299 sz
= parse_mpeg12_video(s
, priv
, spriv
, fps
, len
);
2302 tmp
= (uint64_t) (27000000.0f
/ fps
);
2303 spriv
->last_pts
+= tmp
;
2304 spriv
->last_dts
+= tmp
;
2307 else if(is_mpeg4(stream_format
))
2309 spriv
->is_mpeg12
= 0;
2310 spriv
->telecine
= 0;
2312 sz
= parse_mpeg4_video(s
, priv
, spriv
, fps
, len
);
2315 tmp
= (uint64_t) (27000000.0f
/ fps
);
2316 spriv
->last_pts
+= tmp
;
2317 spriv
->last_dts
+= tmp
;
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
);
2324 { // MUXER_TYPE_AUDIO
2327 stream_format
= s
->wf
->wFormatTag
;
2329 if(s
->b_buffer_size
- s
->b_buffer_len
< len
)
2333 if(s
->b_buffer_len
> SIZE_MAX
- len
)
2335 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "\nFATAL! couldn't realloc, integer overflow\n");
2338 tmp
= realloc(s
->b_buffer
, len
+ s
->b_buffer_len
);
2341 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "\nFATAL! couldn't realloc %d bytes\n", len
+ s
->b_buffer_len
);
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
);
2349 memcpy(&(s
->b_buffer
[s
->b_buffer_ptr
+ s
->b_buffer_len
]), s
->buffer
, len
);
2350 s
->b_buffer_len
+= len
;
2352 if(!spriv
->is_ready
)
2354 if(s
->b_buffer_len
>= 32*1024)
2356 spriv
->mpa_layer
= analyze_mpa(s
);
2357 spriv
->is_ready
= 1;
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
);
2369 flush_buffers(muxer
, 0);
2373 static void mpegfile_write_index(muxer_t
*muxer
)
2377 muxer_priv_t
*priv
= (muxer_priv_t
*) muxer
->priv
;
2379 mp_msg(MSGT_MUXER
, MSGL_INFO
, MSGTR_WritingTrailer
);
2381 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
2383 if(muxer
->streams
[i
]->type
== MUXER_TYPE_AUDIO
)
2384 parse_audio(muxer
->streams
[i
], 1, &nf
, &fake_timer
, priv
->init_adelay
, priv
->drop
);
2386 while(flush_buffers(muxer
, 0) > 0);
2387 flush_buffers(muxer
, 1);
2388 if(priv
->is_genmpeg1
|| priv
->is_genmpeg2
)
2391 write_mpeg_pack(muxer
, NULL
, muxer
->stream
, 1); //insert fake Nav Packet
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
);
2397 static void mpegfile_write_header(muxer_t
*muxer
)
2399 muxer_priv_t
*priv
= (muxer_priv_t
*) muxer
->priv
;
2401 mp_msg(MSGT_MUXER
, MSGL_INFO
, MSGTR_WritingHeader
);
2403 priv
->headers_cnt
++;
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)))
2408 write_mpeg_pack(muxer
, NULL
, muxer
->stream
, 0);
2409 priv
->update_system_header
= 0;
2415 static void setup_sys_params(muxer_priv_t
*priv
)
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);
2423 priv
->sys_info
.cnt
= 4;
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;
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;
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;
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;
2441 else if(priv
->is_xvcd
|| priv
->is_xsvcd
)
2443 int v
= (conf_vbuf_size
? conf_vbuf_size
: (priv
->is_xvcd
? 46: 230));
2444 int a1
= (conf_abuf_size
? conf_abuf_size
: 4);
2446 priv
->sys_info
.cnt
= 2;
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;
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;
2457 priv
->sys_info
.cnt
= 0;
2460 /* excerpt from DGPulldown Copyright (C) 2005-2006, Donald Graft */
2461 static void generate_flags(uint8_t *bff_mask
, int source
, int target
)
2463 unsigned int i
, trfp
;
2465 unsigned char ormask
[4] = {0x0, 0x2, 0x80, 0x82};
2467 dfl
= (target
- source
) << 1;
2471 for(i
= 0; i
< MAX_PATTERN_LENGTH
; i
++)
2477 bff_mask
[i
] = ormask
[trfp
+ 1];
2481 bff_mask
[i
] = ormask
[trfp
];
2485 int muxer_init_muxer_mpeg(muxer_t
*muxer
)
2488 priv
= (muxer_priv_t
*) calloc(1, sizeof(muxer_priv_t
));
2491 priv
->update_system_header
= 1;
2493 //calloc() already zero-ed all flags, so we assign only the ones we need
2495 if(conf_mux
!= NULL
)
2497 if(! strcasecmp(conf_mux
, "mpeg1"))
2499 priv
->mux
= MUX_MPEG1
;
2500 priv
->packet_size
= 2048;
2501 priv
->is_genmpeg1
= 1;
2502 priv
->muxrate
= 1800 * 125; //Constrained parameters
2504 else if(! strcasecmp(conf_mux
, "dvd"))
2506 priv
->mux
= MUX_MPEG2
;
2508 priv
->packet_size
= 2048;
2509 priv
->muxrate
= 10080 * 125;
2511 else if(! strcasecmp(conf_mux
, "xsvcd"))
2513 priv
->mux
= MUX_MPEG2
;
2515 priv
->packet_size
= 2324;
2516 priv
->muxrate
= 150*2324;
2517 priv
->ts_allframes
= 1;
2519 else if(! strcasecmp(conf_mux
, "xvcd"))
2521 priv
->mux
= MUX_MPEG1
;
2523 priv
->packet_size
= 2324;
2524 priv
->muxrate
= 75*2352;
2525 priv
->ts_allframes
= 1;
2527 else if(! strcasecmp(conf_mux
, "pes1"))
2529 priv
->mux
= MUX_MPEG1
;
2531 priv
->packet_size
= 2048;
2532 priv
->muxrate
= 10080 * 125;
2533 priv
->ts_allframes
= 1;
2535 else if(! strcasecmp(conf_mux
, "pes2"))
2537 priv
->mux
= MUX_MPEG2
;
2539 priv
->packet_size
= 2048;
2540 priv
->muxrate
= 10080 * 125;
2541 priv
->ts_allframes
= 1;
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
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
);
2564 if(conf_vaspect
> 0)
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
;
2576 mp_msg(MSGT_MUXER
, MSGL_ERR
, "ERROR: unrecognized aspect %.3f\n", conf_vaspect
);
2579 priv
->vframerate
= 0; // no change
2580 if(conf_telecine
&& conf_vframerate
> 0)
2582 mp_msg(MSGT_MUXER
, MSGL_ERR
, "ERROR: options 'telecine' and 'vframerate' are mutually exclusive, vframerate disabled\n");
2583 conf_vframerate
= 0;
2586 if(conf_telecine
== TELECINE_FILM2PAL
)
2588 if(conf_telecine_src
==0.0f
) conf_telecine_src
= 24000.0/1001.0;
2589 conf_telecine_dest
= 25;
2590 conf_telecine
= TELECINE_DGPULLDOWN
;
2592 else if(conf_telecine
== PULLDOWN32
)
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
;
2599 if(conf_telecine_src
>0 && conf_telecine_dest
>0 && conf_telecine_src
< conf_telecine_dest
)
2603 sfps
= (int) (conf_telecine_src
* 1001 + 0.5);
2604 tfps
= (int) (conf_telecine_dest
* 1001 + 0.5);
2605 if(sfps
% 2 || tfps
% 2)
2611 if(((tfps
- sfps
)>>1) > sfps
)
2613 mp_msg(MSGT_MUXER
, MSGL_ERR
, "ERROR! Framerate increment must be <= 1.5, telecining disabled\n");
2618 generate_flags(priv
->bff_mask
, sfps
, tfps
);
2619 conf_telecine
= TELECINE_DGPULLDOWN
;
2620 conf_vframerate
= conf_telecine_dest
;
2628 fps
= (int) (conf_vframerate
* 1001 + 0.5);
2632 priv
->vframerate
= FRAMERATE_23976
;
2635 priv
->vframerate
= FRAMERATE_24
;
2638 priv
->vframerate
= FRAMERATE_25
;
2641 priv
->vframerate
= FRAMERATE_2997
;
2644 priv
->vframerate
= FRAMERATE_30
;
2647 priv
->vframerate
= FRAMERATE_50
;
2650 priv
->vframerate
= FRAMERATE_5994
;
2653 priv
->vframerate
= FRAMERATE_60
;
2657 mp_msg(MSGT_MUXER
, MSGL_ERR
, "WRONG FPS: %d/1000, ignoring\n", fps
);
2659 mp_msg(MSGT_MUXER
, MSGL_ERR
, "DISABLED TELECINING\n");
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
2671 if(priv
->vaspect
|| priv
->vframerate
|| priv
->vwidth
|| priv
->vheight
|| priv
->vbitrate
|| priv
->panscan_width
|| priv
->panscan_height
)
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
]);
2683 mp_msg(MSGT_MUXER
, MSGL_INFO
, " aspect ratio to %s", aspect_ratios
[priv
->vaspect
]);
2685 mp_msg(MSGT_MUXER
, MSGL_INFO
, " bitrate to %u", conf_vbitrate
);
2686 mp_msg(MSGT_MUXER
, MSGL_INFO
, "\n");
2689 priv
->has_video
= priv
->has_audio
= 0;
2691 muxer
->sysrate
= priv
->muxrate
; // initial muxrate = constrained stream parameter
2692 priv
->scr
= muxer
->file_end
= 0;
2694 if(conf_init_vdelay
&& conf_drop
)
2696 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\nmuxer_mpg, :drop and :vdelay used together are not supported, exiting\n");
2699 if(conf_init_adelay
)
2700 priv
->init_adelay
= - (double) conf_init_adelay
/ (double) 1000.0;
2702 priv
->drop
= conf_drop
;
2704 priv
->buff
= (uint8_t *) malloc(priv
->packet_size
);
2705 if((priv
->buff
== NULL
))
2707 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\nCouldn't allocate %d bytes, exit\n", priv
->packet_size
);
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
;