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