Statistics
| Branch: | Revision:

ffmpeg / libavformat / raw.c @ bd09e8a7

History | View | Annotate | Download (28.3 KB)

1
/*
2
 * RAW muxer and demuxer
3
 * Copyright (c) 2001 Fabrice Bellard.
4
 * Copyright (c) 2005 Alex Beregszaszi
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22

    
23
#include "libavutil/crc.h"
24
#include "libavcodec/ac3_parser.h"
25
#include "libavcodec/bitstream.h"
26
#include "libavcodec/bytestream.h"
27
#include "avformat.h"
28
#include "raw.h"
29

    
30
/* simple formats */
31
#ifdef CONFIG_FLAC_MUXER
32
static int flac_write_header(struct AVFormatContext *s)
33
{
34
    static const uint8_t header[8] = {
35
        0x66, 0x4C, 0x61, 0x43, 0x80, 0x00, 0x00, 0x22
36
    };
37
    uint8_t *streaminfo = s->streams[0]->codec->extradata;
38
    int len = s->streams[0]->codec->extradata_size;
39
    if(streaminfo != NULL && len > 0) {
40
        put_buffer(s->pb, header, 8);
41
        put_buffer(s->pb, streaminfo, len);
42
    }
43
    return 0;
44
}
45

    
46
static int flac_write_trailer(struct AVFormatContext *s)
47
{
48
    ByteIOContext *pb = s->pb;
49
    uint8_t *streaminfo = s->streams[0]->codec->extradata;
50
    int len = s->streams[0]->codec->extradata_size;
51
    int64_t file_size;
52

    
53
    if (streaminfo && len > 0 && !url_is_streamed(s->pb)) {
54
        file_size = url_ftell(pb);
55
        url_fseek(pb, 8, SEEK_SET);
56
        put_buffer(pb, streaminfo, len);
57
        url_fseek(pb, file_size, SEEK_SET);
58
        put_flush_packet(pb);
59
    }
60
    return 0;
61
}
62
#endif
63

    
64
#ifdef CONFIG_ROQ_MUXER
65
static int roq_write_header(struct AVFormatContext *s)
66
{
67
    static const uint8_t header[] = {
68
        0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00
69
    };
70

    
71
    put_buffer(s->pb, header, 8);
72
    put_flush_packet(s->pb);
73

    
74
    return 0;
75
}
76
#endif
77

    
78
#ifdef CONFIG_NULL_MUXER
79
static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
80
{
81
    return 0;
82
}
83
#endif
84

    
85
#ifdef CONFIG_MUXERS
86
static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)
87
{
88
    put_buffer(s->pb, pkt->data, pkt->size);
89
    put_flush_packet(s->pb);
90
    return 0;
91
}
92
#endif
93

    
94
#ifdef CONFIG_DEMUXERS
95
/* raw input */
96
static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
97
{
98
    AVStream *st;
99
    int id;
100

    
101
    st = av_new_stream(s, 0);
102
    if (!st)
103
        return AVERROR(ENOMEM);
104

    
105
        id = s->iformat->value;
106
        if (id == CODEC_ID_RAWVIDEO) {
107
            st->codec->codec_type = CODEC_TYPE_VIDEO;
108
        } else {
109
            st->codec->codec_type = CODEC_TYPE_AUDIO;
110
        }
111
        st->codec->codec_id = id;
112

    
113
        switch(st->codec->codec_type) {
114
        case CODEC_TYPE_AUDIO:
115
            st->codec->sample_rate = ap->sample_rate;
116
            if(ap->channels) st->codec->channels = ap->channels;
117
            else             st->codec->channels = 1;
118
            av_set_pts_info(st, 64, 1, st->codec->sample_rate);
119
            break;
120
        case CODEC_TYPE_VIDEO:
121
            if(ap->time_base.num)
122
                av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
123
            else
124
                av_set_pts_info(st, 64, 1, 25);
125
            st->codec->width = ap->width;
126
            st->codec->height = ap->height;
127
            st->codec->pix_fmt = ap->pix_fmt;
128
            if(st->codec->pix_fmt == PIX_FMT_NONE)
129
                st->codec->pix_fmt= PIX_FMT_YUV420P;
130
            break;
131
        default:
132
            return -1;
133
        }
134
    return 0;
135
}
136

    
137
#define RAW_PACKET_SIZE 1024
138

    
139
static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
140
{
141
    int ret, size, bps;
142
    //    AVStream *st = s->streams[0];
143

    
144
    size= RAW_PACKET_SIZE;
145

    
146
    ret= av_get_packet(s->pb, pkt, size);
147

    
148
    pkt->stream_index = 0;
149
    if (ret <= 0) {
150
        return AVERROR(EIO);
151
    }
152
    /* note: we need to modify the packet size here to handle the last
153
       packet */
154
    pkt->size = ret;
155

    
156
    bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id);
157
    assert(bps); // if false there IS a bug elsewhere (NOT in this function)
158
    pkt->dts=
159
    pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels);
160

    
161
    return ret;
162
}
163

    
164
static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
165
{
166
    int ret, size;
167

    
168
    size = RAW_PACKET_SIZE;
169

    
170
    if (av_new_packet(pkt, size) < 0)
171
        return AVERROR(EIO);
172

    
173
    pkt->pos= url_ftell(s->pb);
174
    pkt->stream_index = 0;
175
    ret = get_partial_buffer(s->pb, pkt->data, size);
176
    if (ret <= 0) {
177
        av_free_packet(pkt);
178
        return AVERROR(EIO);
179
    }
180
    pkt->size = ret;
181
    return ret;
182
}
183
#endif
184

    
185
#ifdef CONFIG_RAWVIDEO_DEMUXER
186
static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
187
{
188
    int packet_size, ret, width, height;
189
    AVStream *st = s->streams[0];
190

    
191
    width = st->codec->width;
192
    height = st->codec->height;
193

    
194
    packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
195
    if (packet_size < 0)
196
        return -1;
197

    
198
    ret= av_get_packet(s->pb, pkt, packet_size);
199
    pkt->pts=
200
    pkt->dts= pkt->pos / packet_size;
201

    
202
    pkt->stream_index = 0;
203
    if (ret != packet_size) {
204
        return AVERROR(EIO);
205
    } else {
206
        return 0;
207
    }
208
}
209
#endif
210

    
211
#ifdef CONFIG_INGENIENT_DEMUXER
212
// http://www.artificis.hu/files/texts/ingenient.txt
213
static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
214
{
215
    int ret, size, w, h, unk1, unk2;
216

    
217
    if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))
218
        return AVERROR(EIO); // FIXME
219

    
220
    size = get_le32(s->pb);
221

    
222
    w = get_le16(s->pb);
223
    h = get_le16(s->pb);
224

    
225
    url_fskip(s->pb, 8); // zero + size (padded?)
226
    url_fskip(s->pb, 2);
227
    unk1 = get_le16(s->pb);
228
    unk2 = get_le16(s->pb);
229
    url_fskip(s->pb, 22); // ASCII timestamp
230

    
231
    av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
232
        size, w, h, unk1, unk2);
233

    
234
    if (av_new_packet(pkt, size) < 0)
235
        return AVERROR(EIO);
236

    
237
    pkt->pos = url_ftell(s->pb);
238
    pkt->stream_index = 0;
239
    ret = get_buffer(s->pb, pkt->data, size);
240
    if (ret <= 0) {
241
        av_free_packet(pkt);
242
        return AVERROR(EIO);
243
    }
244
    pkt->size = ret;
245
    return ret;
246
}
247
#endif
248

    
249
#ifdef CONFIG_DEMUXERS
250
int pcm_read_seek(AVFormatContext *s,
251
                  int stream_index, int64_t timestamp, int flags)
252
{
253
    AVStream *st;
254
    int block_align, byte_rate, ret;
255
    int64_t pos;
256

    
257
    st = s->streams[0];
258

    
259
    block_align = st->codec->block_align ? st->codec->block_align :
260
        (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
261
    byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :
262
        block_align * st->codec->sample_rate;
263

    
264
    if (block_align <= 0 || byte_rate <= 0)
265
        return -1;
266

    
267
    /* compute the position by aligning it to block_align */
268
    pos = av_rescale_rnd(timestamp * byte_rate,
269
                         st->time_base.num,
270
                         st->time_base.den * (int64_t)block_align,
271
                         (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
272
    pos *= block_align;
273

    
274
    /* recompute exact position */
275
    st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
276
    if ((ret = url_fseek(s->pb, pos + s->data_offset, SEEK_SET)) < 0)
277
        return ret;
278
    return 0;
279
}
280

    
281
static int audio_read_header(AVFormatContext *s,
282
                             AVFormatParameters *ap)
283
{
284
    AVStream *st = av_new_stream(s, 0);
285
    if (!st)
286
        return AVERROR(ENOMEM);
287
    st->codec->codec_type = CODEC_TYPE_AUDIO;
288
    st->codec->codec_id = s->iformat->value;
289
    st->need_parsing = AVSTREAM_PARSE_FULL;
290
    /* the parameters will be extracted from the compressed bitstream */
291
    return 0;
292
}
293

    
294
/* MPEG-1/H.263 input */
295
static int video_read_header(AVFormatContext *s,
296
                             AVFormatParameters *ap)
297
{
298
    AVStream *st;
299

    
300
    st = av_new_stream(s, 0);
301
    if (!st)
302
        return AVERROR(ENOMEM);
303

    
304
    st->codec->codec_type = CODEC_TYPE_VIDEO;
305
    st->codec->codec_id = s->iformat->value;
306
    st->need_parsing = AVSTREAM_PARSE_FULL;
307

    
308
    /* for MJPEG, specify frame rate */
309
    /* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop_rate set ...)*/
310
    if (ap->time_base.num) {
311
        av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
312
    } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
313
                st->codec->codec_id == CODEC_ID_MPEG4 ||
314
                st->codec->codec_id == CODEC_ID_DIRAC ||
315
                st->codec->codec_id == CODEC_ID_H264) {
316
        av_set_pts_info(st, 64, 1, 25);
317
    }
318

    
319
    return 0;
320
}
321
#endif
322

    
323
#ifdef CONFIG_MPEGVIDEO_DEMUXER
324
#define SEQ_START_CODE          0x000001b3
325
#define GOP_START_CODE          0x000001b8
326
#define PICTURE_START_CODE      0x00000100
327
#define SLICE_START_CODE        0x00000101
328
#define PACK_START_CODE         0x000001ba
329
#define VIDEO_ID                0x000001e0
330
#define AUDIO_ID                0x000001c0
331

    
332
static int mpegvideo_probe(AVProbeData *p)
333
{
334
    uint32_t code= -1;
335
    int pic=0, seq=0, slice=0, pspack=0, pes=0;
336
    int i;
337

    
338
    for(i=0; i<p->buf_size; i++){
339
        code = (code<<8) + p->buf[i];
340
        if ((code & 0xffffff00) == 0x100) {
341
            switch(code){
342
            case     SEQ_START_CODE:   seq++; break;
343
            case PICTURE_START_CODE:   pic++; break;
344
            case   SLICE_START_CODE: slice++; break;
345
            case    PACK_START_CODE: pspack++; break;
346
            }
347
            if     ((code & 0x1f0) == VIDEO_ID)   pes++;
348
            else if((code & 0x1e0) == AUDIO_ID)   pes++;
349
        }
350
    }
351
    if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)
352
        return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
353
    return 0;
354
}
355
#endif
356

    
357
#ifdef CONFIG_M4V_DEMUXER
358
#define VISUAL_OBJECT_START_CODE       0x000001b5
359
#define VOP_START_CODE                 0x000001b6
360

    
361
static int mpeg4video_probe(AVProbeData *probe_packet)
362
{
363
    uint32_t temp_buffer= -1;
364
    int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;
365
    int i;
366

    
367
    for(i=0; i<probe_packet->buf_size; i++){
368
        temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];
369
        if ((temp_buffer & 0xffffff00) != 0x100)
370
            continue;
371

    
372
        if (temp_buffer == VOP_START_CODE)                         VOP++;
373
        else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;
374
        else if (temp_buffer < 0x120)                              VO++;
375
        else if (temp_buffer < 0x130)                              VOL++;
376
        else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)
377
                 && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;
378
    }
379

    
380
    if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)
381
        return AVPROBE_SCORE_MAX/2;
382
    return 0;
383
}
384
#endif
385

    
386
#ifdef CONFIG_H264_DEMUXER
387
static int h264_probe(AVProbeData *p)
388
{
389
    uint32_t code= -1;
390
    int sps=0, pps=0, idr=0, res=0, sli=0;
391
    int i;
392

    
393
    for(i=0; i<p->buf_size; i++){
394
        code = (code<<8) + p->buf[i];
395
        if ((code & 0xffffff00) == 0x100) {
396
            int ref_idc= (code>>5)&3;
397
            int type   = code & 0x1F;
398
            static const int8_t ref_zero[32]={
399
                2, 0, 0, 0, 0,-1, 1,-1,
400
               -1, 1, 1, 1, 1,-1, 2, 2,
401
                2, 2, 2, 0, 2, 2, 2, 2,
402
                2, 2, 2, 2, 2, 2, 2, 2
403
            };
404

    
405
            if(code & 0x80) //forbidden bit
406
                return 0;
407

    
408
            if(ref_zero[type] == 1 && ref_idc)
409
                return 0;
410
            if(ref_zero[type] ==-1 && !ref_idc)
411
                return 0;
412
            if(ref_zero[type] == 2)
413
                res++;
414

    
415
            switch(type){
416
            case     1:   sli++; break;
417
            case     5:   idr++; break;
418
            case     7:
419
                if(p->buf[i+2]&0x0F)
420
                    return 0;
421
                sps++;
422
                break;
423
            case     8:   pps++; break;
424
            }
425
        }
426
    }
427
    if(sps && pps && (idr||sli>3) && res<(sps+pps+idr))
428
        return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
429
    return 0;
430
}
431
#endif
432

    
433
#ifdef CONFIG_H263_DEMUXER
434
static int h263_probe(AVProbeData *p)
435
{
436
    int code;
437
    const uint8_t *d;
438

    
439
    d = p->buf;
440
    code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
441
    if (code == 0x20) {
442
        return 50;
443
    }
444
    return 0;
445
}
446
#endif
447

    
448
#ifdef CONFIG_H261_DEMUXER
449
static int h261_probe(AVProbeData *p)
450
{
451
    int code;
452
    const uint8_t *d;
453

    
454
    d = p->buf;
455
    code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
456
    if (code == 0x10) {
457
        return 50;
458
    }
459
    return 0;
460
}
461
#endif
462

    
463
#ifdef CONFIG_DTS_DEMUXER
464
#define DCA_MARKER_14B_BE 0x1FFFE800
465
#define DCA_MARKER_14B_LE 0xFF1F00E8
466
#define DCA_MARKER_RAW_BE 0x7FFE8001
467
#define DCA_MARKER_RAW_LE 0xFE7F0180
468
static int dts_probe(AVProbeData *p)
469
{
470
    const uint8_t *buf, *bufp;
471
    uint32_t state = -1;
472

    
473
    buf = p->buf;
474

    
475
    for(; buf < (p->buf+p->buf_size)-2; buf+=2) {
476
        bufp = buf;
477
        state = (state << 16) | bytestream_get_be16(&bufp);
478

    
479
        /* regular bitstream */
480
        if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)
481
            return AVPROBE_SCORE_MAX/2+1;
482

    
483
        /* 14 bits big-endian bitstream */
484
        if (state == DCA_MARKER_14B_BE)
485
            if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)
486
                return AVPROBE_SCORE_MAX/2+1;
487

    
488
        /* 14 bits little-endian bitstream */
489
        if (state == DCA_MARKER_14B_LE)
490
            if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)
491
                return AVPROBE_SCORE_MAX/2+1;
492
    }
493

    
494
    return 0;
495
}
496
#endif
497

    
498
#ifdef CONFIG_DIRAC_DEMUXER
499
static int dirac_probe(AVProbeData *p)
500
{
501
    if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
502
        return AVPROBE_SCORE_MAX;
503
    else
504
        return 0;
505
}
506
#endif
507

    
508
#ifdef CONFIG_DNXHD_DEMUXER
509
static int dnxhd_probe(AVProbeData *p)
510
{
511
    static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01};
512
    if (!memcmp(p->buf, header, 5))
513
        return AVPROBE_SCORE_MAX;
514
    else
515
        return 0;
516
}
517
#endif
518

    
519
#if defined(CONFIG_AC3_DEMUXER) || defined(CONFIG_EAC3_DEMUXER)
520
static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id)
521
{
522
    int max_frames, first_frames = 0, frames;
523
    uint8_t *buf, *buf2, *end;
524
    AC3HeaderInfo hdr;
525
    GetBitContext gbc;
526
    enum CodecID codec_id = CODEC_ID_AC3;
527

    
528
    max_frames = 0;
529
    buf = p->buf;
530
    end = buf + p->buf_size;
531

    
532
    for(; buf < end; buf++) {
533
        buf2 = buf;
534

    
535
        for(frames = 0; buf2 < end; frames++) {
536
            init_get_bits(&gbc, buf2, 54);
537
            if(ff_ac3_parse_header(&gbc, &hdr) < 0)
538
                break;
539
            if(buf2 + hdr.frame_size > end ||
540
               av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))
541
                break;
542
            if (hdr.bitstream_id > 10)
543
                codec_id = CODEC_ID_EAC3;
544
            buf2 += hdr.frame_size;
545
        }
546
        max_frames = FFMAX(max_frames, frames);
547
        if(buf == p->buf)
548
            first_frames = frames;
549
    }
550
    if(codec_id != expected_codec_id) return 0;
551
    if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
552
    else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
553
    else if(max_frames>=1) return 1;
554
    else                   return 0;
555
}
556
#endif
557

    
558
#ifdef CONFIG_AC3_DEMUXER
559
static int ac3_probe(AVProbeData *p)
560
{
561
    return ac3_eac3_probe(p, CODEC_ID_AC3);
562
}
563
#endif
564

    
565
#ifdef CONFIG_EAC3_DEMUXER
566
static int eac3_probe(AVProbeData *p)
567
{
568
    return ac3_eac3_probe(p, CODEC_ID_EAC3);
569
}
570
#endif
571

    
572
#ifdef CONFIG_FLAC_DEMUXER
573
static int flac_probe(AVProbeData *p)
574
{
575
    if(memcmp(p->buf, "fLaC", 4)) return 0;
576
    else                          return AVPROBE_SCORE_MAX / 2;
577
}
578
#endif
579

    
580

    
581
/* Note: Do not forget to add new entries to the Makefile as well. */
582

    
583
#ifdef CONFIG_AAC_DEMUXER
584
AVInputFormat aac_demuxer = {
585
    "aac",
586
    NULL_IF_CONFIG_SMALL("ADTS AAC"),
587
    0,
588
    NULL,
589
    audio_read_header,
590
    raw_read_partial_packet,
591
    .flags= AVFMT_GENERIC_INDEX,
592
    .extensions = "aac",
593
    .value = CODEC_ID_AAC,
594
};
595
#endif
596

    
597
#ifdef CONFIG_AC3_DEMUXER
598
AVInputFormat ac3_demuxer = {
599
    "ac3",
600
    NULL_IF_CONFIG_SMALL("raw AC-3"),
601
    0,
602
    ac3_probe,
603
    audio_read_header,
604
    raw_read_partial_packet,
605
    .flags= AVFMT_GENERIC_INDEX,
606
    .extensions = "ac3",
607
    .value = CODEC_ID_AC3,
608
};
609
#endif
610

    
611
#ifdef CONFIG_AC3_MUXER
612
AVOutputFormat ac3_muxer = {
613
    "ac3",
614
    NULL_IF_CONFIG_SMALL("raw AC-3"),
615
    "audio/x-ac3",
616
    "ac3",
617
    0,
618
    CODEC_ID_AC3,
619
    CODEC_ID_NONE,
620
    NULL,
621
    raw_write_packet,
622
    .flags= AVFMT_NOTIMESTAMPS,
623
};
624
#endif
625

    
626
#ifdef CONFIG_DIRAC_DEMUXER
627
AVInputFormat dirac_demuxer = {
628
    "dirac",
629
    NULL_IF_CONFIG_SMALL("raw Dirac"),
630
    0,
631
    dirac_probe,
632
    video_read_header,
633
    raw_read_partial_packet,
634
    .flags= AVFMT_GENERIC_INDEX,
635
    .value = CODEC_ID_DIRAC,
636
};
637
#endif
638

    
639
#ifdef CONFIG_DIRAC_MUXER
640
AVOutputFormat dirac_muxer = {
641
    "dirac",
642
    NULL_IF_CONFIG_SMALL("raw Dirac"),
643
    NULL,
644
    "drc",
645
    0,
646
    CODEC_ID_NONE,
647
    CODEC_ID_DIRAC,
648
    NULL,
649
    raw_write_packet,
650
    .flags= AVFMT_NOTIMESTAMPS,
651
};
652
#endif
653

    
654
#ifdef CONFIG_DNXHD_DEMUXER
655
AVInputFormat dnxhd_demuxer = {
656
    "dnxhd",
657
    NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
658
    0,
659
    dnxhd_probe,
660
    video_read_header,
661
    raw_read_partial_packet,
662
    .flags= AVFMT_GENERIC_INDEX,
663
    .value = CODEC_ID_DNXHD,
664
};
665
#endif
666

    
667
#ifdef CONFIG_DNXHD_MUXER
668
AVOutputFormat dnxhd_muxer = {
669
    "dnxhd",
670
    NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
671
    NULL,
672
    "dnxhd",
673
    0,
674
    CODEC_ID_NONE,
675
    CODEC_ID_DNXHD,
676
    NULL,
677
    raw_write_packet,
678
    .flags= AVFMT_NOTIMESTAMPS,
679
};
680
#endif
681

    
682
#ifdef CONFIG_DTS_DEMUXER
683
AVInputFormat dts_demuxer = {
684
    "dts",
685
    NULL_IF_CONFIG_SMALL("raw DTS"),
686
    0,
687
    dts_probe,
688
    audio_read_header,
689
    raw_read_partial_packet,
690
    .flags= AVFMT_GENERIC_INDEX,
691
    .extensions = "dts",
692
    .value = CODEC_ID_DTS,
693
};
694
#endif
695

    
696
#ifdef CONFIG_DTS_MUXER
697
AVOutputFormat dts_muxer = {
698
    "dts",
699
    NULL_IF_CONFIG_SMALL("raw DTS"),
700
    "audio/x-dca",
701
    "dts",
702
    0,
703
    CODEC_ID_DTS,
704
    CODEC_ID_NONE,
705
    NULL,
706
    raw_write_packet,
707
    .flags= AVFMT_NOTIMESTAMPS,
708
};
709
#endif
710

    
711
#ifdef CONFIG_EAC3_DEMUXER
712
AVInputFormat eac3_demuxer = {
713
    "eac3",
714
    NULL_IF_CONFIG_SMALL("raw E-AC-3"),
715
    0,
716
    eac3_probe,
717
    audio_read_header,
718
    raw_read_partial_packet,
719
    .flags= AVFMT_GENERIC_INDEX,
720
    .extensions = "eac3",
721
    .value = CODEC_ID_EAC3,
722
};
723
#endif
724

    
725
#ifdef CONFIG_EAC3_MUXER
726
AVOutputFormat eac3_muxer = {
727
    "eac3",
728
    NULL_IF_CONFIG_SMALL("raw E-AC-3"),
729
    "audio/x-eac3",
730
    "eac3",
731
    0,
732
    CODEC_ID_EAC3,
733
    CODEC_ID_NONE,
734
    NULL,
735
    raw_write_packet,
736
    .flags= AVFMT_NOTIMESTAMPS,
737
};
738
#endif
739

    
740
#ifdef CONFIG_FLAC_DEMUXER
741
AVInputFormat flac_demuxer = {
742
    "flac",
743
    NULL_IF_CONFIG_SMALL("raw FLAC"),
744
    0,
745
    flac_probe,
746
    audio_read_header,
747
    raw_read_partial_packet,
748
    .flags= AVFMT_GENERIC_INDEX,
749
    .extensions = "flac",
750
    .value = CODEC_ID_FLAC,
751
};
752
#endif
753

    
754
#ifdef CONFIG_FLAC_MUXER
755
AVOutputFormat flac_muxer = {
756
    "flac",
757
    NULL_IF_CONFIG_SMALL("raw FLAC"),
758
    "audio/x-flac",
759
    "flac",
760
    0,
761
    CODEC_ID_FLAC,
762
    CODEC_ID_NONE,
763
    flac_write_header,
764
    raw_write_packet,
765
    flac_write_trailer,
766
    .flags= AVFMT_NOTIMESTAMPS,
767
};
768
#endif
769

    
770
#ifdef CONFIG_GSM_DEMUXER
771
AVInputFormat gsm_demuxer = {
772
    "gsm",
773
    NULL_IF_CONFIG_SMALL("GSM"),
774
    0,
775
    NULL,
776
    audio_read_header,
777
    raw_read_partial_packet,
778
    .flags= AVFMT_GENERIC_INDEX,
779
    .extensions = "gsm",
780
    .value = CODEC_ID_GSM,
781
};
782
#endif
783

    
784
#ifdef CONFIG_H261_DEMUXER
785
AVInputFormat h261_demuxer = {
786
    "h261",
787
    NULL_IF_CONFIG_SMALL("raw H.261"),
788
    0,
789
    h261_probe,
790
    video_read_header,
791
    raw_read_partial_packet,
792
    .flags= AVFMT_GENERIC_INDEX,
793
    .extensions = "h261",
794
    .value = CODEC_ID_H261,
795
};
796
#endif
797

    
798
#ifdef CONFIG_H261_MUXER
799
AVOutputFormat h261_muxer = {
800
    "h261",
801
    NULL_IF_CONFIG_SMALL("raw H.261"),
802
    "video/x-h261",
803
    "h261",
804
    0,
805
    CODEC_ID_NONE,
806
    CODEC_ID_H261,
807
    NULL,
808
    raw_write_packet,
809
    .flags= AVFMT_NOTIMESTAMPS,
810
};
811
#endif
812

    
813
#ifdef CONFIG_H263_DEMUXER
814
AVInputFormat h263_demuxer = {
815
    "h263",
816
    NULL_IF_CONFIG_SMALL("raw H.263"),
817
    0,
818
    h263_probe,
819
    video_read_header,
820
    raw_read_partial_packet,
821
    .flags= AVFMT_GENERIC_INDEX,
822
//    .extensions = "h263", //FIXME remove after writing mpeg4_probe
823
    .value = CODEC_ID_H263,
824
};
825
#endif
826

    
827
#ifdef CONFIG_H263_MUXER
828
AVOutputFormat h263_muxer = {
829
    "h263",
830
    NULL_IF_CONFIG_SMALL("raw H.263"),
831
    "video/x-h263",
832
    "h263",
833
    0,
834
    CODEC_ID_NONE,
835
    CODEC_ID_H263,
836
    NULL,
837
    raw_write_packet,
838
    .flags= AVFMT_NOTIMESTAMPS,
839
};
840
#endif
841

    
842
#ifdef CONFIG_H264_DEMUXER
843
AVInputFormat h264_demuxer = {
844
    "h264",
845
    NULL_IF_CONFIG_SMALL("raw H.264 video format"),
846
    0,
847
    h264_probe,
848
    video_read_header,
849
    raw_read_partial_packet,
850
    .flags= AVFMT_GENERIC_INDEX,
851
    .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
852
    .value = CODEC_ID_H264,
853
};
854
#endif
855

    
856
#ifdef CONFIG_H264_MUXER
857
AVOutputFormat h264_muxer = {
858
    "h264",
859
    NULL_IF_CONFIG_SMALL("raw H.264 video format"),
860
    NULL,
861
    "h264",
862
    0,
863
    CODEC_ID_NONE,
864
    CODEC_ID_H264,
865
    NULL,
866
    raw_write_packet,
867
    .flags= AVFMT_NOTIMESTAMPS,
868
};
869
#endif
870

    
871
#ifdef CONFIG_INGENIENT_DEMUXER
872
AVInputFormat ingenient_demuxer = {
873
    "ingenient",
874
    NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),
875
    0,
876
    NULL,
877
    video_read_header,
878
    ingenient_read_packet,
879
    .flags= AVFMT_GENERIC_INDEX,
880
    .extensions = "cgi", // FIXME
881
    .value = CODEC_ID_MJPEG,
882
};
883
#endif
884

    
885
#ifdef CONFIG_M4V_DEMUXER
886
AVInputFormat m4v_demuxer = {
887
    "m4v",
888
    NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
889
    0,
890
    mpeg4video_probe, /** probing for MPEG-4 data */
891
    video_read_header,
892
    raw_read_partial_packet,
893
    .flags= AVFMT_GENERIC_INDEX,
894
    .extensions = "m4v", //FIXME remove after writing mpeg4_probe
895
    .value = CODEC_ID_MPEG4,
896
};
897
#endif
898

    
899
#ifdef CONFIG_M4V_MUXER
900
AVOutputFormat m4v_muxer = {
901
    "m4v",
902
    NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
903
    NULL,
904
    "m4v",
905
    0,
906
    CODEC_ID_NONE,
907
    CODEC_ID_MPEG4,
908
    NULL,
909
    raw_write_packet,
910
    .flags= AVFMT_NOTIMESTAMPS,
911
};
912
#endif
913

    
914
#ifdef CONFIG_MJPEG_DEMUXER
915
AVInputFormat mjpeg_demuxer = {
916
    "mjpeg",
917
    NULL_IF_CONFIG_SMALL("MJPEG video"),
918
    0,
919
    NULL,
920
    video_read_header,
921
    raw_read_partial_packet,
922
    .flags= AVFMT_GENERIC_INDEX,
923
    .extensions = "mjpg,mjpeg",
924
    .value = CODEC_ID_MJPEG,
925
};
926
#endif
927

    
928
#ifdef CONFIG_MJPEG_MUXER
929
AVOutputFormat mjpeg_muxer = {
930
    "mjpeg",
931
    NULL_IF_CONFIG_SMALL("MJPEG video"),
932
    "video/x-mjpeg",
933
    "mjpg,mjpeg",
934
    0,
935
    CODEC_ID_NONE,
936
    CODEC_ID_MJPEG,
937
    NULL,
938
    raw_write_packet,
939
    .flags= AVFMT_NOTIMESTAMPS,
940
};
941
#endif
942

    
943
#ifdef CONFIG_MLP_DEMUXER
944
AVInputFormat mlp_demuxer = {
945
    "mlp",
946
    NULL_IF_CONFIG_SMALL("raw MLP"),
947
    0,
948
    NULL,
949
    audio_read_header,
950
    raw_read_partial_packet,
951
    .flags= AVFMT_GENERIC_INDEX,
952
    .extensions = "mlp",
953
    .value = CODEC_ID_MLP,
954
};
955
#endif
956

    
957
#ifdef CONFIG_MPEG1VIDEO_MUXER
958
AVOutputFormat mpeg1video_muxer = {
959
    "mpeg1video",
960
    NULL_IF_CONFIG_SMALL("MPEG video"),
961
    "video/x-mpeg",
962
    "mpg,mpeg,m1v",
963
    0,
964
    CODEC_ID_NONE,
965
    CODEC_ID_MPEG1VIDEO,
966
    NULL,
967
    raw_write_packet,
968
    .flags= AVFMT_NOTIMESTAMPS,
969
};
970
#endif
971

    
972
#ifdef CONFIG_MPEG2VIDEO_MUXER
973
AVOutputFormat mpeg2video_muxer = {
974
    "mpeg2video",
975
    NULL_IF_CONFIG_SMALL("MPEG-2 video"),
976
    NULL,
977
    "m2v",
978
    0,
979
    CODEC_ID_NONE,
980
    CODEC_ID_MPEG2VIDEO,
981
    NULL,
982
    raw_write_packet,
983
    .flags= AVFMT_NOTIMESTAMPS,
984
};
985
#endif
986

    
987
#ifdef CONFIG_MPEGVIDEO_DEMUXER
988
AVInputFormat mpegvideo_demuxer = {
989
    "mpegvideo",
990
    NULL_IF_CONFIG_SMALL("MPEG video"),
991
    0,
992
    mpegvideo_probe,
993
    video_read_header,
994
    raw_read_partial_packet,
995
    .flags= AVFMT_GENERIC_INDEX,
996
    .value = CODEC_ID_MPEG1VIDEO,
997
};
998
#endif
999

    
1000
#ifdef CONFIG_NULL_MUXER
1001
AVOutputFormat null_muxer = {
1002
    "null",
1003
    NULL_IF_CONFIG_SMALL("null video format"),
1004
    NULL,
1005
    NULL,
1006
    0,
1007
#ifdef WORDS_BIGENDIAN
1008
    CODEC_ID_PCM_S16BE,
1009
#else
1010
    CODEC_ID_PCM_S16LE,
1011
#endif
1012
    CODEC_ID_RAWVIDEO,
1013
    NULL,
1014
    null_write_packet,
1015
    .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
1016
};
1017
#endif
1018

    
1019
#ifdef CONFIG_RAWVIDEO_DEMUXER
1020
AVInputFormat rawvideo_demuxer = {
1021
    "rawvideo",
1022
    NULL_IF_CONFIG_SMALL("raw video format"),
1023
    0,
1024
    NULL,
1025
    raw_read_header,
1026
    rawvideo_read_packet,
1027
    .flags= AVFMT_GENERIC_INDEX,
1028
    .extensions = "yuv,cif,qcif,rgb",
1029
    .value = CODEC_ID_RAWVIDEO,
1030
};
1031
#endif
1032

    
1033
#ifdef CONFIG_RAWVIDEO_MUXER
1034
AVOutputFormat rawvideo_muxer = {
1035
    "rawvideo",
1036
    NULL_IF_CONFIG_SMALL("raw video format"),
1037
    NULL,
1038
    "yuv,rgb",
1039
    0,
1040
    CODEC_ID_NONE,
1041
    CODEC_ID_RAWVIDEO,
1042
    NULL,
1043
    raw_write_packet,
1044
    .flags= AVFMT_NOTIMESTAMPS,
1045
};
1046
#endif
1047

    
1048
#ifdef CONFIG_ROQ_MUXER
1049
AVOutputFormat roq_muxer =
1050
{
1051
    "RoQ",
1052
    NULL_IF_CONFIG_SMALL("id RoQ format"),
1053
    NULL,
1054
    "roq",
1055
    0,
1056
    CODEC_ID_ROQ_DPCM,
1057
    CODEC_ID_ROQ,
1058
    roq_write_header,
1059
    raw_write_packet,
1060
};
1061
#endif
1062

    
1063
#ifdef CONFIG_SHORTEN_DEMUXER
1064
AVInputFormat shorten_demuxer = {
1065
    "shn",
1066
    NULL_IF_CONFIG_SMALL("raw Shorten"),
1067
    0,
1068
    NULL,
1069
    audio_read_header,
1070
    raw_read_partial_packet,
1071
    .flags= AVFMT_GENERIC_INDEX,
1072
    .extensions = "shn",
1073
    .value = CODEC_ID_SHORTEN,
1074
};
1075
#endif
1076

    
1077
#ifdef CONFIG_VC1_DEMUXER
1078
AVInputFormat vc1_demuxer = {
1079
    "vc1",
1080
    NULL_IF_CONFIG_SMALL("raw VC-1"),
1081
    0,
1082
    NULL /* vc1_probe */,
1083
    video_read_header,
1084
    raw_read_partial_packet,
1085
    .extensions = "vc1",
1086
    .value = CODEC_ID_VC1,
1087
};
1088
#endif
1089

    
1090
/* PCM formats */
1091

    
1092
#define PCMINPUTDEF(name, long_name, ext, codec) \
1093
AVInputFormat pcm_ ## name ## _demuxer = {\
1094
    #name,\
1095
    NULL_IF_CONFIG_SMALL(long_name),\
1096
    0,\
1097
    NULL,\
1098
    raw_read_header,\
1099
    raw_read_packet,\
1100
    NULL,\
1101
    pcm_read_seek,\
1102
    .flags= AVFMT_GENERIC_INDEX,\
1103
    .extensions = ext,\
1104
    .value = codec,\
1105
};
1106

    
1107
#define PCMOUTPUTDEF(name, long_name, ext, codec) \
1108
AVOutputFormat pcm_ ## name ## _muxer = {\
1109
    #name,\
1110
    NULL_IF_CONFIG_SMALL(long_name),\
1111
    NULL,\
1112
    ext,\
1113
    0,\
1114
    codec,\
1115
    CODEC_ID_NONE,\
1116
    NULL,\
1117
    raw_write_packet,\
1118
    .flags= AVFMT_NOTIMESTAMPS,\
1119
};
1120

    
1121

    
1122
#if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
1123
#define PCMDEF(name, long_name, ext, codec) \
1124
        PCMINPUTDEF(name, long_name, ext, codec)
1125
#elif defined(CONFIG_MUXERS) && !defined(CONFIG_DEMUXERS)
1126
#define PCMDEF(name, long_name, ext, codec) \
1127
        PCMOUTPUTDEF(name, long_name, ext, codec)
1128
#elif defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
1129
#define PCMDEF(name, long_name, ext, codec) \
1130
        PCMINPUTDEF(name, long_name, ext, codec)\
1131
        PCMOUTPUTDEF(name, long_name, ext, codec)
1132
#else
1133
#define PCMDEF(name, long_name, ext, codec)
1134
#endif
1135

    
1136
#ifdef WORDS_BIGENDIAN
1137
#define BE_DEF(s) s
1138
#define LE_DEF(s) NULL
1139
#else
1140
#define BE_DEF(s) NULL
1141
#define LE_DEF(s) s
1142
#endif
1143

    
1144
PCMDEF(f64be, "PCM 64 bit floating-point big-endian format",
1145
       NULL, CODEC_ID_PCM_F64BE)
1146

    
1147
PCMDEF(f64le, "PCM 64 bit floating-point little-endian format",
1148
       NULL, CODEC_ID_PCM_F64LE)
1149

    
1150
PCMDEF(f32be, "PCM 32 bit floating-point big-endian format",
1151
       NULL, CODEC_ID_PCM_F32BE)
1152

    
1153
PCMDEF(f32le, "PCM 32 bit floating-point little-endian format",
1154
       NULL, CODEC_ID_PCM_F32LE)
1155

    
1156
PCMDEF(s32be, "PCM signed 32 bit big-endian format",
1157
       NULL, CODEC_ID_PCM_S32BE)
1158

    
1159
PCMDEF(s32le, "PCM signed 32 bit little-endian format",
1160
       NULL, CODEC_ID_PCM_S32LE)
1161

    
1162
PCMDEF(s24be, "PCM signed 24 bit big-endian format",
1163
       NULL, CODEC_ID_PCM_S24BE)
1164

    
1165
PCMDEF(s24le, "PCM signed 24 bit little-endian format",
1166
       NULL, CODEC_ID_PCM_S24LE)
1167

    
1168
PCMDEF(s16be, "PCM signed 16 bit big-endian format",
1169
       BE_DEF("sw"), CODEC_ID_PCM_S16BE)
1170

    
1171
PCMDEF(s16le, "PCM signed 16 bit little-endian format",
1172
       LE_DEF("sw"), CODEC_ID_PCM_S16LE)
1173

    
1174
PCMDEF(s8, "PCM signed 8 bit format",
1175
       "sb", CODEC_ID_PCM_S8)
1176

    
1177
PCMDEF(u32be, "PCM unsigned 32 bit big-endian format",
1178
       NULL, CODEC_ID_PCM_U32BE)
1179

    
1180
PCMDEF(u32le, "PCM unsigned 32 bit little-endian format",
1181
       NULL, CODEC_ID_PCM_U32LE)
1182

    
1183
PCMDEF(u24be, "PCM unsigned 24 bit big-endian format",
1184
       NULL, CODEC_ID_PCM_U24BE)
1185

    
1186
PCMDEF(u24le, "PCM unsigned 24 bit little-endian format",
1187
       NULL, CODEC_ID_PCM_U24LE)
1188

    
1189
PCMDEF(u16be, "PCM unsigned 16 bit big-endian format",
1190
       BE_DEF("uw"), CODEC_ID_PCM_U16BE)
1191

    
1192
PCMDEF(u16le, "PCM unsigned 16 bit little-endian format",
1193
       LE_DEF("uw"), CODEC_ID_PCM_U16LE)
1194

    
1195
PCMDEF(u8, "PCM unsigned 8 bit format",
1196
       "ub", CODEC_ID_PCM_U8)
1197

    
1198
PCMDEF(alaw, "PCM A-law format",
1199
       "al", CODEC_ID_PCM_ALAW)
1200

    
1201
PCMDEF(mulaw, "PCM mu-law format",
1202
       "ul", CODEC_ID_PCM_MULAW)