← Back to branch summary

~ubuntu-branches/debian/sid/mplayer/sid

« back to all changes in this revision

Viewing changes to libmpdemux/muxer_mpeg.c

  • Committer: Bazaar Package Importer
  • Author(s): A Mennucc1
  • Date: 2009-03-23 10:05:45 UTC
  • mfrom: (4.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20090323100545-x8h79obawnnte7kk
Tags: 1.0~rc2+svn20090303-5
debian/control : move docbook-xml,docbook-xsl,xsltproc from 
Build-Depends-Indep to Build-Depends, since they are needed to run
configure

Show diffs side-by-side

added added

removed removed

Lines of Context:
libmpdemux/muxer_mpeg.c
6
6
#include <sys/types.h>
7
7
 
8
8
#include "config.h"
9
 
#include "version.h"
10
9
#include "mp_msg.h"
11
10
#include "help_mp.h"
12
11
 
59
58
static char ftypes[] = {'?', 'I', 'P', 'B'}; 
60
59
#define FTYPE(x) (ftypes[(x)])
61
60
 
62
 
#define MAX_PATTERN_LENGTH 2000000
63
 
static unsigned char bff_mask[MAX_PATTERN_LENGTH];      //2 million frames are enough
64
 
 
65
61
static const char *framerates[] = {
66
62
        "unchanged", "23.976", "24", "25", "29.97", "30", "50", "59.94", "60"
67
63
};
142
138
        off_t headers_size, data_size;
143
139
        uint64_t scr;
144
140
        uint64_t delta_scr;
 
141
        uint64_t last_psm_scr;
145
142
        uint32_t muxrate;
146
143
        uint8_t *buff;
147
144
        uint32_t headers_cnt;
154
151
        uint32_t vbitrate;
155
152
        int patch_seq, patch_sde;
156
153
        int psm_streams_cnt;
 
154
 
 
155
//2 million frames are enough
 
156
#define MAX_PATTERN_LENGTH 2000000
 
157
        uint8_t bff_mask[MAX_PATTERN_LENGTH];
157
158
} muxer_priv_t;
158
159
 
159
160
 
160
161
typedef struct {
161
 
        int has_pts, has_dts, pes_is_aligned, type, min_pes_hlen, psm_fixed;
 
162
        int has_pts, has_dts, pes_is_aligned, type, min_pes_hlen;
162
163
        int delay_rff;
163
164
        uint64_t pts, last_pts, last_dts, dts, size, frame_duration, delta_pts, nom_delta_pts, last_saved_pts;
164
165
        uint32_t buffer_size;
230
231
 
231
232
static inline int is_mpeg1(uint32_t x)
232
233
{
233
 
        return (
 
234
        return
234
235
                (x == 0x10000001) ||
235
236
                (x == mmioFOURCC('m','p','g','1')) ||
236
 
                (x == mmioFOURCC('M','P','G','1'))
237
 
        );
 
237
                (x == mmioFOURCC('M','P','G','1'));
238
238
}
239
239
 
240
240
static inline int is_mpeg2(uint32_t x)
241
241
{
242
 
        return (
 
242
        return
243
243
                (x == 0x10000002) ||
244
244
                (x == mmioFOURCC('m','p','g','2')) ||
245
245
                (x == mmioFOURCC('M','P','G','2')) ||
246
246
                (x == mmioFOURCC('m','p','e','g')) ||
247
 
                (x == mmioFOURCC('M','P','E','G'))
248
 
        );
 
247
                (x == mmioFOURCC('M','P','E','G'));
249
248
}
250
249
 
251
250
static inline int is_mpeg4(uint32_t x)
252
251
{
253
 
        return (
 
252
        return
254
253
                (x == 0x10000004) ||
255
254
                (x == mmioFOURCC('d','i','v','x')) ||
256
255
                (x == mmioFOURCC('D','I','V','X')) ||
264
263
                (x == mmioFOURCC('F', 'M','P','4')) ||
265
264
                (x == mmioFOURCC('f', 'm','p','4')) ||
266
265
                (x == mmioFOURCC('D', 'X','5','0')) ||
267
 
                (x == mmioFOURCC('d', 'x','5','0'))
268
 
        );
 
266
                (x == mmioFOURCC('d', 'x','5','0'));
269
267
}
270
268
 
271
269
//from unrarlib.c
540
538
        scr_ext = ts % 300ULL;
541
539
        ts /= 300ULL;
542
540
        ts &= 0x1FFFFFFFFULL;   //33 bits
543
 
        t1 = (ts >> 30) & 0x7;;
 
541
        t1 = (ts >> 30) & 0x7;
544
542
        t2 = (ts >> 15) & 0x7fff;
545
543
        t3 = ts & 0x7fff;
546
544
        
647
645
                        buff[len++] = priv->psm_info.streams[i].type;
648
646
                        buff[len++] = priv->psm_info.streams[i].id;
649
647
                        buff[len++] = 0;        //len of descriptor upper ...
650
 
                        buff[len++] = 6;        //... lower
 
648
                        buff[len++] = 0;        //... lower
651
649
                        
652
 
                        //registration descriptor
653
 
                        buff[len++] = 0x5;      //tag
654
 
                        buff[len++] = 4;        //length: 4 bytes
655
 
                        memcpy(&(buff[len]), (char*) &(priv->psm_info.streams[i].format), 4);
656
 
                        len += 4;
657
 
                        dlen += 10;
 
650
                        dlen += 4;
658
651
                }
659
652
        }
660
653
        *(uint16_t *)(&buff[10]) = be2me_16(dlen);      //length of the es descriptors
668
661
        return len;
669
662
}
670
663
 
 
664
static int psm_is_late(muxer_priv_t *priv)
 
665
{
 
666
        return !priv->data_size || (priv->scr >= priv->last_psm_scr + 27000000ULL);
 
667
}
 
668
 
671
669
static int write_mpeg_pes_header(muxer_headers_t *h, uint8_t *pes_id, uint8_t *buff, uint16_t plen, int stuffing_len, int mux_type)
672
670
{
673
671
        int len;
726
724
 
727
725
        
728
726
        if(mux_type == MUX_MPEG2)
729
 
        {       
 
727
        {
730
728
                if(h->buffer_size > 0)
731
729
                {
732
730
                        buff[len] = 0x1e;       //std flag
758
756
        memset(&buff[6], 0xff, len - 6);
759
757
}
760
758
 
761
 
static void write_psm_block(muxer_t *muxer, stream_t *stream)
762
 
{
763
 
        uint16_t offset, stuffing_len;
764
 
        muxer_priv_t *priv = (muxer_priv_t *) muxer->priv;
765
 
        uint8_t *buff = priv->buff;
766
 
        
767
 
        offset = write_mpeg_pack_header(muxer, buff);
768
 
        offset += write_mpeg_psm(muxer, &buff[offset]);
769
 
        stuffing_len = priv->packet_size - offset;
770
 
        if(stuffing_len > 0)
771
 
        {
772
 
                //insert a PES padding packet
773
 
                write_pes_padding(&buff[offset], stuffing_len);
774
 
                offset += stuffing_len;
775
 
        }
776
 
        stream_write_buffer(stream, buff, offset);
777
 
        priv->headers_size += offset;
778
 
}
779
 
 
780
759
 
781
760
static int write_nav_pack(uint8_t *buff)
782
761
{
802
781
        return len;
803
782
}
804
783
 
 
784
static unsigned int calc_psm_len(muxer_priv_t *priv)
 
785
{
 
786
        return 16 + 4*(priv->psm_info.cnt);
 
787
}
 
788
 
805
789
static uint32_t calc_pes_hlen(int format, muxer_headers_t *h, muxer_priv_t *priv)
806
790
{
807
791
        uint32_t len;
1047
1031
                pack_hlen = 12;
1048
1032
        else
1049
1033
                pack_hlen = 14;
 
1034
        if(priv->use_psm && psm_is_late(priv))
 
1035
                pack_hlen += calc_psm_len(priv);
1050
1036
 
1051
1037
        if(find_packet_timestamps(priv, s, pack_hlen, &dts, &pts))
1052
1038
        {
1121
1107
static int fill_packet(muxer_t *muxer, muxer_stream_t *s, int finalize)
1122
1108
{
1123
1109
        //try to fill a packet as much as possible
1124
 
        //spriv->pack_offset is the start position inited to 0
 
1110
        //spriv->pack_offset is the start position initialized to 0
1125
1111
        //data is taken from spriv->framebuf
1126
1112
        //if audio and a52 insert the headers
1127
1113
        muxer_priv_t *priv = (muxer_priv_t *) muxer->priv;
1128
1114
        muxer_headers_t *spriv = (muxer_headers_t *) s->priv;
1129
1115
        int len, m, n, dvd_pack = 0;
 
1116
        int write_psm = 0;
1130
1117
        mpeg_frame_t *frm;
1131
1118
        pack_stats_t p;
1132
1119
 
1149
1136
                        spriv->pack_offset += write_mpeg_system_header(muxer, &spriv->pack[spriv->pack_offset]);
1150
1137
                        priv->update_system_header = 0;
1151
1138
                }
 
1139
 
 
1140
                if(priv->use_psm && psm_is_late(priv))
 
1141
                {
 
1142
                        spriv->pack_offset += write_mpeg_psm(muxer, &spriv->pack[spriv->pack_offset]);
 
1143
                        write_psm = 1;
 
1144
                }
 
1145
 
1152
1146
                spriv->pes_set = 0;
1153
1147
                spriv->pes_offset = spriv->pack_offset;
1154
1148
                spriv->payload_offset = 0;
1278
1272
        spriv->pack_offset = 0;
1279
1273
        spriv->pes_set = 0;
1280
1274
        spriv->frames = 0;
 
1275
        if(write_psm)
 
1276
                priv->last_psm_scr = priv->scr;
1281
1277
        
1282
1278
        return len;
1283
1279
}
1612
1608
                se_ptr[1] &= 0xf7;
1613
1609
        
1614
1610
        //disable tff and rff and overwrite them with the value in bff_mask
1615
 
        pce_ptr[3] = (pce_ptr[3] & 0x7d) | bff_mask[vpriv->display_frame % MAX_PATTERN_LENGTH];
 
1611
        pce_ptr[3] = (pce_ptr[3] & 0x7d) | priv->bff_mask[vpriv->display_frame % MAX_PATTERN_LENGTH];
1616
1612
        pce_ptr[4] |= 0x80;     //sets progressive frame
1617
1613
        
1618
1614
        vpriv->display_frame += n;
2052
2048
        return layer;   //actual layer with the highest score
2053
2049
}
2054
2050
 
2055
 
extern int aac_parse_frame(uint8_t *buf, int *srate, int *num);
 
2051
int aac_parse_frame(uint8_t *buf, int *srate, int *num);
2056
2052
 
2057
2053
static int parse_audio(muxer_stream_t *s, int finalize, unsigned int *nf, double *timer, double delay, int drop)
2058
2054
{
2105
2101
                                if(s->b_buffer[i] == 0x0B && s->b_buffer[i+1] == 0x77)
2106
2102
                                {
2107
2103
                                        srate = 0;
2108
 
                                #ifdef USE_LIBA52
 
2104
                                #ifdef CONFIG_LIBA52
2109
2105
                                        len = a52_syncinfo(&(s->b_buffer[i]), &dummy, &srate, &dummy);
2110
2106
                                #else
2111
2107
                                        len = mp_a52_framesize(&(s->b_buffer[i]), &srate);
2209
2205
        muxer_headers_t *spriv = stream->priv;
2210
2206
        muxer_t *muxer = stream->muxer;
2211
2207
        muxer_priv_t *priv = muxer->priv;
 
2208
        uint32_t stream_format;
 
2209
        int needs_psm = 0;
2212
2210
 
2213
2211
        if(stream->type == MUXER_TYPE_AUDIO)
2214
2212
        {
 
2213
                stream_format = stream->wf->wFormatTag;
2215
2214
                spriv->is_ready = 1;
2216
2215
                if(conf_abuf_size)
2217
2216
                        spriv->max_buffer_size = conf_abuf_size*1024;
2227
2226
                        spriv->max_buffer_size = 16*1024;
2228
2227
                }
2229
2228
                else if(stream->wf->wFormatTag == AUDIO_AAC1 || stream->wf->wFormatTag == AUDIO_AAC2)
2230
 
                {
2231
 
                        priv->use_psm = 1;
2232
 
                }
 
2229
                        needs_psm = 1;
2233
2230
                else if(stream->wf->wFormatTag == AUDIO_MP2 || stream->wf->wFormatTag == AUDIO_MP3)
2234
2231
                        spriv->is_ready = 0;
2235
2232
        }
2236
2233
        else    //video
2237
2234
        {
 
2235
                stream_format = stream->bih->biCompression;
2238
2236
                if(conf_vbuf_size)
2239
2237
                        spriv->max_buffer_size = conf_vbuf_size*1024;
2240
2238
                else
2241
2239
                {
2242
 
                if(priv->is_dvd)
2243
 
                        spriv->max_buffer_size = 232*1024;
2244
 
                else if(priv->is_xsvcd)
2245
 
                        spriv->max_buffer_size = 230*1024;
2246
 
                else if(priv->is_xvcd)
2247
 
                        spriv->max_buffer_size = 46*1024;
2248
 
                else
2249
 
                        spriv->max_buffer_size = 232*1024;      //no profile => unconstrained :) FIXME!!!
 
2240
                        if(priv->is_dvd)
 
2241
                                spriv->max_buffer_size = 232*1024;
 
2242
                        else if(priv->is_xsvcd)
 
2243
                                spriv->max_buffer_size = 230*1024;
 
2244
                        else if(priv->is_xvcd)
 
2245
                                spriv->max_buffer_size = 46*1024;
 
2246
                        else
 
2247
                                spriv->max_buffer_size = 232*1024;      //no profile => unconstrained :) FIXME!!!
2250
2248
                }
2251
2249
                
2252
2250
                if(is_mpeg4(stream->bih->biCompression))
2253
2251
                        spriv->is_ready = 0;
2254
2252
                else
2255
2253
                        spriv->is_ready = 1;
2256
 
        }
2257
 
}
2258
 
 
2259
 
 
2260
 
static void mpegfile_write_chunk(muxer_stream_t *s,size_t len,unsigned int flags, double dts_arg, double pts_arg){
2261
 
  size_t sz = 0;
2262
 
  uint64_t tmp;
2263
 
  muxer_t *muxer = s->muxer;
2264
 
  muxer_priv_t *priv = (muxer_priv_t *)muxer->priv;
2265
 
  muxer_headers_t *spriv = (muxer_headers_t*) s->priv;
2266
 
  float fps;
2267
 
  uint32_t stream_format, nf;
2268
 
 
2269
 
  if(s->buffer == NULL)
2270
 
        return;
2271
 
  if(len == -1)
2272
 
        return;
2273
 
 
2274
 
  if (s->type == MUXER_TYPE_VIDEO) { // try to recognize frame type...
2275
 
        fps = (float) s->h.dwRate/ (float) s->h.dwScale;
2276
 
        spriv->type = 1;
2277
 
        stream_format = s->bih->biCompression;
2278
 
        if(! spriv->vframes)
2279
 
        {
2280
 
                spriv->last_dts = spriv->last_pts - (uint64_t)(27000000.0f/fps);
2281
 
                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);
2282
 
        }
2283
 
 
2284
 
    if(is_mpeg1(stream_format) || is_mpeg2(stream_format))
2285
 
    {
2286
 
      spriv->is_mpeg12 = 1;
2287
 
      spriv->is_ready = 1;
2288
 
      if(len)
2289
 
        sz = parse_mpeg12_video(s, priv, spriv, fps, len);
2290
 
      else {
2291
 
        tmp = (uint64_t) (27000000.0f / fps);
2292
 
        spriv->last_pts += tmp;
2293
 
        spriv->last_dts += tmp;
2294
 
      }
2295
 
    }
2296
 
    else if(is_mpeg4(stream_format)) 
2297
 
    {
2298
 
      spriv->is_mpeg12 = 0;
2299
 
      spriv->telecine = 0;
2300
 
      if(spriv->size == 0)
2301
 
        priv->use_psm = 1;
2302
 
      if(len)
2303
 
        sz = parse_mpeg4_video(s, priv, spriv, fps, len);
2304
 
      else {
2305
 
        tmp = (uint64_t) (27000000.0f / fps);
2306
 
        spriv->last_pts += tmp;
2307
 
        spriv->last_dts += tmp;
2308
 
      }
2309
 
    }
2310
 
 
2311
 
    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);
2312
 
  } else { // MUXER_TYPE_AUDIO
2313
 
        double fake_timer;
2314
 
        spriv->type = 0;
2315
 
        stream_format = s->wf->wFormatTag;
2316
 
 
2317
 
        if(s->b_buffer_size - s->b_buffer_len < len)
2318
 
        {
2319
 
                if(s->b_buffer_len > SIZE_MAX - len)
2320
 
                {
2321
 
                        mp_msg(MSGT_MUXER, MSGL_FATAL, "\nFATAL! couldn't realloc, integer overflow\n");
2322
 
                        return;
2323
 
                }
2324
 
                s->b_buffer = realloc(s->b_buffer, len  + s->b_buffer_len);
2325
 
                if(s->b_buffer == NULL)
2326
 
                {
2327
 
                        mp_msg(MSGT_MUXER, MSGL_FATAL, "\nFATAL! couldn't realloc %d bytes\n", len  + s->b_buffer_len);
2328
 
                        return;
2329
 
                }
2330
 
                
2331
 
                s->b_buffer_size = len  + s->b_buffer_len;
2332
 
                mp_msg(MSGT_MUXER, MSGL_DBG2, "REALLOC(%d) bytes to AUDIO backbuffer\n", s->b_buffer_size);
2333
 
        }
2334
 
        memcpy(&(s->b_buffer[s->b_buffer_ptr + s->b_buffer_len]), s->buffer, len);
2335
 
        s->b_buffer_len += len;
 
2254
 
 
2255
                if(!is_mpeg1(stream_format) && !is_mpeg2(stream_format))
 
2256
                        needs_psm = 1;
 
2257
        }
2336
2258
        
2337
 
        if(!spriv->is_ready)
 
2259
        if(priv->is_genmpeg2 && needs_psm)
2338
2260
        {
2339
 
                if(s->b_buffer_len >= 32*1024)
2340
 
                {
2341
 
                        spriv->mpa_layer = analyze_mpa(s);
 
2261
                priv->use_psm = 1;
 
2262
                add_to_psm(priv, spriv->id, stream_format);
 
2263
                priv->psm_streams_cnt++;
 
2264
        }
 
2265
}
 
2266
 
 
2267
 
 
2268
static void mpegfile_write_chunk(muxer_stream_t *s,size_t len,unsigned int flags, double dts_arg, double pts_arg)
 
2269
{
 
2270
        size_t sz = 0;
 
2271
        uint64_t tmp;
 
2272
        muxer_t *muxer = s->muxer;
 
2273
        muxer_priv_t *priv = (muxer_priv_t *)muxer->priv;
 
2274
        muxer_headers_t *spriv = (muxer_headers_t*) s->priv;
 
2275
        float fps;
 
2276
        uint32_t stream_format, nf;
 
2277
 
 
2278
        if(s->buffer == NULL || len == -1)
 
2279
                return;
 
2280
 
 
2281
        if (s->type == MUXER_TYPE_VIDEO)
 
2282
        { // try to recognize frame type...
 
2283
                fps = (float) s->h.dwRate/ (float) s->h.dwScale;
 
2284
                spriv->type = 1;
 
2285
                stream_format = s->bih->biCompression;
 
2286
                if(! spriv->vframes)
 
2287
                {
 
2288
                        spriv->last_dts = spriv->last_pts - (uint64_t)(27000000.0f/fps);
 
2289
                        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);
 
2290
                }
 
2291
 
 
2292
                if(is_mpeg1(stream_format) || is_mpeg2(stream_format))
 
2293
                {
 
2294
                        spriv->is_mpeg12 = 1;
2342
2295
                        spriv->is_ready = 1;
2343
 
                }
 
2296
                        if(len)
 
2297
                                sz = parse_mpeg12_video(s, priv, spriv, fps, len);
 
2298
                        else
 
2299
                        {
 
2300
                                tmp = (uint64_t) (27000000.0f / fps);
 
2301
                                spriv->last_pts += tmp;
 
2302
                                spriv->last_dts += tmp;
 
2303
                        }
 
2304
                }
 
2305
                else if(is_mpeg4(stream_format)) 
 
2306
                {
 
2307
                        spriv->is_mpeg12 = 0;
 
2308
                        spriv->telecine = 0;
 
2309
                        if(len)
 
2310
                                sz = parse_mpeg4_video(s, priv, spriv, fps, len);
 
2311
                        else
 
2312
                        {
 
2313
                                tmp = (uint64_t) (27000000.0f / fps);
 
2314
                                spriv->last_pts += tmp;
 
2315
                                spriv->last_dts += tmp;
 
2316
                        }
 
2317
                }
 
2318
                
 
2319
                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);
2344
2320
        }
2345
2321
        else
2346
 
        {
2347
 
        parse_audio(s, 0, &nf, &fake_timer, priv->init_adelay, priv->drop);
2348
 
        spriv->vframes += nf;
2349
 
        if(! spriv->vframes)
2350
 
                mp_msg(MSGT_MUXER, MSGL_INFO, "AINIT: %.3lf\r\n", (double) spriv->last_pts/27000000.0f);        
 
2322
        { // MUXER_TYPE_AUDIO
 
2323
                double fake_timer;
 
2324
                spriv->type = 0;
 
2325
                stream_format = s->wf->wFormatTag;
 
2326
                
 
2327
                if(s->b_buffer_size - s->b_buffer_len < len)
 
2328
                {
 
2329
                        void *tmp;
 
2330
 
 
2331
                        if(s->b_buffer_len > SIZE_MAX - len)
 
2332
                        {
 
2333
                                mp_msg(MSGT_MUXER, MSGL_FATAL, "\nFATAL! couldn't realloc, integer overflow\n");
 
2334
                                return;
 
2335
                        }
 
2336
                        tmp = realloc(s->b_buffer, len  + s->b_buffer_len);
 
2337
                        if(!tmp)
 
2338
                        {
 
2339
                                mp_msg(MSGT_MUXER, MSGL_FATAL, "\nFATAL! couldn't realloc %d bytes\n", len  + s->b_buffer_len);
 
2340
                                return;
 
2341
                        }
 
2342
                        s->b_buffer = tmp;
 
2343
                        
 
2344
                        s->b_buffer_size = len  + s->b_buffer_len;
 
2345
                        mp_msg(MSGT_MUXER, MSGL_DBG2, "REALLOC(%d) bytes to AUDIO backbuffer\n", s->b_buffer_size);
 
2346
                }
 
2347
                memcpy(&(s->b_buffer[s->b_buffer_ptr + s->b_buffer_len]), s->buffer, len);
 
2348
                s->b_buffer_len += len;
 
2349
                
 
2350
                if(!spriv->is_ready)
 
2351
                {
 
2352
                        if(s->b_buffer_len >= 32*1024)
 
2353
                        {
 
2354
                                spriv->mpa_layer = analyze_mpa(s);
 
2355
                                spriv->is_ready = 1;
 
2356
                        }
 
2357
                }
 
2358
                else
 
2359
                {
 
2360
                        parse_audio(s, 0, &nf, &fake_timer, priv->init_adelay, priv->drop);
 
2361
                        spriv->vframes += nf;
 
2362
                        if(! spriv->vframes)
 
2363
                                mp_msg(MSGT_MUXER, MSGL_INFO, "AINIT: %.3lf\r\n", (double) spriv->last_pts/27000000.0f);        
 
2364
                }
2351
2365
        }
2352
 
  }
2353
 
 
2354
 
 
2355
 
  if(spriv->psm_fixed == 0) {
2356
 
        add_to_psm(priv, spriv->id, stream_format);
2357
 
        spriv->psm_fixed = 1;
2358
 
        priv->psm_streams_cnt++;
2359
 
        if((priv->psm_streams_cnt == muxer->num_videos + muxer->num_audios) && priv->use_psm)
2360
 
                write_psm_block(muxer, muxer->stream);
2361
 
  }
2362
 
 
2363
 
  flush_buffers(muxer, 0);
 
2366
 
 
2367
        flush_buffers(muxer, 0);
2364
2368
}
2365
2369
 
2366
2370
 
2452
2456
}
2453
2457
 
2454
2458
/* excerpt from DGPulldown Copyright (C) 2005-2006, Donald Graft */
2455
 
static void generate_flags(int source, int target)
 
2459
static void generate_flags(uint8_t *bff_mask, int source, int target)
2456
2460
{
2457
2461
        unsigned int i, trfp;
2458
2462
        uint64_t dfl,tfl;
2476
2480
        }
2477
2481
}
2478
2482
 
2479
 
int muxer_init_muxer_mpeg(muxer_t *muxer){
2480
 
  muxer_priv_t *priv;
2481
 
  priv = (muxer_priv_t *) calloc(1, sizeof(muxer_priv_t));
2482
 
  if(priv == NULL)
2483
 
        return 0;
2484
 
  priv->update_system_header = 1;
2485
 
 
2486
 
  //calloc() already zero-ed all flags, so we assign only the ones we need
2487
 
 
2488
 
  if(conf_mux != NULL) {
2489
 
    if(! strcasecmp(conf_mux, "mpeg1"))
2490
 
    {
2491
 
        priv->mux = MUX_MPEG1;
2492
 
        priv->packet_size = 2048;
2493
 
        priv->is_genmpeg1 = 1;
2494
 
        priv->muxrate = 1800 * 125;     //Constrained parameters
2495
 
    }
2496
 
    else if(! strcasecmp(conf_mux, "dvd"))
2497
 
    {
2498
 
        priv->mux = MUX_MPEG2;
2499
 
        priv->is_dvd = 1;
2500
 
        priv->packet_size = 2048;
2501
 
        priv->muxrate = 10080 * 125;
2502
 
    }
2503
 
    else if(! strcasecmp(conf_mux, "xsvcd"))
2504
 
    {
2505
 
        priv->mux = MUX_MPEG2;
2506
 
        priv->is_xsvcd = 1;
2507
 
        priv->packet_size = 2324;
2508
 
        priv->muxrate = 150*2324;
2509
 
        priv->ts_allframes = 1;
2510
 
    }
2511
 
    else if(! strcasecmp(conf_mux, "xvcd"))
2512
 
    {
2513
 
        priv->mux = MUX_MPEG1;
2514
 
        priv->is_xvcd = 1;
2515
 
        priv->packet_size = 2324;
2516
 
        priv->muxrate = 75*2352;
2517
 
        priv->ts_allframes = 1;
2518
 
    }
2519
 
    else if(! strcasecmp(conf_mux, "pes1"))
2520
 
    {
2521
 
        priv->mux = MUX_MPEG1;
2522
 
        priv->rawpes = 1;
2523
 
        priv->packet_size = 2048;
2524
 
        priv->muxrate = 10080 * 125;
2525
 
        priv->ts_allframes = 1;
2526
 
    }
2527
 
    else if(! strcasecmp(conf_mux, "pes2"))
2528
 
    {
2529
 
        priv->mux = MUX_MPEG2;
2530
 
        priv->rawpes = 1;
2531
 
        priv->packet_size = 2048;
2532
 
        priv->muxrate = 10080 * 125;
2533
 
        priv->ts_allframes = 1;
2534
 
    }
2535
 
    else
2536
 
    {
2537
 
        if(strcasecmp(conf_mux, "mpeg2"))
2538
 
                mp_msg(MSGT_MUXER, MSGL_ERR, "Unknown format %s, default to mpeg2\n", conf_mux);
2539
 
        priv->mux = MUX_MPEG2;
2540
 
        priv->is_genmpeg2 = 1;
2541
 
        priv->packet_size = 2048;
2542
 
        priv->muxrate = 1800 * 125;     //Constrained parameters
2543
 
    }
2544
 
  }
2545
 
 
2546
 
  if(conf_ts_allframes)
2547
 
        priv->ts_allframes = 1;
2548
 
  if(conf_muxrate > 0)
2549
 
        priv->muxrate = conf_muxrate * 125;             // * 1000 / 8
2550
 
  if(conf_packet_size)
2551
 
        priv->packet_size = conf_packet_size;
2552
 
  priv->delta_scr = (uint64_t) (90000.0f*300.0f*(double)priv->packet_size/(double)priv->muxrate);
2553
 
  mp_msg(MSGT_MUXER, MSGL_INFO, "PACKET SIZE: %u bytes, deltascr: %"PRIu64"\n", priv->packet_size, priv->delta_scr);
2554
 
  setup_sys_params(priv);
2555
 
 
2556
 
  if(conf_vaspect > 0)
2557
 
  {
2558
 
        int asp = (int) (conf_vaspect * 1000.0f);
2559
 
        if(asp >= 1332 && asp <= 1334)
2560
 
                priv->vaspect = ASPECT_4_3;
2561
 
        else if(asp >= 1776 && asp <= 1778)
2562
 
                priv->vaspect = ASPECT_16_9;
2563
 
        else if(asp >= 2209 && asp <= 2211)
2564
 
                priv->vaspect = ASPECT_2_21_1;
2565
 
        else if(asp == 1000)
2566
 
                priv->vaspect = ASPECT_1_1;
2567
 
        else
2568
 
                mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR: unrecognized aspect %.3f\n", conf_vaspect);
2569
 
  }
2570
 
 
2571
 
  priv->vframerate = 0;         // no change
2572
 
  if(conf_telecine && conf_vframerate > 0)
2573
 
  {
2574
 
        mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR: options 'telecine' and 'vframerate' are mutually exclusive, vframerate disabled\n");
2575
 
        conf_vframerate = 0;
2576
 
  }
2577
 
 
2578
 
  if(conf_telecine == TELECINE_FILM2PAL)
2579
 
  {
2580
 
        if(conf_telecine_src==0.0f) conf_telecine_src = 24000.0/1001.0;
2581
 
        conf_telecine_dest = 25;
2582
 
        conf_telecine = TELECINE_DGPULLDOWN;
2583
 
  }
2584
 
  else if(conf_telecine == PULLDOWN32)
2585
 
  {
2586
 
        if(conf_telecine_src==0.0f) conf_telecine_src = 24000.0/1001.0;
2587
 
        conf_telecine_dest = 30000.0/1001.0;
2588
 
        conf_telecine = TELECINE_DGPULLDOWN;
2589
 
  }
2590
 
 
2591
 
  if(conf_telecine_src>0 && conf_telecine_dest>0 && conf_telecine_src < conf_telecine_dest)
2592
 
  {
2593
 
        int sfps, tfps;
2594
 
        
2595
 
        sfps = (int) (conf_telecine_src * 1001 + 0.5);
2596
 
        tfps = (int) (conf_telecine_dest * 1001 + 0.5);
2597
 
        if(sfps % 2 || tfps % 2)
2598
 
        {
2599
 
                sfps *= 2;
2600
 
                tfps *= 2;
2601
 
        }
2602
 
        
2603
 
        if(((tfps - sfps)>>1) > sfps)
2604
 
        {
2605
 
                mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR! Framerate increment must be <= 1.5, telecining disabled\n");
2606
 
                conf_telecine = 0;
2607
 
        }
2608
 
        else
2609
 
        {
2610
 
        generate_flags(sfps, tfps);
2611
 
        conf_telecine = TELECINE_DGPULLDOWN;
2612
 
        conf_vframerate = conf_telecine_dest;
2613
 
        }
2614
 
  }
2615
 
 
2616
 
  if(conf_vframerate)
2617
 
  {
2618
 
        int fps;
2619
 
        
2620
 
        fps = (int) (conf_vframerate * 1001 + 0.5);
2621
 
        switch(fps)
2622
 
        {
2623
 
                case 24000:
2624
 
                        priv->vframerate = FRAMERATE_23976;
2625
 
                        break;
2626
 
                case 24024:
2627
 
                        priv->vframerate = FRAMERATE_24;
2628
 
                        break;
2629
 
                case 25025:
2630
 
                        priv->vframerate = FRAMERATE_25;
2631
 
                        break;
2632
 
                case 30000:
2633
 
                        priv->vframerate = FRAMERATE_2997;
2634
 
                        break;
2635
 
                case 30030:
2636
 
                        priv->vframerate = FRAMERATE_30;
2637
 
                        break;
2638
 
                case 50050:
2639
 
                        priv->vframerate = FRAMERATE_50;
2640
 
                        break;
2641
 
                case 60000:
2642
 
                        priv->vframerate = FRAMERATE_5994;
2643
 
                        break;
2644
 
                case 60060:
2645
 
                        priv->vframerate = FRAMERATE_60;
2646
 
                        break;
2647
 
                default:
2648
 
                {
2649
 
                        mp_msg(MSGT_MUXER, MSGL_ERR, "WRONG FPS: %d/1000, ignoring\n", fps);
2650
 
                        if(conf_telecine)
2651
 
                                mp_msg(MSGT_MUXER, MSGL_ERR, "DISABLED TELECINING\n");
 
2483
int muxer_init_muxer_mpeg(muxer_t *muxer)
 
2484
{
 
2485
        muxer_priv_t *priv;
 
2486
        priv = (muxer_priv_t *) calloc(1, sizeof(muxer_priv_t));
 
2487
        if(priv == NULL)
 
2488
        return 0;
 
2489
        priv->update_system_header = 1;
 
2490
        
 
2491
        //calloc() already zero-ed all flags, so we assign only the ones we need
 
2492
        
 
2493
        if(conf_mux != NULL)
 
2494
        {
 
2495
                if(! strcasecmp(conf_mux, "mpeg1"))
 
2496
                {
 
2497
                        priv->mux = MUX_MPEG1;
 
2498
                        priv->packet_size = 2048;
 
2499
                        priv->is_genmpeg1 = 1;
 
2500
                        priv->muxrate = 1800 * 125;     //Constrained parameters
 
2501
                }
 
2502
                else if(! strcasecmp(conf_mux, "dvd"))
 
2503
                {
 
2504
                        priv->mux = MUX_MPEG2;
 
2505
                        priv->is_dvd = 1;
 
2506
                        priv->packet_size = 2048;
 
2507
                        priv->muxrate = 10080 * 125;
 
2508
                }
 
2509
                else if(! strcasecmp(conf_mux, "xsvcd"))
 
2510
                {
 
2511
                        priv->mux = MUX_MPEG2;
 
2512
                        priv->is_xsvcd = 1;
 
2513
                        priv->packet_size = 2324;
 
2514
                        priv->muxrate = 150*2324;
 
2515
                        priv->ts_allframes = 1;
 
2516
                }
 
2517
                else if(! strcasecmp(conf_mux, "xvcd"))
 
2518
                {
 
2519
                        priv->mux = MUX_MPEG1;
 
2520
                        priv->is_xvcd = 1;
 
2521
                        priv->packet_size = 2324;
 
2522
                        priv->muxrate = 75*2352;
 
2523
                        priv->ts_allframes = 1;
 
2524
                }
 
2525
                else if(! strcasecmp(conf_mux, "pes1"))
 
2526
                {
 
2527
                        priv->mux = MUX_MPEG1;
 
2528
                        priv->rawpes = 1;
 
2529
                        priv->packet_size = 2048;
 
2530
                        priv->muxrate = 10080 * 125;
 
2531
                        priv->ts_allframes = 1;
 
2532
                }
 
2533
                else if(! strcasecmp(conf_mux, "pes2"))
 
2534
                {
 
2535
                        priv->mux = MUX_MPEG2;
 
2536
                        priv->rawpes = 1;
 
2537
                        priv->packet_size = 2048;
 
2538
                        priv->muxrate = 10080 * 125;
 
2539
                        priv->ts_allframes = 1;
 
2540
                }
 
2541
                else
 
2542
                {
 
2543
                        if(strcasecmp(conf_mux, "mpeg2"))
 
2544
                                mp_msg(MSGT_MUXER, MSGL_ERR, "Unknown format %s, default to mpeg2\n", conf_mux);
 
2545
                        priv->mux = MUX_MPEG2;
 
2546
                        priv->is_genmpeg2 = 1;
 
2547
                        priv->packet_size = 2048;
 
2548
                        priv->muxrate = 1800 * 125;     //Constrained parameters
 
2549
                }
 
2550
        }
 
2551
        
 
2552
        if(conf_ts_allframes)
 
2553
                priv->ts_allframes = 1;
 
2554
        if(conf_muxrate > 0)
 
2555
                priv->muxrate = conf_muxrate * 125;             // * 1000 / 8
 
2556
        if(conf_packet_size)
 
2557
                priv->packet_size = conf_packet_size;
 
2558
        priv->delta_scr = (uint64_t) (90000.0f*300.0f*(double)priv->packet_size/(double)priv->muxrate);
 
2559
        mp_msg(MSGT_MUXER, MSGL_INFO, "PACKET SIZE: %u bytes, deltascr: %"PRIu64"\n", priv->packet_size, priv->delta_scr);
 
2560
        setup_sys_params(priv);
 
2561
        
 
2562
        if(conf_vaspect > 0)
 
2563
        {
 
2564
                int asp = (int) (conf_vaspect * 1000.0f);
 
2565
                if(asp >= 1332 && asp <= 1334)
 
2566
                        priv->vaspect = ASPECT_4_3;
 
2567
                else if(asp >= 1776 && asp <= 1778)
 
2568
                        priv->vaspect = ASPECT_16_9;
 
2569
                else if(asp >= 2209 && asp <= 2211)
 
2570
                        priv->vaspect = ASPECT_2_21_1;
 
2571
                else if(asp == 1000)
 
2572
                        priv->vaspect = ASPECT_1_1;
 
2573
                else
 
2574
                        mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR: unrecognized aspect %.3f\n", conf_vaspect);
 
2575
        }
 
2576
        
 
2577
        priv->vframerate = 0;           // no change
 
2578
        if(conf_telecine && conf_vframerate > 0)
 
2579
        {
 
2580
                mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR: options 'telecine' and 'vframerate' are mutually exclusive, vframerate disabled\n");
 
2581
                conf_vframerate = 0;
 
2582
        }
 
2583
        
 
2584
        if(conf_telecine == TELECINE_FILM2PAL)
 
2585
        {
 
2586
                if(conf_telecine_src==0.0f) conf_telecine_src = 24000.0/1001.0;
 
2587
                conf_telecine_dest = 25;
 
2588
                conf_telecine = TELECINE_DGPULLDOWN;
 
2589
        }
 
2590
        else if(conf_telecine == PULLDOWN32)
 
2591
        {
 
2592
                if(conf_telecine_src==0.0f) conf_telecine_src = 24000.0/1001.0;
 
2593
                conf_telecine_dest = 30000.0/1001.0;
 
2594
                conf_telecine = TELECINE_DGPULLDOWN;
 
2595
        }
 
2596
        
 
2597
        if(conf_telecine_src>0 && conf_telecine_dest>0 && conf_telecine_src < conf_telecine_dest)
 
2598
        {
 
2599
                int sfps, tfps;
 
2600
                
 
2601
                sfps = (int) (conf_telecine_src * 1001 + 0.5);
 
2602
                tfps = (int) (conf_telecine_dest * 1001 + 0.5);
 
2603
                if(sfps % 2 || tfps % 2)
 
2604
                {
 
2605
                        sfps *= 2;
 
2606
                        tfps *= 2;
 
2607
                }
 
2608
                
 
2609
                if(((tfps - sfps)>>1) > sfps)
 
2610
                {
 
2611
                        mp_msg(MSGT_MUXER, MSGL_ERR, "ERROR! Framerate increment must be <= 1.5, telecining disabled\n");
2652
2612
                        conf_telecine = 0;
2653
2613
                }
2654
 
        }
2655
 
  }
2656
 
 
2657
 
  priv->vwidth = (uint16_t) conf_vwidth;
2658
 
  priv->vheight = (uint16_t) conf_vheight;
2659
 
  priv->panscan_width = (uint16_t) conf_panscan_width;
2660
 
  priv->panscan_height = (uint16_t) conf_panscan_height;
2661
 
  priv->vbitrate = ((conf_vbitrate) * 10) >> 2; //*1000 / 400
2662
 
 
2663
 
  if(priv->vaspect || priv->vframerate || priv->vwidth || priv->vheight || priv->vbitrate || priv->panscan_width || priv->panscan_height)
2664
 
  {
2665
 
        priv->patch_seq = priv->vaspect || priv->vframerate || priv->vwidth || priv->vheight || priv->vbitrate;
2666
 
        priv->patch_sde = priv->panscan_width || priv->panscan_height;
2667
 
        mp_msg(MSGT_MUXER, MSGL_INFO, "MPEG MUXER, patching");
2668
 
        if(priv->vwidth || priv->vheight)
2669
 
                mp_msg(MSGT_MUXER, MSGL_INFO, " resolution to %dx%d", priv->vwidth, priv->vheight);
2670
 
        if(priv->panscan_width || priv->panscan_height)
2671
 
                mp_msg(MSGT_MUXER, MSGL_INFO, " panscan to to %dx%d", priv->panscan_width, priv->panscan_height);
2672
 
        if(priv->vframerate)
2673
 
                mp_msg(MSGT_MUXER, MSGL_INFO, " framerate to %s fps", framerates[priv->vframerate]);
2674
 
        if(priv->vaspect)
2675
 
                mp_msg(MSGT_MUXER, MSGL_INFO, " aspect ratio to %s", aspect_ratios[priv->vaspect]);
2676
 
        if(priv->vbitrate)
2677
 
                mp_msg(MSGT_MUXER, MSGL_INFO, " bitrate to %u", conf_vbitrate);
2678
 
        mp_msg(MSGT_MUXER, MSGL_INFO, "\n");
2679
 
  }
2680
 
 
2681
 
  priv->has_video = priv->has_audio = 0;
2682
 
 
2683
 
  muxer->sysrate = priv->muxrate;               // initial muxrate = constrained stream parameter
2684
 
  priv->scr = muxer->file_end = 0;
2685
 
 
2686
 
  if(conf_init_vdelay && conf_drop)
2687
 
  {
2688
 
        mp_msg(MSGT_MUXER, MSGL_ERR, "\nmuxer_mpg, :drop and :vdelay used together are not supported, exiting\n");
2689
 
        return 0;
2690
 
  }
2691
 
  if(conf_init_adelay)
2692
 
        priv->init_adelay = - (double) conf_init_adelay / (double) 1000.0;
2693
 
 
2694
 
  priv->drop = conf_drop;
2695
 
 
2696
 
  priv->buff = (uint8_t *) malloc(priv->packet_size);
2697
 
  if((priv->buff == NULL))
2698
 
  {
2699
 
        mp_msg(MSGT_MUXER, MSGL_ERR, "\nCouldn't allocate %d bytes, exit\n", priv->packet_size);
2700
 
        return 0;
2701
 
  }
2702
 
 
2703
 
  muxer->priv = (void *) priv;
2704
 
  muxer->cont_new_stream = &mpegfile_new_stream;
2705
 
  muxer->cont_write_chunk = &mpegfile_write_chunk;
2706
 
  muxer->cont_write_header = &mpegfile_write_header;
2707
 
  muxer->cont_write_index = &mpegfile_write_index;
2708
 
  muxer->fix_stream_parameters = &fix_parameters;
2709
 
  return 1;
 
2614
                else
 
2615
                {
 
2616
                        generate_flags(priv->bff_mask, sfps, tfps);
 
2617
                        conf_telecine = TELECINE_DGPULLDOWN;
 
2618
                        conf_vframerate = conf_telecine_dest;
 
2619
                }
 
2620
        }
 
2621
        
 
2622
        if(conf_vframerate)
 
2623
        {
 
2624
                int fps;
 
2625
                
 
2626
                fps = (int) (conf_vframerate * 1001 + 0.5);
 
2627
                switch(fps)
 
2628
                {
 
2629
                        case 24000:
 
2630
                                priv->vframerate = FRAMERATE_23976;
 
2631
                                break;
 
2632
                        case 24024:
 
2633
                                priv->vframerate = FRAMERATE_24;
 
2634
                                break;
 
2635
                        case 25025:
 
2636
                                priv->vframerate = FRAMERATE_25;
 
2637
                                break;
 
2638
                        case 30000:
 
2639
                                priv->vframerate = FRAMERATE_2997;
 
2640
                                break;
 
2641
                        case 30030:
 
2642
                                priv->vframerate = FRAMERATE_30;
 
2643
                                break;
 
2644
                        case 50050:
 
2645
                                priv->vframerate = FRAMERATE_50;
 
2646
                                break;
 
2647
                        case 60000:
 
2648
                                priv->vframerate = FRAMERATE_5994;
 
2649
                                break;
 
2650
                        case 60060:
 
2651
                                priv->vframerate = FRAMERATE_60;
 
2652
                                break;
 
2653
                        default:
 
2654
                        {
 
2655
                                mp_msg(MSGT_MUXER, MSGL_ERR, "WRONG FPS: %d/1000, ignoring\n", fps);
 
2656
                                if(conf_telecine)
 
2657
                                        mp_msg(MSGT_MUXER, MSGL_ERR, "DISABLED TELECINING\n");
 
2658
                                conf_telecine = 0;
 
2659
                        }
 
2660
                }
 
2661
        }
 
2662
        
 
2663
        priv->vwidth = (uint16_t) conf_vwidth;
 
2664
        priv->vheight = (uint16_t) conf_vheight;
 
2665
        priv->panscan_width = (uint16_t) conf_panscan_width;
 
2666
        priv->panscan_height = (uint16_t) conf_panscan_height;
 
2667
        priv->vbitrate = ((conf_vbitrate) * 10) >> 2;   //*1000 / 400
 
2668
        
 
2669
        if(priv->vaspect || priv->vframerate || priv->vwidth || priv->vheight || priv->vbitrate || priv->panscan_width || priv->panscan_height)
 
2670
        {
 
2671
                priv->patch_seq = priv->vaspect || priv->vframerate || priv->vwidth || priv->vheight || priv->vbitrate;
 
2672
                priv->patch_sde = priv->panscan_width || priv->panscan_height;
 
2673
                mp_msg(MSGT_MUXER, MSGL_INFO, "MPEG MUXER, patching");
 
2674
                if(priv->vwidth || priv->vheight)
 
2675
                        mp_msg(MSGT_MUXER, MSGL_INFO, " resolution to %dx%d", priv->vwidth, priv->vheight);
 
2676
                if(priv->panscan_width || priv->panscan_height)
 
2677
                        mp_msg(MSGT_MUXER, MSGL_INFO, " panscan to to %dx%d", priv->panscan_width, priv->panscan_height);
 
2678
                if(priv->vframerate)
 
2679
                        mp_msg(MSGT_MUXER, MSGL_INFO, " framerate to %s fps", framerates[priv->vframerate]);
 
2680
                if(priv->vaspect)
 
2681
                        mp_msg(MSGT_MUXER, MSGL_INFO, " aspect ratio to %s", aspect_ratios[priv->vaspect]);
 
2682
                if(priv->vbitrate)
 
2683
                        mp_msg(MSGT_MUXER, MSGL_INFO, " bitrate to %u", conf_vbitrate);
 
2684
                mp_msg(MSGT_MUXER, MSGL_INFO, "\n");
 
2685
        }
 
2686
        
 
2687
        priv->has_video = priv->has_audio = 0;
 
2688
        
 
2689
        muxer->sysrate = priv->muxrate;                 // initial muxrate = constrained stream parameter
 
2690
        priv->scr = muxer->file_end = 0;
 
2691
        
 
2692
        if(conf_init_vdelay && conf_drop)
 
2693
        {
 
2694
                mp_msg(MSGT_MUXER, MSGL_ERR, "\nmuxer_mpg, :drop and :vdelay used together are not supported, exiting\n");
 
2695
                return 0;
 
2696
        }
 
2697
        if(conf_init_adelay)
 
2698
                priv->init_adelay = - (double) conf_init_adelay / (double) 1000.0;
 
2699
        
 
2700
        priv->drop = conf_drop;
 
2701
        
 
2702
        priv->buff = (uint8_t *) malloc(priv->packet_size);
 
2703
        if((priv->buff == NULL))
 
2704
        {
 
2705
                mp_msg(MSGT_MUXER, MSGL_ERR, "\nCouldn't allocate %d bytes, exit\n", priv->packet_size);
 
2706
                return 0;
 
2707
        }
 
2708
        
 
2709
        muxer->priv = (void *) priv;
 
2710
        muxer->cont_new_stream = &mpegfile_new_stream;
 
2711
        muxer->cont_write_chunk = &mpegfile_write_chunk;
 
2712
        muxer->cont_write_header = &mpegfile_write_header;
 
2713
        muxer->cont_write_index = &mpegfile_write_index;
 
2714
        muxer->fix_stream_parameters = &fix_parameters;
 
2715
        return 1;
2710
2716
}
2711
2717