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