Statistics
| Branch: | Revision:

ffmpeg / libavformat / raw.c @ ba2c508d

History | View | Annotate | Download (33.5 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/get_bits.h"
26
#include "libavcodec/bytestream.h"
27
#include "avformat.h"
28
#include "raw.h"
29
#include "id3v2.h"
30
#include "id3v1.h"
31

    
32
/* simple formats */
33

    
34
#if CONFIG_ROQ_MUXER
35
static int roq_write_header(struct AVFormatContext *s)
36
{
37
    static const uint8_t header[] = {
38
        0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00
39
    };
40

    
41
    put_buffer(s->pb, header, 8);
42
    put_flush_packet(s->pb);
43

    
44
    return 0;
45
}
46
#endif
47

    
48
#if CONFIG_NULL_MUXER
49
static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
50
{
51
    return 0;
52
}
53
#endif
54

    
55
#if CONFIG_MUXERS
56
static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)
57
{
58
    put_buffer(s->pb, pkt->data, pkt->size);
59
    put_flush_packet(s->pb);
60
    return 0;
61
}
62
#endif
63

    
64
#if CONFIG_DEMUXERS
65
/* raw input */
66
static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
67
{
68
    AVStream *st;
69
    enum CodecID id;
70

    
71
    st = av_new_stream(s, 0);
72
    if (!st)
73
        return AVERROR(ENOMEM);
74

    
75
        id = s->iformat->value;
76
        if (id == CODEC_ID_RAWVIDEO) {
77
            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
78
        } else {
79
            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
80
        }
81
        st->codec->codec_id = id;
82

    
83
        switch(st->codec->codec_type) {
84
        case AVMEDIA_TYPE_AUDIO:
85
            st->codec->sample_rate = ap->sample_rate;
86
            if(ap->channels) st->codec->channels = ap->channels;
87
            else             st->codec->channels = 1;
88
            st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id);
89
            assert(st->codec->bits_per_coded_sample > 0);
90
            st->codec->block_align = st->codec->bits_per_coded_sample*st->codec->channels/8;
91
            av_set_pts_info(st, 64, 1, st->codec->sample_rate);
92
            break;
93
        case AVMEDIA_TYPE_VIDEO:
94
            if(ap->time_base.num)
95
                av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
96
            else
97
                av_set_pts_info(st, 64, 1, 25);
98
            st->codec->width = ap->width;
99
            st->codec->height = ap->height;
100
            st->codec->pix_fmt = ap->pix_fmt;
101
            if(st->codec->pix_fmt == PIX_FMT_NONE)
102
                st->codec->pix_fmt= PIX_FMT_YUV420P;
103
            break;
104
        default:
105
            return -1;
106
        }
107
    return 0;
108
}
109

    
110
#define RAW_PACKET_SIZE 1024
111
#define RAW_SAMPLES     1024
112

    
113
static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
114
{
115
    int ret, size, bps;
116
    //    AVStream *st = s->streams[0];
117

    
118
    size= RAW_SAMPLES*s->streams[0]->codec->block_align;
119

    
120
    ret= av_get_packet(s->pb, pkt, size);
121

    
122
    pkt->stream_index = 0;
123
    if (ret < 0)
124
        return ret;
125

    
126
    bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id);
127
    assert(bps); // if false there IS a bug elsewhere (NOT in this function)
128
    pkt->dts=
129
    pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels);
130

    
131
    return ret;
132
}
133

    
134
int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
135
{
136
    int ret, size;
137

    
138
    size = RAW_PACKET_SIZE;
139

    
140
    if (av_new_packet(pkt, size) < 0)
141
        return AVERROR(ENOMEM);
142

    
143
    pkt->pos= url_ftell(s->pb);
144
    pkt->stream_index = 0;
145
    ret = get_partial_buffer(s->pb, pkt->data, size);
146
    if (ret < 0) {
147
        av_free_packet(pkt);
148
        return ret;
149
    }
150
    pkt->size = ret;
151
    return ret;
152
}
153
#endif
154

    
155
#if CONFIG_RAWVIDEO_DEMUXER
156
static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
157
{
158
    int packet_size, ret, width, height;
159
    AVStream *st = s->streams[0];
160

    
161
    width = st->codec->width;
162
    height = st->codec->height;
163

    
164
    packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
165
    if (packet_size < 0)
166
        return -1;
167

    
168
    ret= av_get_packet(s->pb, pkt, packet_size);
169
    pkt->pts=
170
    pkt->dts= pkt->pos / packet_size;
171

    
172
    pkt->stream_index = 0;
173
    if (ret < 0)
174
        return ret;
175
    return 0;
176
}
177
#endif
178

    
179
#if CONFIG_INGENIENT_DEMUXER
180
// http://www.artificis.hu/files/texts/ingenient.txt
181
static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
182
{
183
    int ret, size, w, h, unk1, unk2;
184

    
185
    if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))
186
        return AVERROR(EIO); // FIXME
187

    
188
    size = get_le32(s->pb);
189

    
190
    w = get_le16(s->pb);
191
    h = get_le16(s->pb);
192

    
193
    url_fskip(s->pb, 8); // zero + size (padded?)
194
    url_fskip(s->pb, 2);
195
    unk1 = get_le16(s->pb);
196
    unk2 = get_le16(s->pb);
197
    url_fskip(s->pb, 22); // ASCII timestamp
198

    
199
    av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
200
        size, w, h, unk1, unk2);
201

    
202
    if (av_new_packet(pkt, size) < 0)
203
        return AVERROR(ENOMEM);
204

    
205
    pkt->pos = url_ftell(s->pb);
206
    pkt->stream_index = 0;
207
    ret = get_buffer(s->pb, pkt->data, size);
208
    if (ret < 0) {
209
        av_free_packet(pkt);
210
        return ret;
211
    }
212
    pkt->size = ret;
213
    return ret;
214
}
215
#endif
216

    
217
#if CONFIG_DEMUXERS
218
int pcm_read_seek(AVFormatContext *s,
219
                  int stream_index, int64_t timestamp, int flags)
220
{
221
    AVStream *st;
222
    int block_align, byte_rate;
223
    int64_t pos, ret;
224

    
225
    st = s->streams[0];
226

    
227
    block_align = st->codec->block_align ? st->codec->block_align :
228
        (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
229
    byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :
230
        block_align * st->codec->sample_rate;
231

    
232
    if (block_align <= 0 || byte_rate <= 0)
233
        return -1;
234
    if (timestamp < 0) timestamp = 0;
235

    
236
    /* compute the position by aligning it to block_align */
237
    pos = av_rescale_rnd(timestamp * byte_rate,
238
                         st->time_base.num,
239
                         st->time_base.den * (int64_t)block_align,
240
                         (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
241
    pos *= block_align;
242

    
243
    /* recompute exact position */
244
    st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
245
    if ((ret = url_fseek(s->pb, pos + s->data_offset, SEEK_SET)) < 0)
246
        return ret;
247
    return 0;
248
}
249

    
250
static int audio_read_header(AVFormatContext *s,
251
                             AVFormatParameters *ap)
252
{
253
    AVStream *st = av_new_stream(s, 0);
254
    if (!st)
255
        return AVERROR(ENOMEM);
256
    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
257
    st->codec->codec_id = s->iformat->value;
258
    st->need_parsing = AVSTREAM_PARSE_FULL;
259
    /* the parameters will be extracted from the compressed bitstream */
260

    
261
    return 0;
262
}
263

    
264
/* MPEG-1/H.263 input */
265
static int video_read_header(AVFormatContext *s,
266
                             AVFormatParameters *ap)
267
{
268
    AVStream *st;
269

    
270
    st = av_new_stream(s, 0);
271
    if (!st)
272
        return AVERROR(ENOMEM);
273

    
274
    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
275
    st->codec->codec_id = s->iformat->value;
276
    st->need_parsing = AVSTREAM_PARSE_FULL;
277

    
278
    /* for MJPEG, specify frame rate */
279
    /* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop_rate set ...)*/
280
    if (ap->time_base.num) {
281
        st->codec->time_base= ap->time_base;
282
    } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
283
                st->codec->codec_id == CODEC_ID_MPEG4 ||
284
                st->codec->codec_id == CODEC_ID_DIRAC ||
285
                st->codec->codec_id == CODEC_ID_DNXHD ||
286
                st->codec->codec_id == CODEC_ID_VC1   ||
287
                st->codec->codec_id == CODEC_ID_H264) {
288
        st->codec->time_base= (AVRational){1,25};
289
    }
290
    av_set_pts_info(st, 64, 1, 1200000);
291

    
292
    return 0;
293
}
294
#endif
295

    
296
#if CONFIG_MPEGVIDEO_DEMUXER
297
#define SEQ_START_CODE          0x000001b3
298
#define GOP_START_CODE          0x000001b8
299
#define PICTURE_START_CODE      0x00000100
300
#define SLICE_START_CODE        0x00000101
301
#define PACK_START_CODE         0x000001ba
302
#define VIDEO_ID                0x000001e0
303
#define AUDIO_ID                0x000001c0
304

    
305
static int mpegvideo_probe(AVProbeData *p)
306
{
307
    uint32_t code= -1;
308
    int pic=0, seq=0, slice=0, pspack=0, pes=0;
309
    int i;
310

    
311
    for(i=0; i<p->buf_size; i++){
312
        code = (code<<8) + p->buf[i];
313
        if ((code & 0xffffff00) == 0x100) {
314
            switch(code){
315
            case     SEQ_START_CODE:   seq++; break;
316
            case PICTURE_START_CODE:   pic++; break;
317
            case   SLICE_START_CODE: slice++; break;
318
            case    PACK_START_CODE: pspack++; break;
319
            }
320
            if     ((code & 0x1f0) == VIDEO_ID)   pes++;
321
            else if((code & 0x1e0) == AUDIO_ID)   pes++;
322
        }
323
    }
324
    if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)
325
        return pic>1 ? AVPROBE_SCORE_MAX/2+1 : AVPROBE_SCORE_MAX/4; // +1 for .mpg
326
    return 0;
327
}
328
#endif
329

    
330
#if CONFIG_CAVSVIDEO_DEMUXER
331
#define CAVS_SEQ_START_CODE       0x000001b0
332
#define CAVS_PIC_I_START_CODE     0x000001b3
333
#define CAVS_UNDEF_START_CODE     0x000001b4
334
#define CAVS_PIC_PB_START_CODE    0x000001b6
335
#define CAVS_VIDEO_EDIT_CODE      0x000001b7
336
#define CAVS_PROFILE_JIZHUN       0x20
337

    
338
static int cavsvideo_probe(AVProbeData *p)
339
{
340
    uint32_t code= -1;
341
    int pic=0, seq=0, slice_pos = 0;
342
    int i;
343

    
344
    for(i=0; i<p->buf_size; i++){
345
        code = (code<<8) + p->buf[i];
346
        if ((code & 0xffffff00) == 0x100) {
347
            if(code < CAVS_SEQ_START_CODE) {
348
                /* slices have to be consecutive */
349
                if(code < slice_pos)
350
                    return 0;
351
                slice_pos = code;
352
            } else {
353
                slice_pos = 0;
354
            }
355
            if (code == CAVS_SEQ_START_CODE) {
356
                seq++;
357
                /* check for the only currently supported profile */
358
                if(p->buf[i+1] != CAVS_PROFILE_JIZHUN)
359
                    return 0;
360
            } else if ((code == CAVS_PIC_I_START_CODE) ||
361
                       (code == CAVS_PIC_PB_START_CODE)) {
362
                pic++;
363
            } else if ((code == CAVS_UNDEF_START_CODE) ||
364
                       (code >  CAVS_VIDEO_EDIT_CODE)) {
365
                return 0;
366
            }
367
        }
368
    }
369
    if(seq && seq*9<=pic*10)
370
        return AVPROBE_SCORE_MAX/2;
371
    return 0;
372
}
373
#endif
374

    
375
#if CONFIG_M4V_DEMUXER
376
#define VISUAL_OBJECT_START_CODE       0x000001b5
377
#define VOP_START_CODE                 0x000001b6
378

    
379
static int mpeg4video_probe(AVProbeData *probe_packet)
380
{
381
    uint32_t temp_buffer= -1;
382
    int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;
383
    int i;
384

    
385
    for(i=0; i<probe_packet->buf_size; i++){
386
        temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];
387
        if ((temp_buffer & 0xffffff00) != 0x100)
388
            continue;
389

    
390
        if (temp_buffer == VOP_START_CODE)                         VOP++;
391
        else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;
392
        else if (temp_buffer < 0x120)                              VO++;
393
        else if (temp_buffer < 0x130)                              VOL++;
394
        else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)
395
                 && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;
396
    }
397

    
398
    if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)
399
        return AVPROBE_SCORE_MAX/2;
400
    return 0;
401
}
402
#endif
403

    
404
#if CONFIG_H264_DEMUXER
405
static int h264_probe(AVProbeData *p)
406
{
407
    uint32_t code= -1;
408
    int sps=0, pps=0, idr=0, res=0, sli=0;
409
    int i;
410

    
411
    for(i=0; i<p->buf_size; i++){
412
        code = (code<<8) + p->buf[i];
413
        if ((code & 0xffffff00) == 0x100) {
414
            int ref_idc= (code>>5)&3;
415
            int type   = code & 0x1F;
416
            static const int8_t ref_zero[32]={
417
                2, 0, 0, 0, 0,-1, 1,-1,
418
               -1, 1, 1, 1, 1,-1, 2, 2,
419
                2, 2, 2, 0, 2, 2, 2, 2,
420
                2, 2, 2, 2, 2, 2, 2, 2
421
            };
422

    
423
            if(code & 0x80) //forbidden bit
424
                return 0;
425

    
426
            if(ref_zero[type] == 1 && ref_idc)
427
                return 0;
428
            if(ref_zero[type] ==-1 && !ref_idc)
429
                return 0;
430
            if(ref_zero[type] == 2)
431
                res++;
432

    
433
            switch(type){
434
            case     1:   sli++; break;
435
            case     5:   idr++; break;
436
            case     7:
437
                if(p->buf[i+2]&0x0F)
438
                    return 0;
439
                sps++;
440
                break;
441
            case     8:   pps++; break;
442
            }
443
        }
444
    }
445
    if(sps && pps && (idr||sli>3) && res<(sps+pps+idr))
446
        return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
447
    return 0;
448
}
449
#endif
450

    
451
#if CONFIG_H263_DEMUXER
452
static int h263_probe(AVProbeData *p)
453
{
454
    uint64_t code= -1;
455
    int i;
456
    int valid_psc=0;
457
    int invalid_psc=0;
458
    int res_change=0;
459
    int src_fmt, last_src_fmt=-1;
460
    int last_gn=0;
461

    
462
    for(i=0; i<p->buf_size; i++){
463
        code = (code<<8) + p->buf[i];
464
        if ((code & 0xfffffc0000) == 0x800000) {
465
            src_fmt= (code>>2)&3;
466
            if(   src_fmt != last_src_fmt
467
               && last_src_fmt>0 && last_src_fmt<6
468
               && src_fmt<6)
469
                res_change++;
470

    
471
            if((code&0x300)==0x200 && src_fmt){
472
                valid_psc++;
473
                last_gn=0;
474
            }else
475
                invalid_psc++;
476
            last_src_fmt= src_fmt;
477
        } else if((code & 0xffff800000) == 0x800000) {
478
            int gn= (code>>(23-5)) & 0x1F;
479
            if(gn<last_gn){
480
                invalid_psc++;
481
            }else
482
                last_gn= gn;
483
        }
484
    }
485
//av_log(NULL, AV_LOG_ERROR, "h263_probe: psc:%d invalid:%d res_change:%d\n", valid_psc, invalid_psc, res_change);
486
//h263_probe: psc:3 invalid:0 res_change:0 (1588/recent_ffmpeg_parses_mpg_incorrectly.mpg)
487
    if(valid_psc > 2*invalid_psc + 2*res_change + 3){
488
        return 50;
489
    }else if(valid_psc > 2*invalid_psc)
490
        return 25;
491
    return 0;
492
}
493
#endif
494

    
495
#if CONFIG_H261_DEMUXER
496
static int h261_probe(AVProbeData *p)
497
{
498
    uint32_t code= -1;
499
    int i;
500
    int valid_psc=0;
501
    int invalid_psc=0;
502
    int next_gn=0;
503
    int src_fmt=0;
504
    GetBitContext gb;
505

    
506
    init_get_bits(&gb, p->buf, p->buf_size*8);
507

    
508
    for(i=0; i<p->buf_size*8; i++){
509
        if ((code & 0x01ff0000) || !(code & 0xff00)) {
510
            code = (code<<8) + get_bits(&gb, 8);
511
            i += 7;
512
        } else
513
            code = (code<<1) + get_bits1(&gb);
514
        if ((code & 0xffff0000) == 0x10000) {
515
            int gn= (code>>12)&0xf;
516
            if(!gn)
517
                src_fmt= code&8;
518
            if(gn != next_gn) invalid_psc++;
519
            else              valid_psc++;
520

    
521
            if(src_fmt){ // CIF
522
                next_gn= (gn+1     )%13;
523
            }else{       //QCIF
524
                next_gn= (gn+1+!!gn)% 7;
525
            }
526
        }
527
    }
528
    if(valid_psc > 2*invalid_psc + 6){
529
        return 50;
530
    }else if(valid_psc > 2*invalid_psc + 2)
531
        return 25;
532
    return 0;
533
}
534
#endif
535

    
536
#if CONFIG_DTS_DEMUXER
537
#define DCA_MARKER_14B_BE 0x1FFFE800
538
#define DCA_MARKER_14B_LE 0xFF1F00E8
539
#define DCA_MARKER_RAW_BE 0x7FFE8001
540
#define DCA_MARKER_RAW_LE 0xFE7F0180
541
static int dts_probe(AVProbeData *p)
542
{
543
    const uint8_t *buf, *bufp;
544
    uint32_t state = -1;
545
    int markers[3] = {0};
546
    int sum, max;
547

    
548
    buf = p->buf;
549

    
550
    for(; buf < (p->buf+p->buf_size)-2; buf+=2) {
551
        bufp = buf;
552
        state = (state << 16) | bytestream_get_be16(&bufp);
553

    
554
        /* regular bitstream */
555
        if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)
556
            markers[0]++;
557

    
558
        /* 14 bits big-endian bitstream */
559
        if (state == DCA_MARKER_14B_BE)
560
            if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)
561
                markers[1]++;
562

    
563
        /* 14 bits little-endian bitstream */
564
        if (state == DCA_MARKER_14B_LE)
565
            if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)
566
                markers[2]++;
567
    }
568
    sum = markers[0] + markers[1] + markers[2];
569
    max = markers[1] > markers[0];
570
    max = markers[2] > markers[max] ? 2 : max;
571
    if (markers[max] > 3 && p->buf_size / markers[max] < 32*1024 &&
572
        markers[max] * 4 > sum * 3)
573
        return AVPROBE_SCORE_MAX/2+1;
574

    
575
    return 0;
576
}
577
#endif
578

    
579
#if CONFIG_DIRAC_DEMUXER
580
static int dirac_probe(AVProbeData *p)
581
{
582
    if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
583
        return AVPROBE_SCORE_MAX;
584
    else
585
        return 0;
586
}
587
#endif
588

    
589
#if CONFIG_DNXHD_DEMUXER
590
static int dnxhd_probe(AVProbeData *p)
591
{
592
    static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01};
593
    int w, h, compression_id;
594
    if (p->buf_size < 0x2c)
595
        return 0;
596
    if (memcmp(p->buf, header, 5))
597
        return 0;
598
    h = AV_RB16(p->buf + 0x18);
599
    w = AV_RB16(p->buf + 0x1a);
600
    if (!w || !h)
601
        return 0;
602
    compression_id = AV_RB32(p->buf + 0x28);
603
    if (compression_id < 1237 || compression_id > 1253)
604
        return 0;
605
    return AVPROBE_SCORE_MAX;
606
}
607
#endif
608

    
609
#if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER
610
static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id)
611
{
612
    int max_frames, first_frames = 0, frames;
613
    uint8_t *buf, *buf2, *end;
614
    AC3HeaderInfo hdr;
615
    GetBitContext gbc;
616
    enum CodecID codec_id = CODEC_ID_AC3;
617

    
618
    max_frames = 0;
619
    buf = p->buf;
620
    end = buf + p->buf_size;
621

    
622
    for(; buf < end; buf++) {
623
        buf2 = buf;
624

    
625
        for(frames = 0; buf2 < end; frames++) {
626
            init_get_bits(&gbc, buf2, 54);
627
            if(ff_ac3_parse_header(&gbc, &hdr) < 0)
628
                break;
629
            if(buf2 + hdr.frame_size > end ||
630
               av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))
631
                break;
632
            if (hdr.bitstream_id > 10)
633
                codec_id = CODEC_ID_EAC3;
634
            buf2 += hdr.frame_size;
635
        }
636
        max_frames = FFMAX(max_frames, frames);
637
        if(buf == p->buf)
638
            first_frames = frames;
639
    }
640
    if(codec_id != expected_codec_id) return 0;
641
    // keep this in sync with mp3 probe, both need to avoid
642
    // issues with MPEG-files!
643
    if   (first_frames>=4) return AVPROBE_SCORE_MAX/2+1;
644
    else if(max_frames>500)return AVPROBE_SCORE_MAX/2;
645
    else if(max_frames>=4) return AVPROBE_SCORE_MAX/4;
646
    else if(max_frames>=1) return 1;
647
    else                   return 0;
648
}
649
#endif
650

    
651
#if CONFIG_AC3_DEMUXER
652
static int ac3_probe(AVProbeData *p)
653
{
654
    return ac3_eac3_probe(p, CODEC_ID_AC3);
655
}
656
#endif
657

    
658
#if CONFIG_EAC3_DEMUXER
659
static int eac3_probe(AVProbeData *p)
660
{
661
    return ac3_eac3_probe(p, CODEC_ID_EAC3);
662
}
663
#endif
664

    
665
#if CONFIG_AAC_DEMUXER
666
static int adts_aac_probe(AVProbeData *p)
667
{
668
    int max_frames = 0, first_frames = 0;
669
    int fsize, frames;
670
    uint8_t *buf0 = p->buf;
671
    uint8_t *buf2;
672
    uint8_t *buf;
673
    uint8_t *end = buf0 + p->buf_size - 7;
674

    
675
    if (ff_id3v2_match(buf0, ID3v2_DEFAULT_MAGIC)) {
676
        buf0 += ff_id3v2_tag_len(buf0);
677
    }
678
    buf = buf0;
679

    
680
    for(; buf < end; buf= buf2+1) {
681
        buf2 = buf;
682

    
683
        for(frames = 0; buf2 < end; frames++) {
684
            uint32_t header = AV_RB16(buf2);
685
            if((header&0xFFF6) != 0xFFF0)
686
                break;
687
            fsize = (AV_RB32(buf2+3)>>13) & 0x8FFF;
688
            if(fsize < 7)
689
                break;
690
            buf2 += fsize;
691
        }
692
        max_frames = FFMAX(max_frames, frames);
693
        if(buf == buf0)
694
            first_frames= frames;
695
    }
696
    if   (first_frames>=3) return AVPROBE_SCORE_MAX/2+1;
697
    else if(max_frames>500)return AVPROBE_SCORE_MAX/2;
698
    else if(max_frames>=3) return AVPROBE_SCORE_MAX/4;
699
    else if(max_frames>=1) return 1;
700
    else                   return 0;
701
}
702

    
703
static int adts_aac_read_header(AVFormatContext *s,
704
                                AVFormatParameters *ap)
705
{
706
    AVStream *st;
707

    
708
    st = av_new_stream(s, 0);
709
    if (!st)
710
        return AVERROR(ENOMEM);
711

    
712
    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
713
    st->codec->codec_id = s->iformat->value;
714
    st->need_parsing = AVSTREAM_PARSE_FULL;
715

    
716
    ff_id3v1_read(s);
717
    ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
718

    
719
    return 0;
720
}
721

    
722
#endif
723

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

    
726
#if CONFIG_AAC_DEMUXER
727
AVInputFormat aac_demuxer = {
728
    "aac",
729
    NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
730
    0,
731
    adts_aac_probe,
732
    adts_aac_read_header,
733
    ff_raw_read_partial_packet,
734
    .flags= AVFMT_GENERIC_INDEX,
735
    .extensions = "aac",
736
    .value = CODEC_ID_AAC,
737
};
738
#endif
739

    
740
#if CONFIG_AC3_DEMUXER
741
AVInputFormat ac3_demuxer = {
742
    "ac3",
743
    NULL_IF_CONFIG_SMALL("raw AC-3"),
744
    0,
745
    ac3_probe,
746
    audio_read_header,
747
    ff_raw_read_partial_packet,
748
    .flags= AVFMT_GENERIC_INDEX,
749
    .extensions = "ac3",
750
    .value = CODEC_ID_AC3,
751
};
752
#endif
753

    
754
#if CONFIG_AC3_MUXER
755
AVOutputFormat ac3_muxer = {
756
    "ac3",
757
    NULL_IF_CONFIG_SMALL("raw AC-3"),
758
    "audio/x-ac3",
759
    "ac3",
760
    0,
761
    CODEC_ID_AC3,
762
    CODEC_ID_NONE,
763
    NULL,
764
    raw_write_packet,
765
    .flags= AVFMT_NOTIMESTAMPS,
766
};
767
#endif
768

    
769
#if CONFIG_DIRAC_DEMUXER
770
AVInputFormat dirac_demuxer = {
771
    "dirac",
772
    NULL_IF_CONFIG_SMALL("raw Dirac"),
773
    0,
774
    dirac_probe,
775
    video_read_header,
776
    ff_raw_read_partial_packet,
777
    .flags= AVFMT_GENERIC_INDEX,
778
    .value = CODEC_ID_DIRAC,
779
};
780
#endif
781

    
782
#if CONFIG_DIRAC_MUXER
783
AVOutputFormat dirac_muxer = {
784
    "dirac",
785
    NULL_IF_CONFIG_SMALL("raw Dirac"),
786
    NULL,
787
    "drc",
788
    0,
789
    CODEC_ID_NONE,
790
    CODEC_ID_DIRAC,
791
    NULL,
792
    raw_write_packet,
793
    .flags= AVFMT_NOTIMESTAMPS,
794
};
795
#endif
796

    
797
#if CONFIG_DNXHD_DEMUXER
798
AVInputFormat dnxhd_demuxer = {
799
    "dnxhd",
800
    NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
801
    0,
802
    dnxhd_probe,
803
    video_read_header,
804
    ff_raw_read_partial_packet,
805
    .flags= AVFMT_GENERIC_INDEX,
806
    .value = CODEC_ID_DNXHD,
807
};
808
#endif
809

    
810
#if CONFIG_DNXHD_MUXER
811
AVOutputFormat dnxhd_muxer = {
812
    "dnxhd",
813
    NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
814
    NULL,
815
    "dnxhd",
816
    0,
817
    CODEC_ID_NONE,
818
    CODEC_ID_DNXHD,
819
    NULL,
820
    raw_write_packet,
821
    .flags= AVFMT_NOTIMESTAMPS,
822
};
823
#endif
824

    
825
#if CONFIG_DTS_DEMUXER
826
AVInputFormat dts_demuxer = {
827
    "dts",
828
    NULL_IF_CONFIG_SMALL("raw DTS"),
829
    0,
830
    dts_probe,
831
    audio_read_header,
832
    ff_raw_read_partial_packet,
833
    .flags= AVFMT_GENERIC_INDEX,
834
    .extensions = "dts",
835
    .value = CODEC_ID_DTS,
836
};
837
#endif
838

    
839
#if CONFIG_DTS_MUXER
840
AVOutputFormat dts_muxer = {
841
    "dts",
842
    NULL_IF_CONFIG_SMALL("raw DTS"),
843
    "audio/x-dca",
844
    "dts",
845
    0,
846
    CODEC_ID_DTS,
847
    CODEC_ID_NONE,
848
    NULL,
849
    raw_write_packet,
850
    .flags= AVFMT_NOTIMESTAMPS,
851
};
852
#endif
853

    
854
#if CONFIG_EAC3_DEMUXER
855
AVInputFormat eac3_demuxer = {
856
    "eac3",
857
    NULL_IF_CONFIG_SMALL("raw E-AC-3"),
858
    0,
859
    eac3_probe,
860
    audio_read_header,
861
    ff_raw_read_partial_packet,
862
    .flags= AVFMT_GENERIC_INDEX,
863
    .extensions = "eac3",
864
    .value = CODEC_ID_EAC3,
865
};
866
#endif
867

    
868
#if CONFIG_EAC3_MUXER
869
AVOutputFormat eac3_muxer = {
870
    "eac3",
871
    NULL_IF_CONFIG_SMALL("raw E-AC-3"),
872
    "audio/x-eac3",
873
    "eac3",
874
    0,
875
    CODEC_ID_EAC3,
876
    CODEC_ID_NONE,
877
    NULL,
878
    raw_write_packet,
879
    .flags= AVFMT_NOTIMESTAMPS,
880
};
881
#endif
882

    
883
#if CONFIG_GSM_DEMUXER
884
AVInputFormat gsm_demuxer = {
885
    "gsm",
886
    NULL_IF_CONFIG_SMALL("raw GSM"),
887
    0,
888
    NULL,
889
    audio_read_header,
890
    ff_raw_read_partial_packet,
891
    .flags= AVFMT_GENERIC_INDEX,
892
    .extensions = "gsm",
893
    .value = CODEC_ID_GSM,
894
};
895
#endif
896

    
897
#if CONFIG_H261_DEMUXER
898
AVInputFormat h261_demuxer = {
899
    "h261",
900
    NULL_IF_CONFIG_SMALL("raw H.261"),
901
    0,
902
    h261_probe,
903
    video_read_header,
904
    ff_raw_read_partial_packet,
905
    .flags= AVFMT_GENERIC_INDEX,
906
    .extensions = "h261",
907
    .value = CODEC_ID_H261,
908
};
909
#endif
910

    
911
#if CONFIG_H261_MUXER
912
AVOutputFormat h261_muxer = {
913
    "h261",
914
    NULL_IF_CONFIG_SMALL("raw H.261"),
915
    "video/x-h261",
916
    "h261",
917
    0,
918
    CODEC_ID_NONE,
919
    CODEC_ID_H261,
920
    NULL,
921
    raw_write_packet,
922
    .flags= AVFMT_NOTIMESTAMPS,
923
};
924
#endif
925

    
926
#if CONFIG_H263_DEMUXER
927
AVInputFormat h263_demuxer = {
928
    "h263",
929
    NULL_IF_CONFIG_SMALL("raw H.263"),
930
    0,
931
    h263_probe,
932
    video_read_header,
933
    ff_raw_read_partial_packet,
934
    .flags= AVFMT_GENERIC_INDEX,
935
//    .extensions = "h263", //FIXME remove after writing mpeg4_probe
936
    .value = CODEC_ID_H263,
937
};
938
#endif
939

    
940
#if CONFIG_H263_MUXER
941
AVOutputFormat h263_muxer = {
942
    "h263",
943
    NULL_IF_CONFIG_SMALL("raw H.263"),
944
    "video/x-h263",
945
    "h263",
946
    0,
947
    CODEC_ID_NONE,
948
    CODEC_ID_H263,
949
    NULL,
950
    raw_write_packet,
951
    .flags= AVFMT_NOTIMESTAMPS,
952
};
953
#endif
954

    
955
#if CONFIG_H264_DEMUXER
956
AVInputFormat h264_demuxer = {
957
    "h264",
958
    NULL_IF_CONFIG_SMALL("raw H.264 video format"),
959
    0,
960
    h264_probe,
961
    video_read_header,
962
    ff_raw_read_partial_packet,
963
    .flags= AVFMT_GENERIC_INDEX,
964
    .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
965
    .value = CODEC_ID_H264,
966
};
967
#endif
968

    
969
#if CONFIG_H264_MUXER
970
AVOutputFormat h264_muxer = {
971
    "h264",
972
    NULL_IF_CONFIG_SMALL("raw H.264 video format"),
973
    NULL,
974
    "h264",
975
    0,
976
    CODEC_ID_NONE,
977
    CODEC_ID_H264,
978
    NULL,
979
    raw_write_packet,
980
    .flags= AVFMT_NOTIMESTAMPS,
981
};
982
#endif
983

    
984
#if CONFIG_INGENIENT_DEMUXER
985
AVInputFormat ingenient_demuxer = {
986
    "ingenient",
987
    NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
988
    0,
989
    NULL,
990
    video_read_header,
991
    ingenient_read_packet,
992
    .flags= AVFMT_GENERIC_INDEX,
993
    .extensions = "cgi", // FIXME
994
    .value = CODEC_ID_MJPEG,
995
};
996
#endif
997

    
998
#if CONFIG_M4V_DEMUXER
999
AVInputFormat m4v_demuxer = {
1000
    "m4v",
1001
    NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
1002
    0,
1003
    mpeg4video_probe, /** probing for MPEG-4 data */
1004
    video_read_header,
1005
    ff_raw_read_partial_packet,
1006
    .flags= AVFMT_GENERIC_INDEX,
1007
    .extensions = "m4v",
1008
    .value = CODEC_ID_MPEG4,
1009
};
1010
#endif
1011

    
1012
#if CONFIG_M4V_MUXER
1013
AVOutputFormat m4v_muxer = {
1014
    "m4v",
1015
    NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
1016
    NULL,
1017
    "m4v",
1018
    0,
1019
    CODEC_ID_NONE,
1020
    CODEC_ID_MPEG4,
1021
    NULL,
1022
    raw_write_packet,
1023
    .flags= AVFMT_NOTIMESTAMPS,
1024
};
1025
#endif
1026

    
1027
#if CONFIG_MJPEG_DEMUXER
1028
AVInputFormat mjpeg_demuxer = {
1029
    "mjpeg",
1030
    NULL_IF_CONFIG_SMALL("raw MJPEG video"),
1031
    0,
1032
    NULL,
1033
    video_read_header,
1034
    ff_raw_read_partial_packet,
1035
    .flags= AVFMT_GENERIC_INDEX,
1036
    .extensions = "mjpg,mjpeg",
1037
    .value = CODEC_ID_MJPEG,
1038
};
1039
#endif
1040

    
1041
#if CONFIG_MJPEG_MUXER
1042
AVOutputFormat mjpeg_muxer = {
1043
    "mjpeg",
1044
    NULL_IF_CONFIG_SMALL("raw MJPEG video"),
1045
    "video/x-mjpeg",
1046
    "mjpg,mjpeg",
1047
    0,
1048
    CODEC_ID_NONE,
1049
    CODEC_ID_MJPEG,
1050
    NULL,
1051
    raw_write_packet,
1052
    .flags= AVFMT_NOTIMESTAMPS,
1053
};
1054
#endif
1055

    
1056
#if CONFIG_MLP_DEMUXER
1057
AVInputFormat mlp_demuxer = {
1058
    "mlp",
1059
    NULL_IF_CONFIG_SMALL("raw MLP"),
1060
    0,
1061
    NULL,
1062
    audio_read_header,
1063
    ff_raw_read_partial_packet,
1064
    .flags= AVFMT_GENERIC_INDEX,
1065
    .extensions = "mlp",
1066
    .value = CODEC_ID_MLP,
1067
};
1068
#endif
1069

    
1070
#if CONFIG_MLP_MUXER
1071
AVOutputFormat mlp_muxer = {
1072
    "mlp",
1073
    NULL_IF_CONFIG_SMALL("raw MLP"),
1074
    NULL,
1075
    "mlp",
1076
    0,
1077
    CODEC_ID_MLP,
1078
    CODEC_ID_NONE,
1079
    NULL,
1080
    raw_write_packet,
1081
    .flags= AVFMT_NOTIMESTAMPS,
1082
};
1083
#endif
1084

    
1085
#if CONFIG_SRT_MUXER
1086
AVOutputFormat srt_muxer = {
1087
    .name           = "srt",
1088
    .long_name      = NULL_IF_CONFIG_SMALL("SubRip subtitle format"),
1089
    .mime_type      = "application/x-subrip",
1090
    .extensions     = "srt",
1091
    .write_packet   = raw_write_packet,
1092
    .flags          = AVFMT_NOTIMESTAMPS,
1093
    .subtitle_codec = CODEC_ID_SRT,
1094
};
1095
#endif
1096

    
1097
#if CONFIG_TRUEHD_DEMUXER
1098
AVInputFormat truehd_demuxer = {
1099
    "truehd",
1100
    NULL_IF_CONFIG_SMALL("raw TrueHD"),
1101
    0,
1102
    NULL,
1103
    audio_read_header,
1104
    ff_raw_read_partial_packet,
1105
    .flags= AVFMT_GENERIC_INDEX,
1106
    .extensions = "thd",
1107
    .value = CODEC_ID_TRUEHD,
1108
};
1109
#endif
1110

    
1111
#if CONFIG_TRUEHD_MUXER
1112
AVOutputFormat truehd_muxer = {
1113
    "truehd",
1114
    NULL_IF_CONFIG_SMALL("raw TrueHD"),
1115
    NULL,
1116
    "thd",
1117
    0,
1118
    CODEC_ID_TRUEHD,
1119
    CODEC_ID_NONE,
1120
    NULL,
1121
    raw_write_packet,
1122
    .flags= AVFMT_NOTIMESTAMPS,
1123
};
1124
#endif
1125

    
1126
#if CONFIG_MPEG1VIDEO_MUXER
1127
AVOutputFormat mpeg1video_muxer = {
1128
    "mpeg1video",
1129
    NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
1130
    "video/x-mpeg",
1131
    "mpg,mpeg,m1v",
1132
    0,
1133
    CODEC_ID_NONE,
1134
    CODEC_ID_MPEG1VIDEO,
1135
    NULL,
1136
    raw_write_packet,
1137
    .flags= AVFMT_NOTIMESTAMPS,
1138
};
1139
#endif
1140

    
1141
#if CONFIG_MPEG2VIDEO_MUXER
1142
AVOutputFormat mpeg2video_muxer = {
1143
    "mpeg2video",
1144
    NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
1145
    NULL,
1146
    "m2v",
1147
    0,
1148
    CODEC_ID_NONE,
1149
    CODEC_ID_MPEG2VIDEO,
1150
    NULL,
1151
    raw_write_packet,
1152
    .flags= AVFMT_NOTIMESTAMPS,
1153
};
1154
#endif
1155

    
1156
#if CONFIG_MPEGVIDEO_DEMUXER
1157
AVInputFormat mpegvideo_demuxer = {
1158
    "mpegvideo",
1159
    NULL_IF_CONFIG_SMALL("raw MPEG video"),
1160
    0,
1161
    mpegvideo_probe,
1162
    video_read_header,
1163
    ff_raw_read_partial_packet,
1164
    .flags= AVFMT_GENERIC_INDEX,
1165
    .value = CODEC_ID_MPEG1VIDEO,
1166
};
1167
#endif
1168

    
1169
#if CONFIG_CAVSVIDEO_DEMUXER
1170
AVInputFormat cavsvideo_demuxer = {
1171
    "cavsvideo",
1172
    NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
1173
    0,
1174
    cavsvideo_probe,
1175
    video_read_header,
1176
    ff_raw_read_partial_packet,
1177
    .flags= AVFMT_GENERIC_INDEX,
1178
    .value = CODEC_ID_CAVS,
1179
};
1180
#endif
1181

    
1182
#if CONFIG_NULL_MUXER
1183
AVOutputFormat null_muxer = {
1184
    "null",
1185
    NULL_IF_CONFIG_SMALL("raw null video format"),
1186
    NULL,
1187
    NULL,
1188
    0,
1189
#if HAVE_BIGENDIAN
1190
    CODEC_ID_PCM_S16BE,
1191
#else
1192
    CODEC_ID_PCM_S16LE,
1193
#endif
1194
    CODEC_ID_RAWVIDEO,
1195
    NULL,
1196
    null_write_packet,
1197
    .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
1198
};
1199
#endif
1200

    
1201
#if CONFIG_RAWVIDEO_DEMUXER
1202
AVInputFormat rawvideo_demuxer = {
1203
    "rawvideo",
1204
    NULL_IF_CONFIG_SMALL("raw video format"),
1205
    0,
1206
    NULL,
1207
    raw_read_header,
1208
    rawvideo_read_packet,
1209
    .flags= AVFMT_GENERIC_INDEX,
1210
    .extensions = "yuv,cif,qcif,rgb",
1211
    .value = CODEC_ID_RAWVIDEO,
1212
};
1213
#endif
1214

    
1215
#if CONFIG_RAWVIDEO_MUXER
1216
AVOutputFormat rawvideo_muxer = {
1217
    "rawvideo",
1218
    NULL_IF_CONFIG_SMALL("raw video format"),
1219
    NULL,
1220
    "yuv,rgb",
1221
    0,
1222
    CODEC_ID_NONE,
1223
    CODEC_ID_RAWVIDEO,
1224
    NULL,
1225
    raw_write_packet,
1226
    .flags= AVFMT_NOTIMESTAMPS,
1227
};
1228
#endif
1229

    
1230
#if CONFIG_ROQ_MUXER
1231
AVOutputFormat roq_muxer =
1232
{
1233
    "RoQ",
1234
    NULL_IF_CONFIG_SMALL("raw id RoQ format"),
1235
    NULL,
1236
    "roq",
1237
    0,
1238
    CODEC_ID_ROQ_DPCM,
1239
    CODEC_ID_ROQ,
1240
    roq_write_header,
1241
    raw_write_packet,
1242
};
1243
#endif
1244

    
1245
#if CONFIG_SHORTEN_DEMUXER
1246
AVInputFormat shorten_demuxer = {
1247
    "shn",
1248
    NULL_IF_CONFIG_SMALL("raw Shorten"),
1249
    0,
1250
    NULL,
1251
    audio_read_header,
1252
    ff_raw_read_partial_packet,
1253
    .flags= AVFMT_GENERIC_INDEX,
1254
    .extensions = "shn",
1255
    .value = CODEC_ID_SHORTEN,
1256
};
1257
#endif
1258

    
1259
#if CONFIG_VC1_DEMUXER
1260
AVInputFormat vc1_demuxer = {
1261
    "vc1",
1262
    NULL_IF_CONFIG_SMALL("raw VC-1"),
1263
    0,
1264
    NULL /* vc1_probe */,
1265
    video_read_header,
1266
    ff_raw_read_partial_packet,
1267
    .extensions = "vc1",
1268
    .value = CODEC_ID_VC1,
1269
};
1270
#endif
1271

    
1272
/* PCM formats */
1273

    
1274
#define PCMINPUTDEF(name, long_name, ext, codec) \
1275
AVInputFormat pcm_ ## name ## _demuxer = {\
1276
    #name,\
1277
    NULL_IF_CONFIG_SMALL(long_name),\
1278
    0,\
1279
    NULL,\
1280
    raw_read_header,\
1281
    raw_read_packet,\
1282
    NULL,\
1283
    pcm_read_seek,\
1284
    .flags= AVFMT_GENERIC_INDEX,\
1285
    .extensions = ext,\
1286
    .value = codec,\
1287
};
1288

    
1289
#define PCMOUTPUTDEF(name, long_name, ext, codec) \
1290
AVOutputFormat pcm_ ## name ## _muxer = {\
1291
    #name,\
1292
    NULL_IF_CONFIG_SMALL(long_name),\
1293
    NULL,\
1294
    ext,\
1295
    0,\
1296
    codec,\
1297
    CODEC_ID_NONE,\
1298
    NULL,\
1299
    raw_write_packet,\
1300
    .flags= AVFMT_NOTIMESTAMPS,\
1301
};
1302

    
1303

    
1304
#if  !CONFIG_MUXERS && CONFIG_DEMUXERS
1305
#define PCMDEF(name, long_name, ext, codec) \
1306
        PCMINPUTDEF(name, long_name, ext, codec)
1307
#elif CONFIG_MUXERS && !CONFIG_DEMUXERS
1308
#define PCMDEF(name, long_name, ext, codec) \
1309
        PCMOUTPUTDEF(name, long_name, ext, codec)
1310
#elif CONFIG_MUXERS && CONFIG_DEMUXERS
1311
#define PCMDEF(name, long_name, ext, codec) \
1312
        PCMINPUTDEF(name, long_name, ext, codec)\
1313
        PCMOUTPUTDEF(name, long_name, ext, codec)
1314
#else
1315
#define PCMDEF(name, long_name, ext, codec)
1316
#endif
1317

    
1318
#if HAVE_BIGENDIAN
1319
#define BE_DEF(s) s
1320
#define LE_DEF(s) NULL
1321
#else
1322
#define BE_DEF(s) NULL
1323
#define LE_DEF(s) s
1324
#endif
1325

    
1326
PCMDEF(f64be, "PCM 64 bit floating-point big-endian format",
1327
       NULL, CODEC_ID_PCM_F64BE)
1328

    
1329
PCMDEF(f64le, "PCM 64 bit floating-point little-endian format",
1330
       NULL, CODEC_ID_PCM_F64LE)
1331

    
1332
PCMDEF(f32be, "PCM 32 bit floating-point big-endian format",
1333
       NULL, CODEC_ID_PCM_F32BE)
1334

    
1335
PCMDEF(f32le, "PCM 32 bit floating-point little-endian format",
1336
       NULL, CODEC_ID_PCM_F32LE)
1337

    
1338
PCMDEF(s32be, "PCM signed 32 bit big-endian format",
1339
       NULL, CODEC_ID_PCM_S32BE)
1340

    
1341
PCMDEF(s32le, "PCM signed 32 bit little-endian format",
1342
       NULL, CODEC_ID_PCM_S32LE)
1343

    
1344
PCMDEF(s24be, "PCM signed 24 bit big-endian format",
1345
       NULL, CODEC_ID_PCM_S24BE)
1346

    
1347
PCMDEF(s24le, "PCM signed 24 bit little-endian format",
1348
       NULL, CODEC_ID_PCM_S24LE)
1349

    
1350
PCMDEF(s16be, "PCM signed 16 bit big-endian format",
1351
       BE_DEF("sw"), CODEC_ID_PCM_S16BE)
1352

    
1353
PCMDEF(s16le, "PCM signed 16 bit little-endian format",
1354
       LE_DEF("sw"), CODEC_ID_PCM_S16LE)
1355

    
1356
PCMDEF(s8, "PCM signed 8 bit format",
1357
       "sb", CODEC_ID_PCM_S8)
1358

    
1359
PCMDEF(u32be, "PCM unsigned 32 bit big-endian format",
1360
       NULL, CODEC_ID_PCM_U32BE)
1361

    
1362
PCMDEF(u32le, "PCM unsigned 32 bit little-endian format",
1363
       NULL, CODEC_ID_PCM_U32LE)
1364

    
1365
PCMDEF(u24be, "PCM unsigned 24 bit big-endian format",
1366
       NULL, CODEC_ID_PCM_U24BE)
1367

    
1368
PCMDEF(u24le, "PCM unsigned 24 bit little-endian format",
1369
       NULL, CODEC_ID_PCM_U24LE)
1370

    
1371
PCMDEF(u16be, "PCM unsigned 16 bit big-endian format",
1372
       BE_DEF("uw"), CODEC_ID_PCM_U16BE)
1373

    
1374
PCMDEF(u16le, "PCM unsigned 16 bit little-endian format",
1375
       LE_DEF("uw"), CODEC_ID_PCM_U16LE)
1376

    
1377
PCMDEF(u8, "PCM unsigned 8 bit format",
1378
       "ub", CODEC_ID_PCM_U8)
1379

    
1380
PCMDEF(alaw, "PCM A-law format",
1381
       "al", CODEC_ID_PCM_ALAW)
1382

    
1383
PCMDEF(mulaw, "PCM mu-law format",
1384
       "ul", CODEC_ID_PCM_MULAW)