2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 #include <sys/types.h>
28 #include "aviheader.h"
31 #include "stream/stream.h"
42 #include <a52dec/a52.h>
45 #define PACK_HEADER_START_CODE 0x01ba
46 #define SYSTEM_HEADER_START_CODE 0x01bb
47 #define PSM_START_CODE 0x01bc
49 #define PES_PRIVATE1 0x01bd
50 #define PES_PRIVATE2 0x01bf
55 #define VIDEO_MPEG1 0x10000001
56 #define VIDEO_MPEG2 0x10000002
57 #define AUDIO_MP2 0x50
58 #define AUDIO_MP3 0x55
59 #define AUDIO_A52 0x2000
60 #define AUDIO_LPCM 0x10001 /* only a placeholder at the moment */
61 #define AUDIO_AAC1 0x706D
62 //#define AUDIO_AAC2 (short) mmioFOURCC('m','p','4','a')
63 #define AUDIO_AAC2 0x504D
68 #define ASPECT_2_21_1 4
70 #define FRAMERATE_23976 1
71 #define FRAMERATE_24 2
72 #define FRAMERATE_25 3
73 #define FRAMERATE_2997 4
74 #define FRAMERATE_30 5
75 #define FRAMERATE_50 6
76 #define FRAMERATE_5994 7
77 #define FRAMERATE_60 8
79 static char ftypes
[] = {'?', 'I', 'P', 'B'};
80 #define FTYPE(x) (ftypes[(x)])
82 static const char *framerates
[] = {
83 "unchanged", "23.976", "24", "25", "29.97", "30", "50", "59.94", "60"
86 static const char *aspect_ratios
[] = {
87 "unchanged", "1/1", "4/3", "16/9", "2.21/1"
90 static char *conf_mux
= "mpeg2";
91 static uint16_t conf_packet_size
= 0; //dvd
92 static uint32_t conf_muxrate
= 0; //kb/s
93 static float conf_vaspect
= 0;
94 static float conf_vframerate
= 0;
95 static uint32_t conf_vwidth
= 0, conf_vheight
= 0, conf_panscan_width
= 0, conf_panscan_height
= 0;
96 static uint32_t conf_vbitrate
= 0;
97 static int conf_init_vpts
= 200, conf_init_apts
= 200;
98 static int conf_ts_allframes
= 0;
99 static int conf_init_adelay
= 0, conf_init_vdelay
= 0;
100 static int conf_abuf_size
= 0;
101 static int conf_vbuf_size
= 0;
102 static int conf_drop
= 0;
103 static int conf_telecine
= 0;
104 static int conf_interleaving2
= 0;
105 static float conf_telecine_src
= 0;
106 static float conf_telecine_dest
= 0;
119 uint64_t pts
, dts
, idur
;
120 uint32_t pos
; //start offset for the frame
124 uint8_t cnt
; // how many entries we use
129 } streams
[50]; //16 video + 16 audio mpa + 16 audio private + bd/bf for dvd
133 uint8_t cnt
; // how many entries we use
138 } streams
[50]; //16 video + 16 audio mpa + 16 audio private + bd/bf for dvd
148 uint64_t frame_dts
, frame_pts
;
156 uint16_t packet_size
;
157 int is_dvd
, is_xvcd
, is_xsvcd
, is_genmpeg1
, is_genmpeg2
, rawpes
, ts_allframes
, has_video
, has_audio
;
158 int update_system_header
, use_psm
;
159 off_t headers_size
, data_size
;
162 uint64_t last_psm_scr
;
165 uint32_t headers_cnt
;
169 //video patching parameters
170 uint8_t vaspect
, vframerate
;
171 uint16_t vwidth
, vheight
, panscan_width
, panscan_height
;
173 int patch_seq
, patch_sde
;
176 //2 million frames are enough
177 #define MAX_PATTERN_LENGTH 2000000
178 uint8_t bff_mask
[MAX_PATTERN_LENGTH
];
183 int has_pts
, has_dts
, pes_is_aligned
, type
, min_pes_hlen
;
185 uint64_t pts
, last_pts
, last_dts
, dts
, size
, frame_duration
, delta_pts
, nom_delta_pts
, last_saved_pts
;
186 uint32_t buffer_size
;
187 double delta_clock
, timer
;
188 int drop_delayed_frames
;
189 mpeg_frame_t
*framebuf
;
190 uint16_t framebuf_cnt
;
191 uint16_t framebuf_used
;
194 uint8_t id
, is_mpeg12
, telecine
;
196 int64_t display_frame
;
197 mp_mpeg_header_t picture
;
199 buffer_track_t
*buffer_track
;
200 int track_pos
, track_len
, track_bufsize
; //pos and len control the array, bufsize is the size of the buffer
202 int pack_offset
, pes_offset
, pes_set
, payload_offset
;
204 int last_frame_rest
; //the rest of the previous frame
210 #define TELECINE_FILM2PAL 2
211 #define TELECINE_DGPULLDOWN 3
213 const m_option_t mpegopts_conf
[] = {
214 {"format", &(conf_mux
), CONF_TYPE_STRING
, M_OPT_GLOBAL
, 0 ,0, NULL
},
215 {"size", &(conf_packet_size
), CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 0, 65535, NULL
},
216 {"muxrate", &(conf_muxrate
), CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 0, 12000000, NULL
}, //12 Mb/s
217 {"vaspect", &(conf_vaspect
), CONF_TYPE_FLOAT
, M_OPT_GLOBAL
, 0, 0, NULL
},
218 {"vframerate", &(conf_vframerate
), CONF_TYPE_FLOAT
, M_OPT_GLOBAL
, 0, 0, NULL
},
219 {"vwidth", &(conf_vwidth
), CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 1, 4095, NULL
},
220 {"vheight", &(conf_vheight
), CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 1, 4095, NULL
},
221 {"vpswidth", &(conf_panscan_width
), CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 1, 16383, NULL
},
222 {"vpsheight", &(conf_panscan_height
), CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 1, 16383, NULL
},
223 {"vbitrate", &(conf_vbitrate
), CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 1, 104857599, NULL
},
224 {"vdelay", &conf_init_vdelay
, CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 0, 32760, NULL
},
225 {"adelay", &conf_init_adelay
, CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 0, 32760, NULL
},
226 {"vbuf_size", &conf_vbuf_size
, CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 40, 1194, NULL
},
227 {"abuf_size", &conf_abuf_size
, CONF_TYPE_INT
, M_OPT_GLOBAL
|M_OPT_RANGE
, 4, 64, NULL
},
228 {"drop", &conf_drop
, CONF_TYPE_FLAG
, M_OPT_GLOBAL
, 0, 1, NULL
},
229 {"tsaf", &conf_ts_allframes
, CONF_TYPE_FLAG
, M_OPT_GLOBAL
, 0, 1, NULL
},
230 {"telecine", &conf_telecine
, CONF_TYPE_FLAG
, M_OPT_GLOBAL
, 0, PULLDOWN32
, NULL
},
231 {"interleaving2", &conf_interleaving2
, CONF_TYPE_FLAG
, M_OPT_GLOBAL
, 0, 1, NULL
},
232 {"film2pal", &conf_telecine
, CONF_TYPE_FLAG
, M_OPT_GLOBAL
, 0, TELECINE_FILM2PAL
, NULL
},
233 {"tele_src", &(conf_telecine_src
), CONF_TYPE_FLOAT
, M_OPT_GLOBAL
, 0, 0, NULL
},
234 {"tele_dest", &(conf_telecine_dest
), CONF_TYPE_FLOAT
, M_OPT_GLOBAL
, 0, 0, NULL
},
235 {NULL
, NULL
, 0, 0, 0, 0, NULL
}
238 static void fix_audio_sys_header(muxer_priv_t
*priv
, uint8_t id
, uint8_t newid
, uint32_t size
)
242 for(i
= 0; i
< priv
->sys_info
.cnt
; i
++)
244 if(priv
->sys_info
.streams
[i
].id
== id
)
246 priv
->sys_info
.streams
[i
].id
= newid
;
247 priv
->sys_info
.streams
[i
].type
= 1;
248 priv
->sys_info
.streams
[i
].bufsize
= size
;
253 static inline int is_mpeg1(uint32_t x
)
257 (x
== mmioFOURCC('m','p','g','1')) ||
258 (x
== mmioFOURCC('M','P','G','1'));
261 static inline int is_mpeg2(uint32_t x
)
265 (x
== mmioFOURCC('m','p','g','2')) ||
266 (x
== mmioFOURCC('M','P','G','2')) ||
267 (x
== mmioFOURCC('m','p','e','g')) ||
268 (x
== mmioFOURCC('M','P','E','G'));
271 static inline int is_mpeg4(uint32_t x
)
275 (x
== mmioFOURCC('d','i','v','x')) ||
276 (x
== mmioFOURCC('D','I','V','X')) ||
277 (x
== mmioFOURCC('x','v','i','d')) ||
278 (x
== mmioFOURCC('X','V','I','D')) ||
279 (x
== mmioFOURCC('X','v','i','D')) ||
280 (x
== mmioFOURCC('x','v','i','x')) ||
281 (x
== mmioFOURCC('X','V','I','X')) ||
282 (x
== mmioFOURCC('m','p','4','v')) ||
283 (x
== mmioFOURCC('M','P','4','V')) ||
284 (x
== mmioFOURCC('F', 'M','P','4')) ||
285 (x
== mmioFOURCC('f', 'm','p','4')) ||
286 (x
== mmioFOURCC('D', 'X','5','0')) ||
287 (x
== mmioFOURCC('d', 'x','5','0'));
291 static uint32_t CalcCRC32(uint8_t *buff
, uint32_t size
)
293 uint32_t i
, j
, CRCTab
[256], crc
;
295 for(i
= 0;i
< 256; i
++)
297 for(crc
= i
, j
= 0; j
< 8; j
++)
298 crc
= (crc
& 1) ? (crc
>> 1)^0xEDB88320L
: (crc
>> 1);
304 for(i
= 0; i
< size
; i
++)
305 crc
= (crc
<< 8) ^ CRCTab
[((crc
>> 24) ^ buff
[i
]) & 0xff];
311 static void add_to_psm(muxer_priv_t
*priv
, uint8_t id
, uint32_t format
)
315 i
= priv
->psm_info
.cnt
;
316 priv
->psm_info
.streams
[i
].id
= id
;
317 priv
->psm_info
.streams
[i
].format
= format
;
320 priv
->psm_info
.streams
[i
].type
= 0x01;
321 else if(is_mpeg2(format
))
322 priv
->psm_info
.streams
[i
].type
= 0x02;
323 else if(is_mpeg4(format
))
324 priv
->psm_info
.streams
[i
].type
= 0x10;
325 else if(format
== AUDIO_MP2
|| format
== AUDIO_MP3
)
326 priv
->psm_info
.streams
[i
].type
= 0x03;
327 else if(format
== AUDIO_AAC1
|| format
== AUDIO_AAC2
)
328 priv
->psm_info
.streams
[i
].type
= 0x0f;
330 priv
->psm_info
.streams
[i
].type
= 0x81;
332 if(format
== AUDIO_A52
)
333 memcpy((char*) &(priv
->psm_info
.streams
[i
].format
), "AC-3", 4);
335 priv
->psm_info
.cnt
++;
339 static mpeg_frame_t
*init_frames(uint16_t num
, size_t size
)
344 tmp
= calloc(num
, sizeof(mpeg_frame_t
));
348 for(i
=0; i
< num
; i
++)
350 tmp
[i
].buffer
= calloc(1, size
);
351 if(tmp
[i
].buffer
== NULL
)
355 tmp
[i
].alloc_size
= size
;
362 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
);
364 static muxer_stream_t
* mpegfile_new_stream(muxer_t
*muxer
,int type
){
365 muxer_priv_t
*priv
= (muxer_priv_t
*) muxer
->priv
;
367 muxer_headers_t
*spriv
;
369 if (!muxer
) return NULL
;
370 if(muxer
->avih
.dwStreams
>=MUXER_MAX_STREAMS
){
371 mp_msg(MSGT_MUXER
, MSGL_ERR
, "Too many streams! increase MUXER_MAX_STREAMS !\n");
375 case MUXER_TYPE_VIDEO
:
376 if (muxer
->num_videos
>= 16) {
377 mp_msg(MSGT_MUXER
, MSGL_ERR
, "MPEG files can't contain more than 16 video streams!\n");
381 case MUXER_TYPE_AUDIO
:
382 if (muxer
->num_audios
>= 16) {
383 mp_msg(MSGT_MUXER
, MSGL_ERR
, "MPEG files can't contain more than 16 audio streams!\n");
388 mp_msg(MSGT_MUXER
, MSGL_ERR
, "Unknown stream type!\n");
391 s
= calloc(1, sizeof(muxer_stream_t
));
392 if(!s
) return NULL
; // no mem!?
393 if (!(s
->b_buffer
= malloc(priv
->packet_size
)))
395 s
->b_buffer_size
= priv
->packet_size
;
398 s
->priv
= calloc(1, sizeof(muxer_headers_t
));
401 spriv
= (muxer_headers_t
*) s
->priv
;
402 spriv
->pack
= malloc(priv
->packet_size
);
405 spriv
->buffer_track
= calloc(1, 4096*sizeof(buffer_track_t
));
406 if(!spriv
->buffer_track
)
408 spriv
->track_pos
= 0;
409 spriv
->track_len
= 4096;
410 muxer
->streams
[muxer
->avih
.dwStreams
]=s
;
412 s
->id
=muxer
->avih
.dwStreams
;
415 if (type
== MUXER_TYPE_VIDEO
) {
417 spriv
->last_pts
= conf_init_vpts
* 90 * 300;
418 if(conf_init_vdelay
) {
419 spriv
->last_dts
+= conf_init_vdelay
* 90 * 300;
420 spriv
->last_pts
+= conf_init_vdelay
* 90 * 300;
422 spriv
->id
= 0xe0 + muxer
->num_videos
;
423 s
->ckid
= be2me_32 (0x100 + spriv
->id
);
424 if(priv
->is_genmpeg1
|| priv
->is_genmpeg2
) {
425 int v
= (conf_vbuf_size
? conf_vbuf_size
*1024 :
426 (s
->h
.dwSuggestedBufferSize
? s
->h
.dwSuggestedBufferSize
: 46*1024));
427 int n
= priv
->sys_info
.cnt
;
429 priv
->sys_info
.streams
[n
].id
= spriv
->id
;
430 priv
->sys_info
.streams
[n
].type
= 1;
431 priv
->sys_info
.streams
[n
].bufsize
= v
;
432 priv
->sys_info
.cnt
++;
436 s
->h
.fccType
=streamtypeVIDEO
;
437 if(!muxer
->def_v
) muxer
->def_v
=s
;
438 spriv
->framebuf_cnt
= 30;
439 spriv
->framebuf_used
= 0;
440 spriv
->framebuf
= init_frames(spriv
->framebuf_cnt
, (size_t) 5000);
441 if(spriv
->framebuf
== NULL
) {
442 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't allocate initial frames structure, abort!\n");
445 memset(&(spriv
->picture
), 0, sizeof(spriv
->picture
));
447 spriv
->min_pes_hlen
= 18;
448 else if(priv
->is_xsvcd
)
449 spriv
->min_pes_hlen
= 22;
450 spriv
->telecine
= conf_telecine
;
451 mp_msg (MSGT_MUXER
, MSGL_DBG2
, "Added video stream %d, ckid=%X\n", muxer
->num_videos
, s
->ckid
);
452 } else { // MUXER_TYPE_AUDIO
454 spriv
->drop_delayed_frames
= conf_drop
;
455 spriv
->last_pts
= conf_init_apts
* 90 * 300;
456 if(conf_init_adelay
&& ! spriv
->drop_delayed_frames
)
457 spriv
->last_pts
+= conf_init_adelay
* 90 * 300;
458 spriv
->pts
= spriv
->last_pts
;
459 spriv
->id
= 0xc0 + muxer
->num_audios
;
460 s
->ckid
= be2me_32 (0x100 + spriv
->id
);
461 if(priv
->is_genmpeg1
|| priv
->is_genmpeg2
) {
462 int a1
= (conf_abuf_size
? conf_abuf_size
*1024 :
463 (s
->h
.dwSuggestedBufferSize
? s
->h
.dwSuggestedBufferSize
: 4*1024));
464 int n
= priv
->sys_info
.cnt
;
466 priv
->sys_info
.streams
[n
].id
= spriv
->id
;
467 priv
->sys_info
.streams
[n
].type
= 0;
468 priv
->sys_info
.streams
[n
].bufsize
= a1
;
469 priv
->sys_info
.cnt
++;
472 spriv
->min_pes_hlen
= 13;
473 else if(priv
->is_xsvcd
)
474 spriv
->min_pes_hlen
= 17;
478 s
->h
.fccType
=streamtypeAUDIO
;
480 spriv
->framebuf_cnt
= 30;
481 spriv
->framebuf_used
= 0;
482 spriv
->framebuf
= init_frames(spriv
->framebuf_cnt
, (size_t) 2048);
483 if(spriv
->framebuf
== NULL
) {
484 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't allocate initial frames structure, abort!\n");
488 mp_msg (MSGT_MUXER
, MSGL_DBG2
, "Added audio stream %d, ckid=%X\n", s
->id
- muxer
->num_videos
+ 1, s
->ckid
);
490 muxer
->avih
.dwStreams
++;
501 if(spriv
->buffer_track
)
502 free(spriv
->buffer_track
);
512 static void write_mpeg_ts(unsigned char *b
, uint64_t ts
, uint8_t mod
) {
514 b
[0] = mod
| ((ts
>> 29) & 0xf) | 1;
515 b
[1] = (ts
>> 22) & 0xff;
516 b
[2] = ((ts
>> 14) & 0xff) | 1;
517 b
[3] = (ts
>> 7) & 0xff;
518 b
[4] = ((ts
<< 1) & 0xff) | 1;
522 static void write_mpeg_rate(int type
, unsigned char *b
, unsigned int rate
)
524 rate
= ((rate
*8)+399) / 400;
526 if(type
== MUX_MPEG1
)
528 b
[0] = ((rate
>> 15) & 0x7f) | 0x80;
529 b
[1] = (rate
>> 7) & 0xff;
530 b
[2] = ((rate
<< 1) & 0xff) | 1;
535 b
[1] = (rate
>> 6) & 0xff;
536 b
[2] = ((rate
& 0x3f) << 2) | 0x03;
541 static void write_mpeg_std(unsigned char *b
, unsigned int size
, unsigned int type
, uint8_t mod
)
543 //type = 0:mpeg audio/128, 1:video and pes private streams (including ac3/dts/lpcm)/1024
544 if(type
== 0) //audio
545 size
= (size
+ 127) / 128;
546 else //video or other
547 size
= ((size
+ 1023) / 1024);
552 b
[0] = ((size
>> 8) & 0x3f) | (type
==1 ? 0x60 : 0x40) | mod
;
556 static void write_mpeg2_scr(unsigned char *b
, uint64_t ts
)
558 uint16_t t1
, t2
, t3
, scr_ext
;
559 scr_ext
= ts
% 300ULL;
561 ts
&= 0x1FFFFFFFFULL
; //33 bits
562 t1
= (ts
>> 30) & 0x7;
563 t2
= (ts
>> 15) & 0x7fff;
566 b
[0] = (t1
<< 3 ) | 0x44 | ((t2
>> 13) & 0x3);
568 b
[2] = (t2
& 0x1f) << 3 | 0x4 | ((t3
>> 13) & 0x3);
570 b
[4] = (t3
& 0x1f) << 3 | ((scr_ext
>> 7) & 0x03) | 0x4;
571 b
[5] = ((scr_ext
<< 1) & 0xFF) | 1;
575 static int write_mpeg_pack_header(muxer_t
*muxer
, char *buff
)
580 priv
= (muxer_priv_t
*) muxer
->priv
;
581 *(uint32_t *)buff
= be2me_32(PACK_HEADER_START_CODE
);
582 if(priv
->mux
==MUX_MPEG1
)
584 write_mpeg_ts(&buff
[4], priv
->scr
, 0x20); // 0010 and SCR
585 write_mpeg_rate(priv
->mux
, &buff
[9], muxer
->sysrate
);
590 write_mpeg2_scr(&buff
[4], priv
->scr
); // 0010 and SCR
591 write_mpeg_rate(priv
->mux
, &buff
[10], muxer
->sysrate
);
592 buff
[13] = 0xf8; //5 bits reserved + 3 set to 0 to indicate 0 stuffing bytes
600 static int write_mpeg_system_header(muxer_t
*muxer
, char *buff
)
605 priv
= (muxer_priv_t
*) muxer
->priv
;
608 *(uint32_t *)(&buff
[len
]) = be2me_32(SYSTEM_HEADER_START_CODE
);
610 *(uint16_t *)(&buff
[len
]) = 0; //fake length, we'll fix it later
612 write_mpeg_rate(MUX_MPEG1
, &buff
[len
], muxer
->sysrate
);
615 buff
[len
++] = 0x4 | (priv
->is_xvcd
? 1 : 0); //1 audio stream bound, no fixed, CSPS only for xvcd
616 //stolen from libavformat
617 if(priv
->is_xvcd
|| priv
->is_dvd
)
618 buff
[len
++] = 0xe1; //system_audio_lock, system_video_lock, marker, 1 video stream bound
620 buff
[len
++] = 0x21; //marker, 1 video stream bound
622 buff
[len
++] = ((priv
->mux
== MUX_MPEG1
) ? 0xff : 0x7f); //in mpeg2 there's the packet rate restriction
624 for(i
= 0; i
< priv
->sys_info
.cnt
; i
++)
626 buff
[len
++] = priv
->sys_info
.streams
[i
].id
;
627 write_mpeg_std(&buff
[len
], priv
->sys_info
.streams
[i
].bufsize
, priv
->sys_info
.streams
[i
].type
,
628 (priv
->sys_info
.streams
[i
].type
== 1 ? 0xe0: 0xc0));
632 *(uint16_t *)(&buff
[4]) = be2me_16(len
- 6); // length field fixed
637 static int write_mpeg_psm(muxer_t
*muxer
, char *buff
)
643 priv
= (muxer_priv_t
*) muxer
->priv
;
646 *(uint32_t *)(&buff
[len
]) = be2me_32(PSM_START_CODE
);
648 *(uint16_t *)(&buff
[len
]) = 0; //fake length, we'll fix it later
650 buff
[len
++] = 0xe0; //1 current, 2 bits reserved, 5 version 0
651 buff
[len
++] = 0xff; //7 reserved, 1 marker
652 buff
[len
] = buff
[len
+1] = 0; //length of the program descriptors (unused)
654 *(uint16_t *)(&buff
[len
]) = 0; //length of the es descriptors
658 for(i
= 0; i
< priv
->psm_info
.cnt
; i
++)
661 (priv
->psm_info
.streams
[i
].id
== 0xbd) ||
662 (priv
->psm_info
.streams
[i
].id
>= 0xe0 && priv
->psm_info
.streams
[i
].id
<= 0xef) ||
663 (priv
->psm_info
.streams
[i
].id
>= 0xc0 && priv
->psm_info
.streams
[i
].id
<= 0xcf)
666 buff
[len
++] = priv
->psm_info
.streams
[i
].type
;
667 buff
[len
++] = priv
->psm_info
.streams
[i
].id
;
668 buff
[len
++] = 0; //len of descriptor upper ...
669 buff
[len
++] = 0; //... lower
674 *(uint16_t *)(&buff
[10]) = be2me_16(dlen
); //length of the es descriptors
676 *(uint16_t *)(&buff
[4]) = be2me_16(len
- 6 + 4); // length field fixed, including size of CRC32
678 *(uint32_t *)(&buff
[len
]) = be2me_32(CalcCRC32(buff
, len
));
685 static int psm_is_late(muxer_priv_t
*priv
)
687 return !priv
->data_size
|| (priv
->scr
>= priv
->last_psm_scr
+ 27000000ULL);
690 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
)
695 memcpy(&buff
[len
], pes_id
, 4);
698 buff
[len
] = buff
[len
+1] = 0; //fake len
701 if(mux_type
== MUX_MPEG1
)
705 memset(&buff
[len
], 0xff, stuffing_len
);
709 if(h
->buffer_size
> 0)
711 write_mpeg_std(&buff
[len
], h
->buffer_size
, h
->type
, 0x40); // 01 is pes1 format
717 buff
[len
] = (h
->pes_is_aligned
? 0x84 : 0x80); //0x10...
719 buff
[len
] = ((h
->buffer_size
> 0) ? 1 : 0) | (h
->pts
? (h
->dts
? 0xC0 : 0x80) : 0); //pes extension + pts/dts flags
721 buff
[len
] = (h
->pts
? (h
->dts
? 10 : 5) : 0) + ((h
->buffer_size
> 0) ? 3 : 0) + stuffing_len
;//pts + std + stuffing
728 write_mpeg_ts(&buff
[len
], h
->pts
, (h
->dts
? 0x30 : 0x20)); // 001x and both PTS/DTS
733 write_mpeg_ts(&buff
[len
], h
->dts
, 0x10); // 0001 before DTS
739 if(mux_type
== MUX_MPEG1
)
747 if(mux_type
== MUX_MPEG2
)
749 if(h
->buffer_size
> 0)
751 buff
[len
] = 0x1e; //std flag
754 write_mpeg_std(&buff
[len
], h
->buffer_size
, h
->type
, 0x40);
760 memset(&buff
[len
], 0xff, stuffing_len
);
765 *((uint16_t*) &buff
[4]) = be2me_16(len
+ plen
- 6); //fix pes packet size
770 static void write_pes_padding(uint8_t *buff
, uint16_t len
)
772 //6 header bytes + len-6 0xff chars
773 buff
[0] = buff
[1] = 0;
776 *((uint16_t*) &buff
[4]) = be2me_16(len
- 6);
777 memset(&buff
[6], 0xff, len
- 6);
781 static int write_nav_pack(uint8_t *buff
)
783 // concatenation of pes_private2 + 03d4 x 0 and pes_private2 + 03fa x 0
786 mp_msg(MSGT_MUXER
, MSGL_DBG3
, "NAV\n");
788 *(uint32_t *)(&buff
[len
]) = be2me_32(PES_PRIVATE2
);
792 memset(&buff
[len
], 0, 0x03d4);
795 *(uint32_t *)(&buff
[len
]) = be2me_32(PES_PRIVATE2
);
799 memset(&buff
[len
], 0, 0x03fa);
805 static unsigned int calc_psm_len(muxer_priv_t
*priv
)
807 return 16 + 4*(priv
->psm_info
.cnt
);
810 static uint32_t calc_pes_hlen(int format
, muxer_headers_t
*h
, muxer_priv_t
*priv
)
814 if(format
== MUX_MPEG1
)
825 else if(format
== MUX_MPEG1
)
828 if(h
->buffer_size
> 0)
830 if(format
== MUX_MPEG2
)
836 //len = max(h->min_pes_hlen, len);
842 static int write_mpeg_pack(muxer_t
*muxer
, muxer_stream_t
*s
, stream_t
*stream
, int isoend
)
849 priv
= (muxer_priv_t
*) muxer
->priv
;
854 offset
= priv
->packet_size
- 4;
855 write_pes_padding(buff
, offset
);
856 buff
[offset
+ 0] = buff
[offset
+ 1] = 0;
857 buff
[offset
+ 2] = 1;
858 buff
[offset
+ 3] = 0xb9;
860 stream_write_buffer(stream
, buff
, priv
->packet_size
);
863 else //FAKE DVD NAV PACK
865 offset
= write_mpeg_pack_header(muxer
, buff
);
866 offset
+= write_mpeg_system_header(muxer
, &buff
[offset
]);
868 //priv->update_system_header = 0;
871 offset
+= write_nav_pack(&buff
[offset
]);
873 stuffing_len
= priv
->packet_size
- offset
;
876 //insert a PES padding packet
877 write_pes_padding(&buff
[offset
], stuffing_len
);
878 offset
+= stuffing_len
;
881 stream_write_buffer(stream
, buff
, offset
);
882 priv
->headers_size
+= offset
;
884 muxer
->movi_end
+= tot
;
890 static void update_demux_bufsize(muxer_headers_t
*spriv
, uint64_t dts
, int framelen
, int type
)
892 int dim
= (spriv
->track_len
+16)*sizeof(buffer_track_t
);
894 if(spriv
->track_pos
+1 >= spriv
->track_len
)
896 buffer_track_t
*tmp
= realloc(spriv
->buffer_track
, dim
);
899 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\r\nERROR, couldn't realloc %d bytes for tracking buffer\r\n", dim
);
902 spriv
->buffer_track
= tmp
;
903 memset(&(spriv
->buffer_track
[spriv
->track_pos
+1]), 0, 16*sizeof(buffer_track_t
));
904 spriv
->track_len
+= 16;
907 spriv
->buffer_track
[spriv
->track_pos
].size
= framelen
;
908 spriv
->buffer_track
[spriv
->track_pos
].dts
= dts
; //must be dts
913 static void fix_a52_headers(muxer_stream_t
*s
)
915 muxer_headers_t
*spriv
= s
->priv
;
916 int x
= spriv
->payload_offset
;
918 spriv
->pack
[x
+0] = 0x80;
919 spriv
->pack
[x
+1] = spriv
->frames
;
922 spriv
->pack
[x
+2] = ((spriv
->last_frame_rest
+1) >> 8) & 0xff; //256 * 0 ...
923 spriv
->pack
[x
+3] = (spriv
->last_frame_rest
+1) & 0xff; // + 1 byte(s) to skip
926 spriv
->pack
[x
+2] = spriv
->pack
[x
+3] = 0;
929 static inline void remove_frames(muxer_headers_t
*spriv
, int n
)
934 for(i
= n
; i
< spriv
->framebuf_used
; i
++)
936 tmp
= spriv
->framebuf
[i
- n
];
937 spriv
->framebuf
[i
- n
] = spriv
->framebuf
[i
];
938 spriv
->framebuf
[i
] = tmp
;
940 spriv
->framebuf_used
-= n
;
943 static int calc_packet_len(muxer_stream_t
*s
, int psize
, int finalize
)
945 muxer_headers_t
*spriv
= s
->priv
;
946 int n
, len
, frpos
, m
;
949 frpos
= spriv
->framebuf
[0].pos
;
950 while(len
< psize
&& n
< spriv
->framebuf_used
)
952 if(!frpos
&& len
>0 && s
->type
== MUXER_TYPE_VIDEO
&& spriv
->framebuf
[n
].type
==I_FRAME
)
954 m
= FFMIN(spriv
->framebuf
[n
].size
- frpos
, psize
- len
);
957 if(frpos
== spriv
->framebuf
[n
].size
)
964 if(len
< psize
&& !finalize
)
969 static int find_packet_timestamps(muxer_priv_t
*priv
, muxer_stream_t
*s
, unsigned int start
, uint64_t *dts
, uint64_t *pts
)
971 muxer_headers_t
*spriv
= s
->priv
;
972 int i
, m
, pes_hlen
, ret
, threshold
;
973 uint64_t spts
, sdts
, dpts
;
975 if(!spriv
->framebuf_used
)
980 spriv
->dts
= spriv
->pts
= 0;
982 if(spriv
->framebuf
[0].pos
== 0) // start of frame
986 pes_hlen
= calc_pes_hlen(priv
->mux
, spriv
, priv
);
988 if(pes_hlen
< spriv
->min_pes_hlen
)
989 pes_hlen
= spriv
->min_pes_hlen
;
991 m
= spriv
->framebuf
[0].size
- spriv
->framebuf
[0].pos
;
993 if(start
+ pes_hlen
+ m
>= priv
->packet_size
) //spriv->pack_offset
994 i
= -1; //this pack won't have a pts: no space available
997 if(spriv
->framebuf_used
< 2)
1000 if(spriv
->framebuf
[1].pts
== spriv
->framebuf
[1].dts
)
1005 //headers+frame 0 < space available including timestamps
1006 if(start
+ pes_hlen
+ m
< priv
->packet_size
- threshold
)
1015 dpts
= FFMAX(spriv
->last_saved_pts
, spriv
->framebuf
[i
].pts
) -
1016 FFMIN(spriv
->last_saved_pts
, spriv
->framebuf
[i
].pts
) +
1017 spriv
->framebuf
[0].idur
;
1019 if(s
->type
!= MUXER_TYPE_VIDEO
)
1021 else if((spriv
->framebuf
[i
].type
== I_FRAME
|| priv
->ts_allframes
|| dpts
>= 36000*300)) //0.4 seconds
1026 *pts
= spriv
->framebuf
[i
].pts
;
1027 *dts
= spriv
->framebuf
[i
].dts
;
1039 static int get_packet_stats(muxer_priv_t
*priv
, muxer_stream_t
*s
, pack_stats_t
*p
, int finalize
)
1041 muxer_headers_t
*spriv
= s
->priv
;
1042 int len
, len2
, pack_hlen
, pes_hlen
, hlen
, target
, stflen
, stuffing_len
;
1045 spriv
->pts
= spriv
->dts
= 0;
1046 p
->dts
= p
->pts
= p
->frame_pts
= p
->frame_dts
= 0;
1051 else if(priv
->mux
== MUX_MPEG1
)
1055 if(priv
->use_psm
&& psm_is_late(priv
))
1056 pack_hlen
+= calc_psm_len(priv
);
1058 if(find_packet_timestamps(priv
, s
, pack_hlen
, &dts
, &pts
))
1060 p
->pts
= p
->frame_pts
= pts
;
1061 p
->dts
= p
->frame_dts
= dts
;
1066 pes_hlen
= calc_pes_hlen(priv
->mux
, spriv
, priv
);
1068 p
->stflen
= stflen
= (spriv
->min_pes_hlen
> pes_hlen
? spriv
->min_pes_hlen
- pes_hlen
: 0);
1070 target
= len
= priv
->packet_size
- pack_hlen
- pes_hlen
- stflen
; //max space available
1071 if(s
->type
== MUXER_TYPE_AUDIO
&& s
->wf
->wFormatTag
== AUDIO_A52
)
1079 len2
= calc_packet_len(s
, target
, finalize
);
1080 if(!len2
|| (len2
< target
&& s
->type
== MUXER_TYPE_AUDIO
&& !finalize
))
1083 //p->dts = p->pts = 0;
1084 spriv
->pts
= spriv
->dts
= 0;
1085 //fprintf(stderr, "\r\nLEN2: %d, target: %d, type: %d\r\n", len2, target, s->type);
1093 if(s
->type
== MUXER_TYPE_VIDEO
)
1099 spriv
->pts
= spriv
->dts
= 0;
1100 p
->pts
= p
->dts
= 0;
1103 stuffing_len
= target
- len
;
1104 if(stuffing_len
> 0 && stuffing_len
< 7)
1106 if(stflen
+ stuffing_len
> 16)
1108 int x
= 7 - stuffing_len
;
1114 stflen
+= stuffing_len
;
1128 static int fill_packet(muxer_t
*muxer
, muxer_stream_t
*s
, int finalize
)
1130 //try to fill a packet as much as possible
1131 //spriv->pack_offset is the start position initialized to 0
1132 //data is taken from spriv->framebuf
1133 //if audio and a52 insert the headers
1134 muxer_priv_t
*priv
= (muxer_priv_t
*) muxer
->priv
;
1135 muxer_headers_t
*spriv
= (muxer_headers_t
*) s
->priv
;
1136 int len
, m
, n
, dvd_pack
= 0;
1141 spriv
->dts
= spriv
->pts
= 0;
1143 if(! spriv
->framebuf_used
)
1145 spriv
->pack_offset
= 0;
1149 if(!spriv
->pack_offset
)
1152 spriv
->pack_offset
= 0;
1154 spriv
->pack_offset
= write_mpeg_pack_header(muxer
, spriv
->pack
);
1155 if(priv
->update_system_header
&& (priv
->is_genmpeg1
|| priv
->is_genmpeg2
))
1157 spriv
->pack_offset
+= write_mpeg_system_header(muxer
, &spriv
->pack
[spriv
->pack_offset
]);
1158 priv
->update_system_header
= 0;
1161 if(priv
->use_psm
&& psm_is_late(priv
))
1163 spriv
->pack_offset
+= write_mpeg_psm(muxer
, &spriv
->pack
[spriv
->pack_offset
]);
1168 spriv
->pes_offset
= spriv
->pack_offset
;
1169 spriv
->payload_offset
= 0;
1171 spriv
->last_frame_rest
= 0;
1177 //search the pts. yes if either it's video && (I-frame or priv->ts_allframes) && framebuf[i].pos == 0
1178 //or it's audio && framebuf[i].pos == 0
1179 //NB pts and dts can only be relative to the first frame beginning in this pack
1180 if((priv
->is_xsvcd
|| priv
->is_xvcd
|| priv
->rawpes
) && spriv
->size
== 0)
1182 if(s
->type
== MUXER_TYPE_VIDEO
)
1183 bufsize
= (conf_vbuf_size
? conf_vbuf_size
: (priv
->is_xvcd
? 46 : 232));
1185 bufsize
= (conf_abuf_size
? conf_abuf_size
: 4);
1186 spriv
->buffer_size
= bufsize
*1024;
1189 if(priv
->is_dvd
&& s
->type
== MUXER_TYPE_VIDEO
1190 && spriv
->framebuf
[0].type
==I_FRAME
&& spriv
->framebuf
[0].pos
==0)
1193 if(! get_packet_stats(priv
, s
, &p
, finalize
))
1195 spriv
->pack_offset
= 0;
1201 spriv
->last_saved_pts
= p
.pts
;
1203 spriv
->pack_offset
+= write_mpeg_pes_header(spriv
, (uint8_t *) &s
->ckid
, &(spriv
->pack
[spriv
->pack_offset
]),
1204 p
.len
, p
.stflen
, priv
->mux
);
1206 if(s
->type
== MUXER_TYPE_AUDIO
&& s
->wf
->wFormatTag
== AUDIO_A52
)
1208 spriv
->payload_offset
= spriv
->pack_offset
;
1209 spriv
->pack_offset
+= 4; //for the 4 bytes of header
1210 if(!spriv
->framebuf
[0].pos
)
1211 spriv
->last_frame_rest
= 0;
1213 spriv
->last_frame_rest
= spriv
->framebuf
[0].size
- spriv
->framebuf
[0].pos
;
1220 if(spriv
->dts
|| spriv
->pts
)
1222 if((spriv
->dts
&& priv
->scr
>= spriv
->dts
) || priv
->scr
>= spriv
->pts
)
1223 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\r\nERROR: scr %.3f, dts %.3f, pts %.3f\r\n", (double) priv
->scr
/27000000.0, (double) spriv
->dts
/27000000.0, (double) spriv
->pts
/27000000.0);
1224 else if(priv
->scr
+ 63000*300 < spriv
->dts
)
1225 mp_msg(MSGT_MUXER
, MSGL_INFO
, "\r\nWARNING>: scr %.3f, dts %.3f, pts %.3f, diff %.3f, piff %.3f\r\n", (double) priv
->scr
/27000000.0, (double) spriv
->dts
/27000000.0, (double) spriv
->pts
/27000000.0, (double)(spriv
->dts
- priv
->scr
)/27000000.0, (double)(spriv
->pts
- priv
->scr
)/27000000.0);
1231 frm
= spriv
->framebuf
;
1232 while(spriv
->pack_offset
< priv
->packet_size
&& n
< spriv
->framebuf_used
)
1236 //since iframes must always be aligned at block boundaries exit when we find the
1237 //beginning of one in the middle of the flush
1238 if(len
> 0 && s
->type
== MUXER_TYPE_VIDEO
&& frm
->type
== I_FRAME
)
1243 update_demux_bufsize(spriv
, frm
->dts
, frm
->size
, s
->type
);
1246 m
= FFMIN(frm
->size
- frm
->pos
, priv
->packet_size
- spriv
->pack_offset
);
1247 memcpy(&(spriv
->pack
[spriv
->pack_offset
]), &(frm
->buffer
[frm
->pos
]), m
);
1250 spriv
->pack_offset
+= m
;
1253 if(frm
->pos
== frm
->size
) //end of frame
1255 frm
->pos
= frm
->size
= 0;
1256 frm
->pts
= frm
->dts
= 0;
1262 if((priv
->is_xsvcd
|| priv
->is_xvcd
|| priv
->rawpes
) && spriv
->size
== 0)
1263 spriv
->buffer_size
= 0;
1267 if(dvd_pack
&& (spriv
->pack_offset
== priv
->packet_size
))
1268 write_mpeg_pack(muxer
, NULL
, muxer
->stream
, 0); //insert fake Nav Packet
1271 remove_frames(spriv
, n
);
1273 spriv
->track_bufsize
+= len
;
1274 if(spriv
->track_bufsize
> spriv
->max_buffer_size
)
1275 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\r\nBUFFER OVERFLOW: %d > %d, pts: %"PRIu64
"\r\n", spriv
->track_bufsize
, spriv
->max_buffer_size
, spriv
->pts
);
1277 if(s
->type
== MUXER_TYPE_AUDIO
&& s
->wf
->wFormatTag
== AUDIO_A52
)
1280 if(spriv
->pack_offset
< priv
->packet_size
&& !priv
->rawpes
) //here finalize is set
1282 int diff
= priv
->packet_size
- spriv
->pack_offset
;
1283 write_pes_padding(&(spriv
->pack
[spriv
->pack_offset
]), diff
);
1284 spriv
->pack_offset
+= diff
;
1287 stream_write_buffer(muxer
->stream
, spriv
->pack
, spriv
->pack_offset
);
1289 priv
->headers_size
+= spriv
->pack_offset
- len
;
1290 priv
->data_size
+= len
;
1291 muxer
->movi_end
+= spriv
->pack_offset
;
1293 spriv
->pack_offset
= 0;
1297 priv
->last_psm_scr
= priv
->scr
;
1302 static inline int find_best_stream(muxer_t
*muxer
)
1306 muxer_priv_t
*priv
= muxer
->priv
;
1307 muxer_headers_t
*spriv
;
1309 unsigned int perc
, sperc
;
1314 //THIS RULE MUST ALWAYS apply: dts <= SCR + 0.7 seconds
1315 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
1317 spriv
= muxer
->streams
[i
]->priv
;
1320 get_packet_stats(priv
, muxer
->streams
[i
], &p
, 0);
1322 if(spriv
->track_bufsize
+ p
.len
> spriv
->max_buffer_size
)
1324 if(p
.frame_pts
&& p
.frame_dts
> priv
->scr
+ 63000*300)
1327 if(spriv
->framebuf
[0].dts
<= dts
)
1329 dts
= spriv
->framebuf
[0].dts
;
1333 if(conf_interleaving2
)
1335 sperc
= (spriv
->track_bufsize
* 1024) / spriv
->max_buffer_size
;
1347 static void patch_seq(muxer_priv_t
*priv
, unsigned char *buf
)
1349 if(priv
->vwidth
> 0)
1351 buf
[4] = (priv
->vwidth
>> 4) & 0xff;
1353 buf
[5] |= (priv
->vwidth
& 0x0f) << 4;
1356 if(priv
->vheight
> 0)
1359 buf
[5] |= (priv
->vheight
>> 8) & 0x0f;
1360 buf
[6] = priv
->vheight
& 0xff;
1363 if(priv
->vaspect
> 0)
1364 buf
[7] = (buf
[7] & 0x0f) | (priv
->vaspect
<< 4);
1366 if(priv
->vframerate
> 0)
1367 buf
[7] = (buf
[7] & 0xf0) | priv
->vframerate
;
1369 if(priv
->vbitrate
> 0)
1371 buf
[8] = (priv
->vbitrate
>> 10);
1372 buf
[9] = (priv
->vbitrate
>> 2);
1373 buf
[10] = (buf
[10] & 0x3f) | (unsigned char) ((priv
->vbitrate
& 0x4) << 2);
1377 static void patch_panscan(muxer_priv_t
*priv
, unsigned char *buf
)
1378 { //patches sequence display extension (display_horizontal_size and display_vertical_size)
1385 if(priv
->panscan_width
> 0)
1387 buf
[offset
] = (priv
->panscan_width
>> 6);
1388 buf
[offset
+1] = ((priv
->panscan_width
& 0x3F) << 2) | (buf
[offset
+ 1] & 0x03);
1393 if(priv
->panscan_height
> 0)
1395 buf
[offset
] = (priv
->panscan_height
>> 13) << 7;
1396 buf
[offset
+1] = (priv
->panscan_height
>> 5) & 0xFF;
1397 buf
[offset
+2] = ((priv
->panscan_height
& 0x1F) << 3) | (buf
[offset
+2] & 0x07);
1402 static void update_scr(muxer_t
*muxer
)
1404 muxer_priv_t
*priv
= muxer
->priv
;
1405 muxer_stream_t
*stream
;
1406 muxer_headers_t
*spriv
;
1408 uint64_t mindts
= (uint64_t) -1;
1410 priv
->scr
+= priv
->delta_scr
;
1412 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
1414 stream
= muxer
->streams
[i
];
1415 spriv
= stream
->priv
;
1416 if(spriv
->framebuf_used
&& spriv
->framebuf
[0].dts
< mindts
)
1417 mindts
= spriv
->framebuf
[0].dts
;
1420 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "UPDATE SCR TO %"PRIu64
" (%.3f)\n", priv
->scr
, (double) (priv
->scr
/27000000.0));
1422 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
1424 stream
= muxer
->streams
[i
];
1425 spriv
= stream
->priv
;
1428 while(j
< spriv
->track_pos
&& priv
->scr
>= spriv
->buffer_track
[j
].dts
)
1430 spriv
->track_bufsize
-= spriv
->buffer_track
[j
].size
;
1433 if(spriv
->track_bufsize
< 0)
1436 muxer
->sysrate
= (muxer
->sysrate
* 11) / 10; //raise by 10%
1437 d
= (double) priv
->packet_size
/ (double)muxer
->sysrate
;
1438 priv
->delta_scr
= (uint64_t) (d
* 27000000.0f
);
1439 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
);
1440 spriv
->track_bufsize
= 0;
1445 memmove(spriv
->buffer_track
, &(spriv
->buffer_track
[j
]), (spriv
->track_len
- j
) * sizeof(buffer_track_t
));
1446 spriv
->track_pos
-= j
;
1447 for(j
= spriv
->track_pos
; j
< spriv
->track_len
; j
++)
1448 spriv
->buffer_track
[j
].size
= 0;
1451 if(spriv
->framebuf_used
&& spriv
->framebuf
[0].dts
< mindts
)
1452 mindts
= spriv
->framebuf
[0].dts
;
1457 static int calc_frames_to_flush(muxer_headers_t
*vpriv
)
1461 if(vpriv
->framebuf_used
> 0)
1464 //let's count how many frames we'll store in the next pack sequence
1465 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "\n");
1466 while(n
< vpriv
->framebuf_used
)
1468 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "CALC_FRAMES, n=%d, type=%c, pts=%.3f\n", n
, FTYPE(vpriv
->framebuf
[n
].type
), (double)vpriv
->framebuf
[n
].pts
/27000000.0f
);
1469 if(n
+1 < vpriv
->framebuf_used
)
1470 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "n+1=%d, type=%c, pts=%.3f\n", n
+1, FTYPE(vpriv
->framebuf
[n
+1].type
), (double)vpriv
->framebuf
[n
+1].pts
/27000000.0f
);
1472 if(vpriv
->framebuf
[n
].type
== I_FRAME
)
1485 if(found
&& (n
< vpriv
->framebuf_used
+1))
1491 static int flush_buffers(muxer_t
*muxer
, int finalize
)
1495 uint64_t init_delay
= 0;
1496 muxer_stream_t
*s
, *vs
, *as
;
1497 muxer_headers_t
*vpriv
= NULL
, *apriv
= NULL
;
1498 muxer_priv_t
*priv
= (muxer_priv_t
*) muxer
->priv
;
1500 uint64_t iduration
, iaduration
;
1503 analyzes all streams and decides what to flush
1504 trying to respect an interleaving distribution
1505 equal to the v_bitrate/a_bitrate proportion
1510 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
1512 s
= muxer
->streams
[i
];
1513 if(s
->type
== MUXER_TYPE_VIDEO
)
1515 vs
= muxer
->streams
[i
];
1516 vpriv
= (muxer_headers_t
*) vs
->priv
;
1517 if(!vpriv
->is_ready
)
1519 n
= found
= calc_frames_to_flush(vpriv
);
1521 else if(s
->type
== MUXER_TYPE_AUDIO
)
1525 if((! found
) && finalize
)
1528 found
= n
= vpriv
->framebuf_used
;
1533 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "\nVIDEO, FLUSH %d frames (of %d), 0 to %d\n", n
, vpriv
->framebuf_used
, n
-1);
1535 vpriv
= (muxer_headers_t
*) vs
->priv
;
1539 for(i
= 0; i
< n
; i
++)
1540 iduration
+= vpriv
->framebuf
[i
].idur
;
1541 duration
= (double) (iduration
/ 27000000.0);
1545 apriv
= (muxer_headers_t
*) as
->priv
;
1547 for(i
= 0; i
< apriv
->framebuf_used
; i
++)
1549 iaduration
+= apriv
->framebuf
[i
].idur
;
1551 if(iaduration
< iduration
)
1553 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "Not enough audio data exit\n");
1558 if(as
!= NULL
&& (apriv
->size
== 0))
1560 init_delay
= vpriv
->framebuf
[0].pts
- vpriv
->framebuf
[0].dts
;
1562 for(i
= 0; i
< apriv
->framebuf_cnt
; i
++)
1564 apriv
->framebuf
[i
].pts
+= init_delay
;
1565 apriv
->framebuf
[i
].dts
+= init_delay
;
1567 apriv
->last_pts
+= init_delay
;
1568 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "\r\nINITIAL VIDEO DELAY: %.3f, currAPTS: %.3f\r\n", (double) init_delay
/27000000.0f
, (double) apriv
->last_pts
/27000000.0f
);
1571 if((priv
->is_xvcd
|| priv
->is_xsvcd
) && (vpriv
->size
== 0))
1572 vpriv
->buffer_size
= (conf_vbuf_size
? conf_vbuf_size
: (priv
->is_xvcd
? 46 : 230))*1024;
1580 i
= find_best_stream(muxer
);
1583 if(!fill_packet(muxer
, muxer
->streams
[i
], finalize
))
1586 if(skip_cnt
== muxer
->avih
.dwStreams
)
1594 muxer
->file_end
= priv
->scr
;
1599 static inline uint64_t parse_fps(float fps
)
1601 // 90000 * 300 * 1001 / d , there's no rounding error with any of the admitted framerates
1602 int d
= (int)(fps
*1001+0.5);
1604 return 27027000000ULL / d
;
1608 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
)
1614 *fps_ptr
= (*fps_ptr
& 0xf0) | priv
->vframerate
;
1615 vpriv
->nom_delta_pts
= parse_fps(conf_vframerate
);
1618 //in pce_ptr starting from bit 0 bit 24 is tff, bit 30 is rff,
1619 if(pce_ptr
[3] & 0x2)
1621 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\nERROR! RFF bit is already set, disabling telecining\n");
1622 vpriv
->telecine
= 0;
1626 vpriv
->picture
.progressive_sequence
= 0;
1627 vpriv
->picture
.progressive_frame
= 1;
1631 //disable tff and rff and overwrite them with the value in bff_mask
1632 pce_ptr
[3] = (pce_ptr
[3] & 0x7d) | priv
->bff_mask
[vpriv
->display_frame
% MAX_PATTERN_LENGTH
];
1633 pce_ptr
[4] |= 0x80; //sets progressive frame
1635 vpriv
->display_frame
+= n
;
1636 if(! vpriv
->vframes
)
1637 mp_msg(MSGT_MUXER
, MSGL_INFO
, "\nENABLED SOFT TELECINING, FPS=%.3f\n",conf_vframerate
);
1642 static size_t parse_mpeg12_video(muxer_stream_t
*s
, muxer_priv_t
*priv
, muxer_headers_t
*spriv
, float fps
, size_t len
)
1644 uint8_t *fps_ptr
= NULL
; //pointer to the fps byte in the sequence header
1645 uint8_t *se_ptr
= NULL
; //pointer to sequence extension
1646 uint8_t *pce_ptr
= NULL
; //pointer to picture coding extension
1647 int frames_diff
, d1
, gop_reset
= 0; //how any frames we advanced respect to the last one
1653 mp_msg(MSGT_MUXER
, MSGL_DBG2
,"parse_mpeg12_video, len=%u\n", (uint32_t) len
);
1654 if(s
->buffer
[0] != 0 || s
->buffer
[1] != 0 || s
->buffer
[2] != 1 || len
<6)
1656 mp_msg(MSGT_MUXER
, MSGL_ERR
,"Unknown video format, possibly non-MPEG1/2 stream, len=%d!\n", len
);
1665 { // Video (0) Sequence header (b3) or GOP (b8)
1666 if((s
->buffer
[i
] == 0) && (s
->buffer
[i
+1] == 0) && (s
->buffer
[i
+2] == 1))
1668 switch(s
->buffer
[i
+3])
1670 case 0xb3: //sequence
1677 fps_ptr
= &(s
->buffer
[i
+7]);
1678 mp_header_process_sequence_header(&(spriv
->picture
), &(s
->buffer
[i
+4]));
1679 spriv
->delta_pts
= spriv
->nom_delta_pts
= parse_fps(spriv
->picture
.fps
);
1681 spriv
->delta_clock
= (double) 1/fps
;
1682 //the 2 lines below are needed to handle non-standard frame rates (such as 18)
1683 if(! spriv
->delta_pts
)
1684 spriv
->delta_pts
= spriv
->nom_delta_pts
= (uint64_t) ((double)27000000.0 * spriv
->delta_clock
);
1685 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "\nFPS: %.3f, FRAMETIME: %.3f\n", fps
, (double)1/fps
);
1687 patch_seq(priv
, &(s
->buffer
[i
]));
1697 mp_header_process_extension(&(spriv
->picture
), &(s
->buffer
[i
+4]));
1698 if(((s
->buffer
[i
+4] & 0xf0) == 0x10))
1699 se_ptr
= &(s
->buffer
[i
+4]);
1700 if(((s
->buffer
[i
+4] & 0xf0) == 0x20))
1703 patch_panscan(priv
, &(s
->buffer
[i
+4]));
1705 if((s
->buffer
[i
+4] & 0xf0) == 0x80)
1707 pce_ptr
= &(s
->buffer
[i
+4]);
1721 pt
= (s
->buffer
[i
+5] & 0x1c) >> 3;
1722 temp_ref
= (s
->buffer
[i
+4]<<2)+(s
->buffer
[i
+5]>>6);
1725 if(err
) break; //something went wrong
1726 if(s
->buffer
[i
+3] >= 0x01 && s
->buffer
[i
+3] <= 0xAF) break; //slice, we have already analized what we need
1731 mp_msg(MSGT_MUXER
, MSGL_ERR
,"Warning: picture too short or broken!\n");
1733 //following 2 lines are workaround: lavf doesn't sync to sequence headers before passing demux_packets
1734 if(!spriv
->nom_delta_pts
)
1735 spriv
->delta_pts
= spriv
->nom_delta_pts
= parse_fps(fps
);
1737 spriv
->last_tr
= spriv
->max_tr
= temp_ref
;
1738 d1
= temp_ref
- spriv
->last_tr
;
1740 frames_diff
= spriv
->max_tr
+ 1 + temp_ref
- spriv
->last_tr
;
1743 if(d1
< -6) //there's a wraparound
1744 frames_diff
= spriv
->max_tr
+ 1 + temp_ref
- spriv
->last_tr
;
1745 else if(d1
> 6) //there's a wraparound
1746 frames_diff
= spriv
->max_tr
+ 1 + spriv
->last_tr
- temp_ref
;
1747 else if(!d1
) //pre-emptive fix against broken sequences
1752 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "\nLAST: %d, TR: %d, GOP: %d, DIFF: %d, MAX: %d, d1: %d\n",
1753 spriv
->last_tr
, temp_ref
, gop_reset
, frames_diff
, spriv
->max_tr
, d1
);
1755 if(temp_ref
> spriv
->max_tr
|| gop_reset
)
1756 spriv
->max_tr
= temp_ref
;
1758 spriv
->last_tr
= temp_ref
;
1759 if(spriv
->picture
.mpeg1
== 0)
1761 if(spriv
->telecine
&& pce_ptr
)
1763 soft_telecine(priv
, spriv
, fps_ptr
, se_ptr
, pce_ptr
, frames_diff
);
1764 spriv
->picture
.display_time
= 100;
1765 mp_header_process_extension(&(spriv
->picture
), pce_ptr
);
1766 if(spriv
->picture
.display_time
>= 50 && spriv
->picture
.display_time
<= 300)
1767 spriv
->delta_pts
= (spriv
->nom_delta_pts
* spriv
->picture
.display_time
) / 100;
1771 if(! spriv
->vframes
)
1774 spriv
->last_dts
+= spriv
->delta_pts
;
1775 spriv
->last_pts
+= spriv
->nom_delta_pts
*(frames_diff
-1) + spriv
->delta_pts
;
1777 ret
= add_frame(spriv
, spriv
->delta_pts
, s
->buffer
, len
, pt
, spriv
->last_dts
, spriv
->last_pts
);
1780 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "\r\nPARSE_MPEG12: add_frames(%d) failed, exit\r\n", len
);
1783 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "\r\nVIDEO FRAME, PT: %C, tr: %d, diff: %d, dts: %.3f, pts: %.3f, pdt: %u, gop_reset: %d\r\n",
1784 ftypes
[pt
], temp_ref
, frames_diff
, ((double) spriv
->last_dts
/27000000.0f
),
1785 ((double) spriv
->last_pts
/27000000.0f
), spriv
->picture
.display_time
, gop_reset
);
1790 int64_t diff
= spriv
->last_dts
- spriv
->last_pts
;
1794 n
= spriv
->framebuf_used
- 1;
1796 for(j
= n
; j
>= 0; j
--)
1798 if(spriv
->framebuf
[j
].pts
>= spriv
->last_pts
)
1800 spriv
->framebuf
[j
].pts
+= diff
;
1804 mp_msg(MSGT_MUXER
, MSGL_V
, "\r\nResynced B-frame by %d units, DIFF: %"PRId64
" (%.3f),[pd]ts=%.3f\r\n",
1805 n
, diff
, (double) diff
/27000000.0f
, (double) spriv
->last_pts
/27000000.0f
);
1806 spriv
->last_pts
= spriv
->last_dts
;
1811 mp_msg(MSGT_MUXER
, MSGL_DBG2
,"parse_mpeg12_video, return %u\n", (uint32_t) len
);
1816 static uint64_t fix_mp4_frame_duration(muxer_headers_t
*vpriv
)
1818 uint64_t mn
, md
, mx
, diff
;
1821 mn
= mx
= vpriv
->framebuf
[0].pts
;
1822 for(i
= 0; i
< 3; i
++)
1824 mp_msg(MSGT_DECVIDEO
,MSGL_DBG2
, "PTS: %"PRIu64
"\n", vpriv
->framebuf
[i
].pts
);
1825 if(vpriv
->framebuf
[i
].pts
< mn
)
1826 mn
= vpriv
->framebuf
[i
].pts
;
1827 if(vpriv
->framebuf
[i
].pts
> mx
)
1828 mx
= vpriv
->framebuf
[i
].pts
;
1833 if((vpriv
->framebuf
[i
].pts
> mn
) && (vpriv
->framebuf
[i
].pts
< mx
))
1834 md
= vpriv
->framebuf
[i
].pts
;
1837 if(mx
- md
> md
- mn
)
1842 mp_msg(MSGT_DECVIDEO
,MSGL_DBG2
, "MIN: %"PRIu64
", mid: %"PRIu64
", max: %"PRIu64
", diff: %"PRIu64
"\n", mn
, md
, mx
, diff
);
1847 vpriv
->framebuf
[i
].pts
+= diff
;
1848 vpriv
->framebuf
[i
].dts
+= i
* diff
;
1849 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "FIXED_PTS: %.3f, FIXED_DTS: %.3f\n",
1850 (double) (vpriv
->framebuf
[i
].pts
/27000000.0), (double) (vpriv
->framebuf
[i
].dts
/27000000.0));
1859 static size_t parse_mpeg4_video(muxer_stream_t
*s
, muxer_priv_t
*priv
, muxer_headers_t
*vpriv
, float fps
, size_t len
)
1862 int64_t delta_pts
=0;
1866 mp_msg(MSGT_MUXER
, MSGL_DBG2
,"parse_mpeg4_video, len=%u\n", (uint32_t) len
);
1869 mp_msg(MSGT_MUXER
, MSGL_ERR
,"Frame too short: %d, exit!\n", len
);
1874 while(ptr
< len
- 5)
1876 if(s
->buffer
[ptr
] != 0 || s
->buffer
[ptr
+1] != 0 || s
->buffer
[ptr
+2] != 1)
1882 if(s
->buffer
[ptr
+3] >= 0x20 && s
->buffer
[ptr
+3] <= 0x2f) //VOL
1884 mp4_header_process_vol(&(vpriv
->picture
), &(s
->buffer
[ptr
+4]));
1886 else if(s
->buffer
[ptr
+3] == 0xb3) //gov
1888 //fprintf(stderr, "\nGOV\n");
1890 else if(s
->buffer
[ptr
+3] == 0xb6) //vop
1893 mp4_header_process_vop(&(vpriv
->picture
), &(s
->buffer
[ptr
+4]));
1895 delta
= vpriv
->picture
.timeinc_unit
- vpriv
->last_tr
;
1896 if((delta
> 0) && (delta
> (vpriv
->picture
.timeinc_resolution
/2)))
1897 delta
-= vpriv
->picture
.timeinc_resolution
;
1898 else if((delta
< 0) && (delta
< (-(vpriv
->picture
.timeinc_resolution
/2))))
1899 delta
+= vpriv
->picture
.timeinc_resolution
;
1901 delta_pts
= (27000000 * (int64_t) delta
) / vpriv
->picture
.timeinc_resolution
;
1902 //warning, it seems that packed bops can lead to delta == 0
1904 pt
= vpriv
->picture
.picture_type
+ 1;
1905 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "\nTYPE: %c, RESOLUTION: %d, TEMP: %d, delta: %d, delta_pts: %"PRId64
" = %.3f, delta2: %.3f\n",
1906 FTYPE(pt
), vpriv
->picture
.timeinc_resolution
, vpriv
->picture
.timeinc_unit
, delta
, delta_pts
, (double) (delta_pts
/27000000.0),
1907 (double) delta
/ (double) vpriv
->picture
.timeinc_resolution
);
1909 vpriv
->last_tr
= vpriv
->picture
.timeinc_unit
;
1919 vpriv
->last_dts
+= vpriv
->frame_duration
;
1920 vpriv
->last_pts
+= delta_pts
;
1923 ret
= add_frame(vpriv
, delta_pts
, s
->buffer
, len
, pt
, vpriv
->last_dts
, vpriv
->last_pts
);
1926 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "\r\nPARSE_MPEG4: add_frames(%d) failed, exit\r\n", len
);
1930 if(!vpriv
->frame_duration
&& vpriv
->framebuf_used
== 3)
1932 vpriv
->frame_duration
= fix_mp4_frame_duration(vpriv
);
1933 if(vpriv
->frame_duration
)
1935 vpriv
->last_pts
+= vpriv
->frame_duration
;
1936 vpriv
->last_dts
= vpriv
->framebuf
[vpriv
->framebuf_used
-1].dts
;
1937 vpriv
->delta_clock
= ((double) vpriv
->frame_duration
)/27000000.0;
1938 mp_msg(MSGT_MUXER
, MSGL_INFO
, "FRAME DURATION: %"PRIu64
" %.3f\n",
1939 vpriv
->frame_duration
, (double) (vpriv
->frame_duration
/27000000.0));
1940 vpriv
->is_ready
= 1;
1944 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "LAST_PTS: %.3f, LAST_DTS: %.3f\n",
1945 (double) (vpriv
->last_pts
/27000000.0), (double) (vpriv
->last_dts
/27000000.0));
1953 static int fill_last_frame(muxer_headers_t
*spriv
, uint8_t *ptr
, int len
)
1960 if(spriv
->framebuf_used
== 0)
1961 idx
= spriv
->framebuf_used
;
1963 idx
= spriv
->framebuf_used
- 1;
1965 if(spriv
->framebuf
[idx
].alloc_size
< spriv
->framebuf
[idx
].size
+ len
)
1967 if(spriv
->framebuf
[idx
].size
> SIZE_MAX
- (size_t)len
)
1969 spriv
->framebuf
[idx
].buffer
= realloc(spriv
->framebuf
[idx
].buffer
, spriv
->framebuf
[idx
].size
+ len
);
1970 if(! spriv
->framebuf
[idx
].buffer
)
1972 spriv
->framebuf
[idx
].alloc_size
= spriv
->framebuf
[idx
].size
+ len
;
1975 memcpy(&(spriv
->framebuf
[idx
].buffer
[spriv
->framebuf
[idx
].size
]), ptr
, len
);
1976 spriv
->framebuf
[idx
].size
+= len
;
1981 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
)
1985 idx
= spriv
->framebuf_used
;
1986 if(idx
>= spriv
->framebuf_cnt
)
1988 spriv
->framebuf
= realloc_struct(spriv
->framebuf
, (spriv
->framebuf_cnt
+1), sizeof(mpeg_frame_t
));
1989 if(spriv
->framebuf
== NULL
)
1991 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't realloc frame buffer(idx), abort\n");
1995 spriv
->framebuf
[spriv
->framebuf_cnt
].size
= 0;
1996 spriv
->framebuf
[spriv
->framebuf_cnt
].alloc_size
= 0;
1997 spriv
->framebuf
[spriv
->framebuf_cnt
].pos
= 0;
1999 spriv
->framebuf
[spriv
->framebuf_cnt
].buffer
= malloc(len
);
2000 if(spriv
->framebuf
[spriv
->framebuf_cnt
].buffer
== NULL
)
2002 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't realloc frame buffer(frame), abort\n");
2005 spriv
->framebuf
[spriv
->framebuf_cnt
].alloc_size
= len
;
2006 spriv
->framebuf_cnt
++;
2009 if(spriv
->framebuf
[idx
].alloc_size
< spriv
->framebuf
[idx
].size
+ len
)
2011 if(spriv
->framebuf
[idx
].size
> SIZE_MAX
- (size_t)len
)
2013 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Size overflow, couldn't realloc frame buffer(frame), abort\n");
2016 spriv
->framebuf
[idx
].buffer
= realloc(spriv
->framebuf
[idx
].buffer
, spriv
->framebuf
[idx
].size
+ len
);
2017 if(spriv
->framebuf
[idx
].buffer
== NULL
)
2019 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't realloc frame buffer(frame), abort\n");
2022 spriv
->framebuf
[idx
].alloc_size
= spriv
->framebuf
[idx
].size
+ len
;
2025 memcpy(&(spriv
->framebuf
[idx
].buffer
[spriv
->framebuf
[idx
].size
]), ptr
, len
);
2026 spriv
->framebuf
[idx
].size
+= len
;
2027 spriv
->framebuf
[idx
].pos
= 0;
2028 spriv
->framebuf
[idx
].type
= pt
;
2030 spriv
->framebuf
[idx
].idur
= idur
;
2031 spriv
->framebuf
[idx
].dts
= dts
;
2032 spriv
->framebuf
[idx
].pts
= pts
;
2033 spriv
->framebuf_used
++;
2034 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
);
2039 static int analyze_mpa(muxer_stream_t
*s
)
2041 int i
= 0, len
, max
, chans
, srate
, spf
, layer
;
2042 int score
[4] = {0, 0, 0, 0};
2044 while(i
< s
->b_buffer_len
+ 3)
2046 if(s
->b_buffer
[i
] == 0xFF && ((s
->b_buffer
[i
+1] & 0xE0) == 0xE0))
2048 len
= mp_get_mp3_header(&(s
->b_buffer
[i
]), &chans
, &srate
, &spf
, &layer
, NULL
);
2049 if(len
> 0 && (srate
== s
->wf
->nSamplesPerSec
) && (i
+ len
<= s
->b_buffer_len
))
2060 for(i
= 1; i
<= 3; i
++)
2069 return layer
; //actual layer with the highest score
2072 static int parse_audio(muxer_stream_t
*s
, int finalize
, unsigned int *nf
, double *timer
, double delay
, int drop
)
2074 int i
, j
, len
, chans
, srate
, spf
, layer
, dummy
, tot
, num
, frm_idx
;
2076 unsigned int frames
;
2079 muxer_headers_t
*spriv
= (muxer_headers_t
*) s
->priv
;
2081 i
= tot
= frames
= 0;
2086 switch(s
->wf
->wFormatTag
)
2091 if(i
+ 3 >= s
->b_buffer_len
)
2097 if(s
->b_buffer
[i
] == 0xFF && ((s
->b_buffer
[i
+1] & 0xE0) == 0xE0))
2099 len
= mp_get_mp3_header(&(s
->b_buffer
[i
]), &chans
, &srate
, &spf
, &layer
, NULL
);
2100 if(len
> 0 && (srate
== s
->wf
->nSamplesPerSec
) && (i
+ len
<= s
->b_buffer_len
)
2101 && layer
== spriv
->mpa_layer
)
2103 dur
= (double) spf
/ (double) srate
;
2104 idur
= (27000000ULL * spf
) / srate
;
2114 if(i
+ 6 >= s
->b_buffer_len
)
2120 if(s
->b_buffer
[i
] == 0x0B && s
->b_buffer
[i
+1] == 0x77)
2123 #ifdef CONFIG_LIBA52
2124 len
= a52_syncinfo(&(s
->b_buffer
[i
]), &dummy
, &srate
, &dummy
);
2126 len
= mp_a52_framesize(&(s
->b_buffer
[i
]), &srate
);
2128 if((len
> 0) && (srate
== s
->wf
->nSamplesPerSec
) && (i
+ len
<= s
->b_buffer_len
))
2130 dur
= (double) 1536 / (double) srate
;
2131 idur
= (27000000ULL * 1536) / srate
;
2142 if(i
+ 7 >= s
->b_buffer_len
)
2148 if(s
->b_buffer
[i
] == 0xFF && ((s
->b_buffer
[i
+1] & 0xF6) == 0xF0))
2150 len
= aac_parse_frame(&(s
->b_buffer
[i
]), &srate
, &num
);
2151 if((len
> 0) && (srate
== s
->wf
->nSamplesPerSec
) && (i
+ len
<= s
->b_buffer_len
))
2153 dur
= (double) 1024 / (double) srate
;
2154 idur
= (27000000ULL * 1024 * num
) / srate
;
2171 spriv
->timer
+= dur
;
2172 if(spriv
->drop_delayed_frames
&& delay
< 0 && spriv
->timer
<= -delay
)
2180 fill_last_frame(spriv
, &(s
->b_buffer
[tot
]), i
- tot
);
2181 frm_idx
= add_frame(spriv
, idur
, &(s
->b_buffer
[i
]), len
, 0, spriv
->last_pts
, spriv
->last_pts
);
2184 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "Couldn't add audio frame buffer(frame), abort\n");
2187 for(j
= frm_idx
; j
< spriv
->framebuf_cnt
; j
++)
2188 spriv
->framebuf
[j
].pts
= spriv
->last_pts
;
2189 spriv
->last_pts
+= idur
;
2198 memmove(s
->b_buffer
, &(s
->b_buffer
[tot
]), s
->b_buffer_len
- tot
);
2199 s
->b_buffer_len
-= tot
;
2200 s
->b_buffer_ptr
+= tot
;
2201 if(s
->b_buffer_len
> 0)
2202 memmove(s
->b_buffer
, &(s
->b_buffer
[s
->b_buffer_ptr
]), s
->b_buffer_len
);
2203 s
->b_buffer_ptr
= 0;
2208 frm_idx
= add_frame(spriv
, 0, s
->b_buffer
, s
->b_buffer_len
, 0, spriv
->last_pts
, spriv
->last_pts
);
2211 for(j
= frm_idx
; j
< spriv
->framebuf_cnt
; j
++)
2212 spriv
->framebuf
[j
].pts
= spriv
->last_pts
;
2217 *timer
= spriv
->timer
;
2222 static void fix_parameters(muxer_stream_t
*stream
)
2224 muxer_headers_t
*spriv
= stream
->priv
;
2225 muxer_t
*muxer
= stream
->muxer
;
2226 muxer_priv_t
*priv
= muxer
->priv
;
2227 uint32_t stream_format
;
2230 if(stream
->type
== MUXER_TYPE_AUDIO
)
2232 stream_format
= stream
->wf
->wFormatTag
;
2233 spriv
->is_ready
= 1;
2235 spriv
->max_buffer_size
= conf_abuf_size
*1024;
2237 spriv
->max_buffer_size
= 4*1024;
2238 if(stream
->wf
->wFormatTag
== AUDIO_A52
)
2240 stream
->ckid
= be2me_32 (0x1bd);
2241 if(priv
->is_genmpeg1
|| priv
->is_genmpeg2
)
2242 fix_audio_sys_header(priv
, spriv
->id
, 0xbd, FFMAX(conf_abuf_size
, 58)*1024); //only one audio at the moment
2245 spriv
->max_buffer_size
= 16*1024;
2247 else if(stream
->wf
->wFormatTag
== AUDIO_AAC1
|| stream
->wf
->wFormatTag
== AUDIO_AAC2
)
2249 else if(stream
->wf
->wFormatTag
== AUDIO_MP2
|| stream
->wf
->wFormatTag
== AUDIO_MP3
)
2250 spriv
->is_ready
= 0;
2254 stream_format
= stream
->bih
->biCompression
;
2256 spriv
->max_buffer_size
= conf_vbuf_size
*1024;
2260 spriv
->max_buffer_size
= 232*1024;
2261 else if(priv
->is_xsvcd
)
2262 spriv
->max_buffer_size
= 230*1024;
2263 else if(priv
->is_xvcd
)
2264 spriv
->max_buffer_size
= 46*1024;
2266 spriv
->max_buffer_size
= 232*1024; //no profile => unconstrained :) FIXME!!!
2269 if(is_mpeg4(stream
->bih
->biCompression
))
2270 spriv
->is_ready
= 0;
2272 spriv
->is_ready
= 1;
2274 if(!is_mpeg1(stream_format
) && !is_mpeg2(stream_format
))
2278 if(priv
->is_genmpeg2
&& needs_psm
)
2281 add_to_psm(priv
, spriv
->id
, stream_format
);
2282 priv
->psm_streams_cnt
++;
2287 static void mpegfile_write_chunk(muxer_stream_t
*s
,size_t len
,unsigned int flags
, double dts_arg
, double pts_arg
)
2291 muxer_t
*muxer
= s
->muxer
;
2292 muxer_priv_t
*priv
= (muxer_priv_t
*)muxer
->priv
;
2293 muxer_headers_t
*spriv
= (muxer_headers_t
*) s
->priv
;
2295 uint32_t stream_format
, nf
;
2297 if(s
->buffer
== NULL
|| len
== -1)
2300 if (s
->type
== MUXER_TYPE_VIDEO
)
2301 { // try to recognize frame type...
2302 fps
= (float) s
->h
.dwRate
/ (float) s
->h
.dwScale
;
2304 stream_format
= s
->bih
->biCompression
;
2305 if(! spriv
->vframes
)
2307 spriv
->last_dts
= spriv
->last_pts
- (uint64_t)(27000000.0f
/fps
);
2308 mp_msg(MSGT_MUXER
, MSGL_INFO
,"INITV: %.3f, %.3f, fps: %.3f\r\n", (double) spriv
->last_pts
/27000000.0f
, (double) spriv
->last_dts
/27000000.0f
, fps
);
2311 if(is_mpeg1(stream_format
) || is_mpeg2(stream_format
))
2313 spriv
->is_mpeg12
= 1;
2314 spriv
->is_ready
= 1;
2316 sz
= parse_mpeg12_video(s
, priv
, spriv
, fps
, len
);
2319 tmp
= (uint64_t) (27000000.0f
/ fps
);
2320 spriv
->last_pts
+= tmp
;
2321 spriv
->last_dts
+= tmp
;
2324 else if(is_mpeg4(stream_format
))
2326 spriv
->is_mpeg12
= 0;
2327 spriv
->telecine
= 0;
2329 sz
= parse_mpeg4_video(s
, priv
, spriv
, fps
, len
);
2332 tmp
= (uint64_t) (27000000.0f
/ fps
);
2333 spriv
->last_pts
+= tmp
;
2334 spriv
->last_dts
+= tmp
;
2338 mp_msg(MSGT_MUXER
, MSGL_DBG2
,"mpegfile_write_chunk, Video codec=%x, len=%u, mpeg12 returned %u\n", stream_format
, (uint32_t) len
, (uint32_t) sz
);
2341 { // MUXER_TYPE_AUDIO
2344 stream_format
= s
->wf
->wFormatTag
;
2346 if(s
->b_buffer_size
- s
->b_buffer_len
< len
)
2350 if(s
->b_buffer_len
> SIZE_MAX
- len
)
2352 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "\nFATAL! couldn't realloc, integer overflow\n");
2355 tmp
= realloc(s
->b_buffer
, len
+ s
->b_buffer_len
);
2358 mp_msg(MSGT_MUXER
, MSGL_FATAL
, "\nFATAL! couldn't realloc %d bytes\n", len
+ s
->b_buffer_len
);
2363 s
->b_buffer_size
= len
+ s
->b_buffer_len
;
2364 mp_msg(MSGT_MUXER
, MSGL_DBG2
, "REALLOC(%d) bytes to AUDIO backbuffer\n", s
->b_buffer_size
);
2366 memcpy(&(s
->b_buffer
[s
->b_buffer_ptr
+ s
->b_buffer_len
]), s
->buffer
, len
);
2367 s
->b_buffer_len
+= len
;
2369 if(!spriv
->is_ready
)
2371 if(s
->b_buffer_len
>= 32*1024)
2373 spriv
->mpa_layer
= analyze_mpa(s
);
2374 spriv
->is_ready
= 1;
2379 parse_audio(s
, 0, &nf
, &fake_timer
, priv
->init_adelay
, priv
->drop
);
2380 spriv
->vframes
+= nf
;
2381 if(! spriv
->vframes
)
2382 mp_msg(MSGT_MUXER
, MSGL_INFO
, "AINIT: %.3f\r\n", (double) spriv
->last_pts
/27000000.0f
);
2386 flush_buffers(muxer
, 0);
2390 static void mpegfile_write_index(muxer_t
*muxer
)
2394 muxer_priv_t
*priv
= (muxer_priv_t
*) muxer
->priv
;
2396 mp_tmsg(MSGT_MUXER
, MSGL_INFO
, "Writing index...\n");
2398 for(i
= 0; i
< muxer
->avih
.dwStreams
; i
++)
2400 if(muxer
->streams
[i
]->type
== MUXER_TYPE_AUDIO
)
2401 parse_audio(muxer
->streams
[i
], 1, &nf
, &fake_timer
, priv
->init_adelay
, priv
->drop
);
2403 while(flush_buffers(muxer
, 0) > 0);
2404 flush_buffers(muxer
, 1);
2405 if(priv
->is_genmpeg1
|| priv
->is_genmpeg2
)
2408 write_mpeg_pack(muxer
, NULL
, muxer
->stream
, 1); //insert fake Nav Packet
2411 mp_msg(MSGT_MUXER
, MSGL_INFO
, "\nOverhead: %.3f%% (%"PRIu64
" / %"PRIu64
")\n", 100.0 * (double)priv
->headers_size
/ (double)priv
->data_size
, priv
->headers_size
, priv
->data_size
);
2414 static void mpegfile_write_header(muxer_t
*muxer
)
2416 muxer_priv_t
*priv
= (muxer_priv_t
*) muxer
->priv
;
2418 mp_tmsg(MSGT_MUXER
, MSGL_INFO
, "Writing header...\n");
2420 priv
->headers_cnt
++;
2422 //write the first system header only for generic mpeg1/2 muxes, and only when we have collected all necessary infos
2423 if(priv
->is_genmpeg1
|| priv
->is_genmpeg2
|| ((priv
->is_xvcd
|| priv
->is_xsvcd
) && (priv
->headers_cnt
== 1)))
2425 write_mpeg_pack(muxer
, NULL
, muxer
->stream
, 0);
2426 priv
->update_system_header
= 0;
2432 static void setup_sys_params(muxer_priv_t
*priv
)
2436 int v
= (conf_vbuf_size
? conf_vbuf_size
: 232);
2437 int a1
= (conf_abuf_size
? conf_abuf_size
: 4);
2438 int a2
= (conf_abuf_size
>58 ? conf_abuf_size
: 58);
2440 priv
->sys_info
.cnt
= 4;
2442 priv
->sys_info
.streams
[0].id
= 0xb9;
2443 priv
->sys_info
.streams
[0].type
= 1;
2444 priv
->sys_info
.streams
[0].bufsize
= v
*1024;
2446 priv
->sys_info
.streams
[1].id
= 0xb8;
2447 priv
->sys_info
.streams
[1].type
= 0;
2448 priv
->sys_info
.streams
[1].bufsize
= a1
*1024;
2450 priv
->sys_info
.streams
[2].id
= 0xbd;
2451 priv
->sys_info
.streams
[2].type
= 1;
2452 priv
->sys_info
.streams
[2].bufsize
= a2
*1024;
2454 priv
->sys_info
.streams
[3].id
= 0xbf;
2455 priv
->sys_info
.streams
[3].type
= 1;
2456 priv
->sys_info
.streams
[3].bufsize
= 2*1024;
2458 else if(priv
->is_xvcd
|| priv
->is_xsvcd
)
2460 int v
= (conf_vbuf_size
? conf_vbuf_size
: (priv
->is_xvcd
? 46: 230));
2461 int a1
= (conf_abuf_size
? conf_abuf_size
: 4);
2463 priv
->sys_info
.cnt
= 2;
2465 priv
->sys_info
.streams
[0].id
= 0xe0;
2466 priv
->sys_info
.streams
[0].type
= 1;
2467 priv
->sys_info
.streams
[0].bufsize
= v
*1024;
2469 priv
->sys_info
.streams
[1].id
= 0xc0;
2470 priv
->sys_info
.streams
[1].type
= 0;
2471 priv
->sys_info
.streams
[1].bufsize
= a1
*1024;
2474 priv
->sys_info
.cnt
= 0;
2477 /* excerpt from DGPulldown Copyright (C) 2005-2006, Donald Graft */
2478 static void generate_flags(uint8_t *bff_mask
, int source
, int target
)
2480 unsigned int i
, trfp
;
2482 unsigned char ormask
[4] = {0x0, 0x2, 0x80, 0x82};
2484 dfl
= (target
- source
) << 1;
2488 for(i
= 0; i
< MAX_PATTERN_LENGTH
; i
++)
2494 bff_mask
[i
] = ormask
[trfp
+ 1];
2498 bff_mask
[i
] = ormask
[trfp
];
2502 int muxer_init_muxer_mpeg(muxer_t
*muxer
)
2505 priv
= calloc(1, sizeof(muxer_priv_t
));
2508 priv
->update_system_header
= 1;
2510 //calloc() already zero-ed all flags, so we assign only the ones we need
2512 if(conf_mux
!= NULL
)
2514 if(! strcasecmp(conf_mux
, "mpeg1"))
2516 priv
->mux
= MUX_MPEG1
;
2517 priv
->packet_size
= 2048;
2518 priv
->is_genmpeg1
= 1;
2519 priv
->muxrate
= 1800 * 125; //Constrained parameters
2521 else if(! strcasecmp(conf_mux
, "dvd"))
2523 priv
->mux
= MUX_MPEG2
;
2525 priv
->packet_size
= 2048;
2526 priv
->muxrate
= 10080 * 125;
2528 else if(! strcasecmp(conf_mux
, "xsvcd"))
2530 priv
->mux
= MUX_MPEG2
;
2532 priv
->packet_size
= 2324;
2533 priv
->muxrate
= 150*2324;
2534 priv
->ts_allframes
= 1;
2536 else if(! strcasecmp(conf_mux
, "xvcd"))
2538 priv
->mux
= MUX_MPEG1
;
2540 priv
->packet_size
= 2324;
2541 priv
->muxrate
= 75*2352;
2542 priv
->ts_allframes
= 1;
2544 else if(! strcasecmp(conf_mux
, "pes1"))
2546 priv
->mux
= MUX_MPEG1
;
2548 priv
->packet_size
= 2048;
2549 priv
->muxrate
= 10080 * 125;
2550 priv
->ts_allframes
= 1;
2552 else if(! strcasecmp(conf_mux
, "pes2"))
2554 priv
->mux
= MUX_MPEG2
;
2556 priv
->packet_size
= 2048;
2557 priv
->muxrate
= 10080 * 125;
2558 priv
->ts_allframes
= 1;
2562 if(strcasecmp(conf_mux
, "mpeg2"))
2563 mp_msg(MSGT_MUXER
, MSGL_ERR
, "Unknown format %s, default to mpeg2\n", conf_mux
);
2564 priv
->mux
= MUX_MPEG2
;
2565 priv
->is_genmpeg2
= 1;
2566 priv
->packet_size
= 2048;
2567 priv
->muxrate
= 1800 * 125; //Constrained parameters
2571 if(conf_ts_allframes
)
2572 priv
->ts_allframes
= 1;
2573 if(conf_muxrate
> 0)
2574 priv
->muxrate
= conf_muxrate
* 125; // * 1000 / 8
2575 if(conf_packet_size
)
2576 priv
->packet_size
= conf_packet_size
;
2577 priv
->delta_scr
= (uint64_t) (90000.0f
*300.0f
*(double)priv
->packet_size
/(double)priv
->muxrate
);
2578 mp_msg(MSGT_MUXER
, MSGL_INFO
, "PACKET SIZE: %u bytes, deltascr: %"PRIu64
"\n", priv
->packet_size
, priv
->delta_scr
);
2579 setup_sys_params(priv
);
2581 if(conf_vaspect
> 0)
2583 int asp
= (int) (conf_vaspect
* 1000.0f
);
2584 if(asp
>= 1332 && asp
<= 1334)
2585 priv
->vaspect
= ASPECT_4_3
;
2586 else if(asp
>= 1776 && asp
<= 1778)
2587 priv
->vaspect
= ASPECT_16_9
;
2588 else if(asp
>= 2209 && asp
<= 2211)
2589 priv
->vaspect
= ASPECT_2_21_1
;
2590 else if(asp
== 1000)
2591 priv
->vaspect
= ASPECT_1_1
;
2593 mp_msg(MSGT_MUXER
, MSGL_ERR
, "ERROR: unrecognized aspect %.3f\n", conf_vaspect
);
2596 priv
->vframerate
= 0; // no change
2597 if(conf_telecine
&& conf_vframerate
> 0)
2599 mp_msg(MSGT_MUXER
, MSGL_ERR
, "ERROR: options 'telecine' and 'vframerate' are mutually exclusive, vframerate disabled\n");
2600 conf_vframerate
= 0;
2603 if(conf_telecine
== TELECINE_FILM2PAL
)
2605 if(conf_telecine_src
==0.0f
) conf_telecine_src
= 24000.0/1001.0;
2606 conf_telecine_dest
= 25;
2607 conf_telecine
= TELECINE_DGPULLDOWN
;
2609 else if(conf_telecine
== PULLDOWN32
)
2611 if(conf_telecine_src
==0.0f
) conf_telecine_src
= 24000.0/1001.0;
2612 conf_telecine_dest
= 30000.0/1001.0;
2613 conf_telecine
= TELECINE_DGPULLDOWN
;
2616 if(conf_telecine_src
>0 && conf_telecine_dest
>0 && conf_telecine_src
< conf_telecine_dest
)
2620 sfps
= (int) (conf_telecine_src
* 1001 + 0.5);
2621 tfps
= (int) (conf_telecine_dest
* 1001 + 0.5);
2622 if(sfps
% 2 || tfps
% 2)
2628 if(((tfps
- sfps
)>>1) > sfps
)
2630 mp_msg(MSGT_MUXER
, MSGL_ERR
, "ERROR! Framerate increment must be <= 1.5, telecining disabled\n");
2635 generate_flags(priv
->bff_mask
, sfps
, tfps
);
2636 conf_telecine
= TELECINE_DGPULLDOWN
;
2637 conf_vframerate
= conf_telecine_dest
;
2645 fps
= (int) (conf_vframerate
* 1001 + 0.5);
2649 priv
->vframerate
= FRAMERATE_23976
;
2652 priv
->vframerate
= FRAMERATE_24
;
2655 priv
->vframerate
= FRAMERATE_25
;
2658 priv
->vframerate
= FRAMERATE_2997
;
2661 priv
->vframerate
= FRAMERATE_30
;
2664 priv
->vframerate
= FRAMERATE_50
;
2667 priv
->vframerate
= FRAMERATE_5994
;
2670 priv
->vframerate
= FRAMERATE_60
;
2674 mp_msg(MSGT_MUXER
, MSGL_ERR
, "WRONG FPS: %d/1000, ignoring\n", fps
);
2676 mp_msg(MSGT_MUXER
, MSGL_ERR
, "DISABLED TELECINING\n");
2682 priv
->vwidth
= (uint16_t) conf_vwidth
;
2683 priv
->vheight
= (uint16_t) conf_vheight
;
2684 priv
->panscan_width
= (uint16_t) conf_panscan_width
;
2685 priv
->panscan_height
= (uint16_t) conf_panscan_height
;
2686 priv
->vbitrate
= ((conf_vbitrate
) * 10) >> 2; //*1000 / 400
2688 if(priv
->vaspect
|| priv
->vframerate
|| priv
->vwidth
|| priv
->vheight
|| priv
->vbitrate
|| priv
->panscan_width
|| priv
->panscan_height
)
2690 priv
->patch_seq
= priv
->vaspect
|| priv
->vframerate
|| priv
->vwidth
|| priv
->vheight
|| priv
->vbitrate
;
2691 priv
->patch_sde
= priv
->panscan_width
|| priv
->panscan_height
;
2692 mp_msg(MSGT_MUXER
, MSGL_INFO
, "MPEG MUXER, patching");
2693 if(priv
->vwidth
|| priv
->vheight
)
2694 mp_msg(MSGT_MUXER
, MSGL_INFO
, " resolution to %dx%d", priv
->vwidth
, priv
->vheight
);
2695 if(priv
->panscan_width
|| priv
->panscan_height
)
2696 mp_msg(MSGT_MUXER
, MSGL_INFO
, " panscan to to %dx%d", priv
->panscan_width
, priv
->panscan_height
);
2697 if(priv
->vframerate
)
2698 mp_msg(MSGT_MUXER
, MSGL_INFO
, " framerate to %s fps", framerates
[priv
->vframerate
]);
2700 mp_msg(MSGT_MUXER
, MSGL_INFO
, " aspect ratio to %s", aspect_ratios
[priv
->vaspect
]);
2702 mp_msg(MSGT_MUXER
, MSGL_INFO
, " bitrate to %u", conf_vbitrate
);
2703 mp_msg(MSGT_MUXER
, MSGL_INFO
, "\n");
2706 priv
->has_video
= priv
->has_audio
= 0;
2708 muxer
->sysrate
= priv
->muxrate
; // initial muxrate = constrained stream parameter
2709 priv
->scr
= muxer
->file_end
= 0;
2711 if(conf_init_vdelay
&& conf_drop
)
2713 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\nmuxer_mpg, :drop and :vdelay used together are not supported, exiting\n");
2716 if(conf_init_adelay
)
2717 priv
->init_adelay
= - (double) conf_init_adelay
/ (double) 1000.0;
2719 priv
->drop
= conf_drop
;
2721 priv
->buff
= malloc(priv
->packet_size
);
2722 if((priv
->buff
== NULL
))
2724 mp_msg(MSGT_MUXER
, MSGL_ERR
, "\nCouldn't allocate %d bytes, exit\n", priv
->packet_size
);
2728 muxer
->priv
= (void *) priv
;
2729 muxer
->cont_new_stream
= &mpegfile_new_stream
;
2730 muxer
->cont_write_chunk
= &mpegfile_write_chunk
;
2731 muxer
->cont_write_header
= &mpegfile_write_header
;
2732 muxer
->cont_write_index
= &mpegfile_write_index
;
2733 muxer
->fix_stream_parameters
= &fix_parameters
;