Statistics
| Branch: | Revision:

ffmpeg / libavformat / avienc.c @ deabd4fd

History | View | Annotate | Download (18.1 KB)

1
/*
2
 * AVI encoder.
3
 * Copyright (c) 2000 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
#include "avformat.h"
20
#include "avi.h"
21

    
22
/*
23
 * TODO: 
24
 *  - fill all fields if non streamed (nb_frames for example)
25
 */
26

    
27
typedef struct AVIIndex {
28
    unsigned char tag[4];
29
    unsigned int flags, pos, len;
30
    struct AVIIndex *next;
31
} AVIIndex;
32

    
33
typedef struct {
34
    offset_t riff_start, movi_list, odml_list;
35
    offset_t frames_hdr_all, frames_hdr_strm[MAX_STREAMS];
36
    int audio_strm_length[MAX_STREAMS];
37
    AVIIndex *first, *last;
38
} AVIContext;
39

    
40
offset_t start_tag(ByteIOContext *pb, const char *tag)
41
{
42
    put_tag(pb, tag);
43
    put_le32(pb, 0);
44
    return url_ftell(pb);
45
}
46

    
47
void end_tag(ByteIOContext *pb, offset_t start)
48
{
49
    offset_t pos;
50

    
51
    pos = url_ftell(pb);
52
    url_fseek(pb, start - 4, SEEK_SET);
53
    put_le32(pb, (uint32_t)(pos - start));
54
    url_fseek(pb, pos, SEEK_SET);
55
}
56

    
57
/* Note: when encoding, the first matching tag is used, so order is
58
   important if multiple tags possible for a given codec. */
59
const CodecTag codec_bmp_tags[] = {
60
    { CODEC_ID_H263, MKTAG('H', '2', '6', '3') },
61
    { CODEC_ID_H263P, MKTAG('H', '2', '6', '3') },
62
    { CODEC_ID_H263I, MKTAG('I', '2', '6', '3') }, /* intel h263 */
63

    
64
    /* added based on MPlayer */
65
    { CODEC_ID_H263I, MKTAG('i', '2', '6', '3') },
66
    { CODEC_ID_H263P, MKTAG('U', '2', '6', '3') },
67
    { CODEC_ID_H263P, MKTAG('h', '2', '6', '3') },
68
    { CODEC_ID_H263P, MKTAG('v', 'i', 'v', '1') },
69

    
70
    { CODEC_ID_MJPEG, MKTAG('M', 'J', 'P', 'G') },
71
    { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', 'X'), .invalid_asf = 1 },
72
    { CODEC_ID_MPEG4, MKTAG('d', 'i', 'v', 'x'), .invalid_asf = 1 },
73
    { CODEC_ID_MPEG4, MKTAG('D', 'X', '5', '0'), .invalid_asf = 1 },
74
    { CODEC_ID_MPEG4, MKTAG('X', 'V', 'I', 'D'), .invalid_asf = 1 },
75
    { CODEC_ID_MPEG4, MKTAG('x', 'v', 'i', 'd'), .invalid_asf = 1 },
76
    { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 's'), .invalid_asf = 1 },
77
    { CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
78
    { CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
79
    { CODEC_ID_MPEG4, MKTAG('m', '4', 's', '2') },
80
    { CODEC_ID_MPEG4, MKTAG(0x04, 0, 0, 0) }, /* some broken avi use this */
81

    
82
    /* added based on MPlayer */
83
    { CODEC_ID_MPEG4, MKTAG('D', 'I', 'V', '1') },
84
    { CODEC_ID_MPEG4, MKTAG('d', 'i', 'v', '1') },
85
    { CODEC_ID_MPEG4, MKTAG('X', 'v', 'i', 'D') },
86
    { CODEC_ID_MPEG4, MKTAG('B', 'L', 'Z', '0') },
87
    { CODEC_ID_MPEG4, MKTAG('m', 'p', '4', 'v') },
88
    { CODEC_ID_MPEG4, MKTAG('U', 'M', 'P', '4') },
89

    
90
    { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '3'), .invalid_asf = 1 }, /* default signature when using MSMPEG4 */
91
    { CODEC_ID_MSMPEG4V3, MKTAG('d', 'i', 'v', '3'), .invalid_asf = 1 },
92
    { CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') }, 
93

    
94
    /* added based on MPlayer */
95
    { CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', 'G', '3') }, 
96
    { CODEC_ID_MSMPEG4V3, MKTAG('m', 'p', 'g', '3') }, 
97
    { CODEC_ID_MSMPEG4V3, MKTAG('m', 'p', '4', '3') }, 
98
    { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '5') }, 
99
    { CODEC_ID_MSMPEG4V3, MKTAG('d', 'i', 'v', '5') }, 
100
    { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '6') }, 
101
    { CODEC_ID_MSMPEG4V3, MKTAG('d', 'i', 'v', '6') }, 
102
    { CODEC_ID_MSMPEG4V3, MKTAG('D', 'I', 'V', '4') }, 
103
    { CODEC_ID_MSMPEG4V3, MKTAG('d', 'i', 'v', '4') }, 
104
    { CODEC_ID_MSMPEG4V3, MKTAG('A', 'P', '4', '1') }, 
105
    { CODEC_ID_MSMPEG4V3, MKTAG('C', 'O', 'L', '1') }, 
106
    { CODEC_ID_MSMPEG4V3, MKTAG('c', 'o', 'l', '1') }, 
107
    { CODEC_ID_MSMPEG4V3, MKTAG('C', 'O', 'L', '0') }, 
108
    { CODEC_ID_MSMPEG4V3, MKTAG('c', 'o', 'l', '0') }, 
109

    
110
    { CODEC_ID_MSMPEG4V2, MKTAG('M', 'P', '4', '2') }, 
111

    
112
    /* added based on MPlayer */
113
    { CODEC_ID_MSMPEG4V2, MKTAG('D', 'I', 'V', '2') },
114
    { CODEC_ID_MSMPEG4V2, MKTAG('d', 'i', 'v', '2') },
115
    { CODEC_ID_MSMPEG4V2, MKTAG('m', 'p', '4', '2') },
116
 
117
    { CODEC_ID_MSMPEG4V1, MKTAG('M', 'P', 'G', '4') }, 
118

    
119
    /* added based on MPlayer */
120
    { CODEC_ID_MSMPEG4V1, MKTAG('D', 'I', 'V', '4') }, 
121
    { CODEC_ID_MSMPEG4V1, MKTAG('d', 'i', 'v', '4') }, 
122
    { CODEC_ID_MSMPEG4V1, MKTAG('m', 'p', 'g', '4') }, 
123

    
124
    { CODEC_ID_WMV1, MKTAG('W', 'M', 'V', '1') }, 
125

    
126
    /* added based on MPlayer */
127
    { CODEC_ID_WMV1, MKTAG('w', 'm', 'v', '1') }, 
128

    
129
    { CODEC_ID_WMV2, MKTAG('W', 'M', 'V', '2') }, 
130
    { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 's', 'd') }, 
131
    { CODEC_ID_DVVIDEO, MKTAG('D', 'V', 'S', 'D') }, 
132
    { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 'h', 'd') }, 
133
    { CODEC_ID_DVVIDEO, MKTAG('d', 'v', 's', 'l') }, 
134
    { CODEC_ID_DVVIDEO, MKTAG('d', 'v', '2', '5') },
135
    { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'g', '1') }, 
136
    { CODEC_ID_MPEG1VIDEO, MKTAG('m', 'p', 'g', '2') }, 
137
    { CODEC_ID_MPEG1VIDEO, MKTAG('P', 'I', 'M', '1') }, 
138
    { CODEC_ID_MJPEG, MKTAG('M', 'J', 'P', 'G') },
139
    { CODEC_ID_HUFFYUV, MKTAG('H', 'F', 'Y', 'U') },
140
    { CODEC_ID_HUFFYUV, MKTAG('h', 'f', 'y', 'u') },
141
    { CODEC_ID_CYUV, MKTAG('C', 'Y', 'U', 'V') },
142
    { CODEC_ID_CYUV, MKTAG('c', 'y', 'u', 'v') },
143
    { CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '2', '2') },
144
    { CODEC_ID_RAWVIDEO, MKTAG('I', '4', '2', '0') },
145
    { CODEC_ID_INDEO3, MKTAG('i', 'v', '3', '1') },
146
    { CODEC_ID_INDEO3, MKTAG('i', 'v', '3', '2') },
147
    { CODEC_ID_INDEO3, MKTAG('I', 'V', '3', '1') },
148
    { CODEC_ID_INDEO3, MKTAG('I', 'V', '3', '2') },
149
    { 0, 0 },
150
};
151

    
152
unsigned int codec_get_tag(const CodecTag *tags, int id)
153
{
154
    while (tags->id != 0) {
155
        if (tags->id == id)
156
            return tags->tag;
157
        tags++;
158
    }
159
    return 0;
160
}
161

    
162
static unsigned int codec_get_asf_tag(const CodecTag *tags, int id)
163
{
164
    while (tags->id != 0) {
165
        if (!tags->invalid_asf && tags->id == id)
166
            return tags->tag;
167
        tags++;
168
    }
169
    return 0;
170
}
171

    
172
int codec_get_id(const CodecTag *tags, unsigned int tag)
173
{
174
    while (tags->id != 0) {
175
        if (tags->tag == tag)
176
            return tags->id;
177
        tags++;
178
    }
179
    return 0;
180
}
181

    
182
unsigned int codec_get_bmp_tag(int id)
183
{
184
    return codec_get_tag(codec_bmp_tags, id);
185
}
186

    
187
/* BITMAPINFOHEADER header */
188
void put_bmp_header(ByteIOContext *pb, AVCodecContext *enc, const CodecTag *tags, int for_asf)
189
{
190
    put_le32(pb, 40 + enc->extradata_size); /* size */
191
    put_le32(pb, enc->width);
192
    put_le32(pb, enc->height);
193
    put_le16(pb, 1); /* planes */
194
    
195
    put_le16(pb, enc->bits_per_sample ? enc->bits_per_sample : 24); /* depth */
196
    /* compression type */
197
    put_le32(pb, for_asf ? codec_get_asf_tag(tags, enc->codec_id) : codec_get_tag(tags, enc->codec_id));
198
    put_le32(pb, enc->width * enc->height * 3);
199
    put_le32(pb, 0);
200
    put_le32(pb, 0);
201
    put_le32(pb, 0);
202
    put_le32(pb, 0);
203
    
204
    put_buffer(pb, enc->extradata, enc->extradata_size);
205

    
206
    if (enc->extradata_size & 1)
207
        put_byte(pb, 0);
208
}
209

    
210
static void parse_specific_params(AVCodecContext *stream, int *au_byterate, int *au_ssize, int *au_scale)
211
{
212
    switch(stream->codec_id) {
213
    case CODEC_ID_PCM_S16LE:
214
       *au_scale = *au_ssize = 2*stream->channels;
215
       *au_byterate = *au_ssize * stream->sample_rate;
216
        break;
217
    case CODEC_ID_PCM_U8:
218
    case CODEC_ID_PCM_ALAW:
219
    case CODEC_ID_PCM_MULAW:
220
        *au_scale = *au_ssize = stream->channels;
221
        *au_byterate = *au_ssize * stream->sample_rate;
222
        break;
223
    case CODEC_ID_MP2:
224
        *au_ssize = 1;
225
        *au_scale = 1;
226
        *au_byterate = stream->bit_rate / 8;
227
    case CODEC_ID_MP3LAME:
228
        *au_ssize = 1;
229
        *au_scale = 1;
230
        *au_byterate = stream->bit_rate / 8;    
231
    default:
232
        *au_ssize = 1;
233
        *au_scale = 1; 
234
        *au_byterate = stream->bit_rate / 8;
235
        break;
236
    }
237
}
238

    
239
static offset_t avi_start_new_riff(AVIContext *avi, ByteIOContext *pb, 
240
                                   const char* riff_tag, const char* list_tag)
241
{
242
    offset_t loff;
243
    avi->riff_start = start_tag(pb, "RIFF");
244
    put_tag(pb, riff_tag);
245
    loff = start_tag(pb, "LIST");
246
    put_tag(pb, list_tag);
247
    return loff;
248
}
249

    
250
static int avi_write_header(AVFormatContext *s)
251
{
252
    AVIContext *avi = s->priv_data;
253
    ByteIOContext *pb = &s->pb;
254
    int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;
255
    AVCodecContext *stream, *video_enc;
256
    offset_t list1, list2, strh, strf;
257

    
258
    /* header list */
259
    list1 = avi_start_new_riff(avi, pb, "AVI ", "hdrl");
260

    
261
    /* avi header */
262
    put_tag(pb, "avih");
263
    put_le32(pb, 14 * 4);
264
    bitrate = 0;
265

    
266
    video_enc = NULL;
267
    for(n=0;n<s->nb_streams;n++) {
268
        stream = &s->streams[n]->codec;
269
        bitrate += stream->bit_rate;
270
        if (stream->codec_type == CODEC_TYPE_VIDEO)
271
            video_enc = stream;
272
    }
273
    
274
    nb_frames = 0;
275

    
276
    if(video_enc){
277
        put_le32(pb, (uint32_t)(int64_t_C(1000000) * video_enc->frame_rate_base / video_enc->frame_rate));
278
    } else {
279
        put_le32(pb, 0);
280
    }
281
    put_le32(pb, bitrate / 8); /* XXX: not quite exact */
282
    put_le32(pb, 0); /* padding */
283
    put_le32(pb, AVIF_TRUSTCKTYPE | AVIF_HASINDEX | AVIF_ISINTERLEAVED); /* flags */
284
    avi->frames_hdr_all = url_ftell(pb); /* remember this offset to fill later */
285
    put_le32(pb, nb_frames); /* nb frames, filled later */
286
    put_le32(pb, 0); /* initial frame */
287
    put_le32(pb, s->nb_streams); /* nb streams */
288
    put_le32(pb, 1024 * 1024); /* suggested buffer size */
289
    if(video_enc){    
290
    put_le32(pb, video_enc->width);
291
    put_le32(pb, video_enc->height);
292
    } else {
293
        put_le32(pb, 0);
294
        put_le32(pb, 0);
295
    }        
296
    put_le32(pb, 0); /* reserved */
297
    put_le32(pb, 0); /* reserved */
298
    put_le32(pb, 0); /* reserved */
299
    put_le32(pb, 0); /* reserved */
300
    
301
    /* stream list */
302
    for(i=0;i<n;i++) {
303
        list2 = start_tag(pb, "LIST");
304
        put_tag(pb, "strl");
305
    
306
        stream = &s->streams[i]->codec;
307

    
308
        /* FourCC should really be set by the codec itself */
309
        if (! stream->codec_tag) {
310
            stream->codec_tag = codec_get_bmp_tag(stream->codec_id);
311
        }
312

    
313
        /* stream generic header */
314
        strh = start_tag(pb, "strh");
315
        switch(stream->codec_type) {
316
        case CODEC_TYPE_VIDEO:
317
            put_tag(pb, "vids");
318
            put_le32(pb, stream->codec_tag);
319
            put_le32(pb, 0); /* flags */
320
            put_le16(pb, 0); /* priority */
321
            put_le16(pb, 0); /* language */
322
            put_le32(pb, 0); /* initial frame */
323
            
324
            put_le32(pb, stream->frame_rate_base); /* scale */
325
            put_le32(pb, stream->frame_rate); /* rate */
326

    
327
            put_le32(pb, 0); /* start */
328
            avi->frames_hdr_strm[i] = url_ftell(pb); /* remember this offset to fill later */
329
            put_le32(pb, nb_frames); /* length, XXX: fill later */
330
            put_le32(pb, 1024 * 1024); /* suggested buffer size */
331
            put_le32(pb, -1); /* quality */
332
            put_le32(pb, stream->width * stream->height * 3); /* sample size */
333
            put_le16(pb, 0);
334
            put_le16(pb, 0);
335
            put_le16(pb, stream->width);
336
            put_le16(pb, stream->height);
337
            break;
338
        case CODEC_TYPE_AUDIO:
339
            put_tag(pb, "auds");
340
            put_le32(pb, 1); /* tag */
341
            put_le32(pb, 0); /* flags */
342
            put_le16(pb, 0); /* priority */
343
            put_le16(pb, 0); /* language */
344
            put_le32(pb, 0); /* initial frame */
345
            parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
346
            put_le32(pb, au_scale); /* scale */
347
            put_le32(pb, au_byterate); /* rate */
348
            put_le32(pb, 0); /* start */
349
            avi->frames_hdr_strm[i] = url_ftell(pb); /* remember this offset to fill later */
350
            put_le32(pb, 0); /* length, XXX: filled later */
351
            put_le32(pb, 12 * 1024); /* suggested buffer size */
352
            put_le32(pb, -1); /* quality */
353
            put_le32(pb, au_ssize); /* sample size */
354
            put_le32(pb, 0);
355
            put_le32(pb, 0);
356
            break;
357
        default:
358
            av_abort();
359
        }
360
        end_tag(pb, strh);
361

    
362
        strf = start_tag(pb, "strf");
363
        switch(stream->codec_type) {
364
        case CODEC_TYPE_VIDEO:
365
            put_bmp_header(pb, stream, codec_bmp_tags, 0);
366
            break;
367
        case CODEC_TYPE_AUDIO:
368
            if (put_wav_header(pb, stream) < 0) {
369
                av_free(avi);
370
                return -1;
371
            }
372
            break;
373
        default:
374
            av_abort();
375
        }
376
        end_tag(pb, strf);
377
        end_tag(pb, list2);
378
    }
379
    
380
    /* AVI could become an OpenDML one, if it grows beyond 2Gb range */
381
    avi->odml_list = start_tag(pb, "JUNK");
382
    put_tag(pb, "odml");
383
    put_tag(pb, "dmlh");
384
    put_le32(pb, 248);
385
    for (i = 0; i < 248; i+= 4)
386
        put_le32(pb, 0);
387
    end_tag(pb, avi->odml_list);
388

    
389
    end_tag(pb, list1);
390
    
391
    avi->movi_list = start_tag(pb, "LIST");
392
    avi->first = NULL;
393
    avi->last = NULL;
394
    put_tag(pb, "movi");
395

    
396
    put_flush_packet(pb);
397

    
398
    return 0;
399
}
400

    
401
static int avi_finish_riff1(AVFormatContext *s)
402
{
403
    ByteIOContext *pb = &s->pb;
404
    AVIContext *avi = s->priv_data;
405
    offset_t file_size, idx_chunk;
406
    int n, nb_frames, au_byterate, au_ssize, au_scale;
407
    AVCodecContext *stream;
408
    AVIIndex *idx;
409

    
410
    if (!url_is_streamed(pb)) {
411
        end_tag(pb, avi->movi_list);
412

    
413
        idx_chunk = start_tag(pb, "idx1");
414
        idx = avi->first;
415
        while (idx != NULL) {
416
            put_buffer(pb, idx->tag, 4);
417
            put_le32(pb, idx->flags);
418
            put_le32(pb, idx->pos);
419
            put_le32(pb, idx->len);
420
            idx = idx->next;
421
        }
422
        end_tag(pb, idx_chunk);
423
        
424
        /* update file size */
425
        file_size = url_ftell(pb);
426
        end_tag(pb, avi->riff_start);
427

    
428
        /* Fill in frame/sample counters */
429
        nb_frames = 0;
430
        for(n=0;n<s->nb_streams;n++) {
431
            if (avi->frames_hdr_strm[n] != 0) {
432
                stream = &s->streams[n]->codec;
433
                url_fseek(pb, avi->frames_hdr_strm[n], SEEK_SET);
434
                if (stream->codec_type == CODEC_TYPE_VIDEO) {
435
                    put_le32(pb, stream->frame_number); 
436
                    if (nb_frames < stream->frame_number)
437
                        nb_frames = stream->frame_number;
438
                } else {
439
                    if (stream->codec_id == CODEC_ID_MP2 || stream->codec_id == CODEC_ID_MP3LAME) {
440
                        put_le32(pb, stream->frame_number);
441
                        nb_frames += stream->frame_number;
442
                    } else {
443
                        parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
444
                        put_le32(pb, avi->audio_strm_length[n] / au_ssize);
445
                    }
446
                }
447
            }
448
       }
449
       if (avi->frames_hdr_all != 0) {
450
           url_fseek(pb, avi->frames_hdr_all, SEEK_SET);
451
           put_le32(pb, nb_frames); 
452
       }
453
       url_fseek(pb, file_size, SEEK_SET);
454
    }
455
    return 0;
456
}
457

    
458
static int avi_write_packet(AVFormatContext *s, int stream_index,
459
                            uint8_t *buf, int size, int force_pts)
460
{
461
    AVIContext *avi = s->priv_data;
462
    ByteIOContext *pb = &s->pb;
463
    AVIIndex *idx;
464
    unsigned char tag[5];
465
    unsigned int flags;
466
    AVCodecContext *enc;
467

    
468
    if (url_ftell(pb) - avi->riff_start > AVI_MAX_RIFF_SIZE) { 
469
        if (avi->riff_start != 8) {
470
            end_tag(pb, avi->movi_list);
471
            end_tag(pb, avi->riff_start);
472
        } else
473
            avi_finish_riff1(s);
474
        
475
        avi->movi_list = avi_start_new_riff(avi, pb, "AVIX", "movi");
476
    }
477
    
478
    enc = &s->streams[stream_index]->codec;
479

    
480
    tag[0] = '0';
481
    tag[1] = '0' + stream_index;
482
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
483
        tag[2] = 'd';
484
        tag[3] = 'c';
485
        flags = enc->coded_frame->key_frame ? 0x10 : 0x00;
486
    } else {
487
        tag[2] = 'w';
488
        tag[3] = 'b';
489
        flags = 0x10;
490
    }
491
    if (enc->codec_type == CODEC_TYPE_AUDIO) 
492
       avi->audio_strm_length[stream_index] += size;
493

    
494
    if (!url_is_streamed(&s->pb)) {
495
        idx = av_malloc(sizeof(AVIIndex));
496
        memcpy(idx->tag, tag, 4);
497
        idx->flags = flags;
498
        idx->pos = url_ftell(pb) - avi->movi_list;
499
        idx->len = size;
500
        idx->next = NULL;
501
        if (!avi->last)
502
            avi->first = idx;
503
        else
504
            avi->last->next = idx;
505
        avi->last = idx;
506
    }
507
    
508
    put_buffer(pb, tag, 4);
509
    put_le32(pb, size);
510
    put_buffer(pb, buf, size);
511
    if (size & 1)
512
        put_byte(pb, 0);
513

    
514
    put_flush_packet(pb);
515
    return 0;
516
}
517

    
518
static int avi_write_trailer(AVFormatContext *s)
519
{
520
    AVIContext *avi = s->priv_data;
521
    ByteIOContext *pb = &s->pb;
522
    int res = 0;
523

    
524
    if (avi->riff_start != 8) {
525
        int n, nb_frames;
526
        offset_t file_size;
527
        
528
        file_size = url_ftell(pb);
529
        url_fseek(pb, avi->odml_list - 8, SEEK_SET);
530
        put_tag(pb, "LIST"); /* Making this AVI OpenDML one */
531
        url_fskip(pb, 16);
532

    
533
        for (n=nb_frames=0;n<s->nb_streams;n++) {
534
             AVCodecContext *stream = &s->streams[n]->codec;
535
             if (stream->codec_type == CODEC_TYPE_VIDEO) {
536
                 if (nb_frames < stream->frame_number)
537
                     nb_frames = stream->frame_number;
538
             } else {
539
                 if (stream->codec_id == CODEC_ID_MP2 || stream->codec_id == CODEC_ID_MP3LAME) {
540
                     nb_frames += stream->frame_number;
541
                }
542
            }
543
        }
544
        put_le32(pb, nb_frames);
545

    
546
        end_tag(pb, avi->movi_list);
547
        end_tag(pb, avi->riff_start);
548
        url_fseek(pb, file_size, SEEK_SET);
549
    } else
550
        res = avi_finish_riff1(s);
551

    
552
    put_flush_packet(pb);
553
    return res;
554
}
555

    
556
static AVOutputFormat avi_oformat = {
557
    "avi",
558
    "avi format",
559
    "video/x-msvideo",
560
    "avi",
561
    sizeof(AVIContext),
562
    CODEC_ID_MP2,
563
    CODEC_ID_MSMPEG4V3,
564
    avi_write_header,
565
    avi_write_packet,
566
    avi_write_trailer,
567
};
568

    
569
int avienc_init(void)
570
{
571
    av_register_output_format(&avi_oformat);
572
    return 0;
573
}