Statistics
| Branch: | Revision:

ffmpeg / libavformat / raw.c @ 9106a698

History | View | Annotate | Download (30 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

    
31
/* simple formats */
32

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

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

    
43
    return 0;
44
}
45
#endif
46

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

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

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

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

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

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

    
109
#define RAW_PACKET_SIZE 1024
110
#define RAW_SAMPLES     1024
111

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

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

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

    
121
    pkt->stream_index = 0;
122
    if (ret <= 0) {
123
        return AVERROR(EIO);
124
    }
125
    /* note: we need to modify the packet size here to handle the last
126
       packet */
127
    pkt->size = ret;
128

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

    
134
    return ret;
135
}
136

    
137
int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
138
{
139
    int ret, size;
140

    
141
    size = RAW_PACKET_SIZE;
142

    
143
    if (av_new_packet(pkt, size) < 0)
144
        return AVERROR(EIO);
145

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

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

    
164
    width = st->codec->width;
165
    height = st->codec->height;
166

    
167
    packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
168
    if (packet_size < 0)
169
        return -1;
170

    
171
    ret= av_get_packet(s->pb, pkt, packet_size);
172
    pkt->pts=
173
    pkt->dts= pkt->pos / packet_size;
174

    
175
    pkt->stream_index = 0;
176
    if (ret != packet_size) {
177
        return AVERROR(EIO);
178
    } else {
179
        return 0;
180
    }
181
}
182
#endif
183

    
184
#if CONFIG_INGENIENT_DEMUXER
185
// http://www.artificis.hu/files/texts/ingenient.txt
186
static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
187
{
188
    int ret, size, w, h, unk1, unk2;
189

    
190
    if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))
191
        return AVERROR(EIO); // FIXME
192

    
193
    size = get_le32(s->pb);
194

    
195
    w = get_le16(s->pb);
196
    h = get_le16(s->pb);
197

    
198
    url_fskip(s->pb, 8); // zero + size (padded?)
199
    url_fskip(s->pb, 2);
200
    unk1 = get_le16(s->pb);
201
    unk2 = get_le16(s->pb);
202
    url_fskip(s->pb, 22); // ASCII timestamp
203

    
204
    av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
205
        size, w, h, unk1, unk2);
206

    
207
    if (av_new_packet(pkt, size) < 0)
208
        return AVERROR(EIO);
209

    
210
    pkt->pos = url_ftell(s->pb);
211
    pkt->stream_index = 0;
212
    ret = get_buffer(s->pb, pkt->data, size);
213
    if (ret <= 0) {
214
        av_free_packet(pkt);
215
        return AVERROR(EIO);
216
    }
217
    pkt->size = ret;
218
    return ret;
219
}
220
#endif
221

    
222
#if CONFIG_DEMUXERS
223
int pcm_read_seek(AVFormatContext *s,
224
                  int stream_index, int64_t timestamp, int flags)
225
{
226
    AVStream *st;
227
    int block_align, byte_rate, ret;
228
    int64_t pos;
229

    
230
    st = s->streams[0];
231

    
232
    block_align = st->codec->block_align ? st->codec->block_align :
233
        (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
234
    byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :
235
        block_align * st->codec->sample_rate;
236

    
237
    if (block_align <= 0 || byte_rate <= 0)
238
        return -1;
239
    if (timestamp < 0) timestamp = 0;
240

    
241
    /* compute the position by aligning it to block_align */
242
    pos = av_rescale_rnd(timestamp * byte_rate,
243
                         st->time_base.num,
244
                         st->time_base.den * (int64_t)block_align,
245
                         (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
246
    pos *= block_align;
247

    
248
    /* recompute exact position */
249
    st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
250
    if ((ret = url_fseek(s->pb, pos + s->data_offset, SEEK_SET)) < 0)
251
        return ret;
252
    return 0;
253
}
254

    
255
static int audio_read_header(AVFormatContext *s,
256
                             AVFormatParameters *ap)
257
{
258
    AVStream *st = av_new_stream(s, 0);
259
    if (!st)
260
        return AVERROR(ENOMEM);
261
    st->codec->codec_type = CODEC_TYPE_AUDIO;
262
    st->codec->codec_id = s->iformat->value;
263
    st->need_parsing = AVSTREAM_PARSE_FULL;
264
    /* the parameters will be extracted from the compressed bitstream */
265

    
266
    return 0;
267
}
268

    
269
/* MPEG-1/H.263 input */
270
static int video_read_header(AVFormatContext *s,
271
                             AVFormatParameters *ap)
272
{
273
    AVStream *st;
274

    
275
    st = av_new_stream(s, 0);
276
    if (!st)
277
        return AVERROR(ENOMEM);
278

    
279
    st->codec->codec_type = CODEC_TYPE_VIDEO;
280
    st->codec->codec_id = s->iformat->value;
281
    st->need_parsing = AVSTREAM_PARSE_FULL;
282

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

    
295
    return 0;
296
}
297
#endif
298

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
452
#if CONFIG_H263_DEMUXER
453
static int h263_probe(AVProbeData *p)
454
{
455
    int code;
456
    const uint8_t *d;
457

    
458
    d = p->buf;
459
    code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
460
    if (code == 0x20) {
461
        return 50;
462
    }
463
    return 0;
464
}
465
#endif
466

    
467
#if CONFIG_H261_DEMUXER
468
static int h261_probe(AVProbeData *p)
469
{
470
    int code;
471
    const uint8_t *d;
472

    
473
    d = p->buf;
474
    code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
475
    if (code == 0x10) {
476
        return 50;
477
    }
478
    return 0;
479
}
480
#endif
481

    
482
#if CONFIG_DTS_DEMUXER
483
#define DCA_MARKER_14B_BE 0x1FFFE800
484
#define DCA_MARKER_14B_LE 0xFF1F00E8
485
#define DCA_MARKER_RAW_BE 0x7FFE8001
486
#define DCA_MARKER_RAW_LE 0xFE7F0180
487
static int dts_probe(AVProbeData *p)
488
{
489
    const uint8_t *buf, *bufp;
490
    uint32_t state = -1;
491

    
492
    buf = p->buf;
493

    
494
    for(; buf < (p->buf+p->buf_size)-2; buf+=2) {
495
        bufp = buf;
496
        state = (state << 16) | bytestream_get_be16(&bufp);
497

    
498
        /* regular bitstream */
499
        if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)
500
            return AVPROBE_SCORE_MAX/2+1;
501

    
502
        /* 14 bits big-endian bitstream */
503
        if (state == DCA_MARKER_14B_BE)
504
            if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)
505
                return AVPROBE_SCORE_MAX/2+1;
506

    
507
        /* 14 bits little-endian bitstream */
508
        if (state == DCA_MARKER_14B_LE)
509
            if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)
510
                return AVPROBE_SCORE_MAX/2+1;
511
    }
512

    
513
    return 0;
514
}
515
#endif
516

    
517
#if CONFIG_DIRAC_DEMUXER
518
static int dirac_probe(AVProbeData *p)
519
{
520
    if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
521
        return AVPROBE_SCORE_MAX;
522
    else
523
        return 0;
524
}
525
#endif
526

    
527
#if CONFIG_DNXHD_DEMUXER
528
static int dnxhd_probe(AVProbeData *p)
529
{
530
    static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01};
531
    if (!memcmp(p->buf, header, 5))
532
        return AVPROBE_SCORE_MAX;
533
    else
534
        return 0;
535
}
536
#endif
537

    
538
#if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER
539
static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id)
540
{
541
    int max_frames, first_frames = 0, frames;
542
    uint8_t *buf, *buf2, *end;
543
    AC3HeaderInfo hdr;
544
    GetBitContext gbc;
545
    enum CodecID codec_id = CODEC_ID_AC3;
546

    
547
    max_frames = 0;
548
    buf = p->buf;
549
    end = buf + p->buf_size;
550

    
551
    for(; buf < end; buf++) {
552
        buf2 = buf;
553

    
554
        for(frames = 0; buf2 < end; frames++) {
555
            init_get_bits(&gbc, buf2, 54);
556
            if(ff_ac3_parse_header(&gbc, &hdr) < 0)
557
                break;
558
            if(buf2 + hdr.frame_size > end ||
559
               av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))
560
                break;
561
            if (hdr.bitstream_id > 10)
562
                codec_id = CODEC_ID_EAC3;
563
            buf2 += hdr.frame_size;
564
        }
565
        max_frames = FFMAX(max_frames, frames);
566
        if(buf == p->buf)
567
            first_frames = frames;
568
    }
569
    if(codec_id != expected_codec_id) return 0;
570
    if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
571
    else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
572
    else if(max_frames>=1) return 1;
573
    else                   return 0;
574
}
575
#endif
576

    
577
#if CONFIG_AC3_DEMUXER
578
static int ac3_probe(AVProbeData *p)
579
{
580
    return ac3_eac3_probe(p, CODEC_ID_AC3);
581
}
582
#endif
583

    
584
#if CONFIG_EAC3_DEMUXER
585
static int eac3_probe(AVProbeData *p)
586
{
587
    return ac3_eac3_probe(p, CODEC_ID_EAC3);
588
}
589
#endif
590

    
591
#if CONFIG_AAC_DEMUXER
592
static int adts_aac_probe(AVProbeData *p)
593
{
594
    int max_frames = 0, first_frames = 0;
595
    int fsize, frames;
596
    uint8_t *buf0 = p->buf;
597
    uint8_t *buf2;
598
    uint8_t *buf;
599
    uint8_t *end = buf0 + p->buf_size - 7;
600

    
601
    if (ff_id3v2_match(buf0)) {
602
        buf0 += ff_id3v2_tag_len(buf0);
603
    }
604
    buf = buf0;
605

    
606
    for(; buf < end; buf= buf2+1) {
607
        buf2 = buf;
608

    
609
        for(frames = 0; buf2 < end; frames++) {
610
            uint32_t header = AV_RB16(buf2);
611
            if((header&0xFFF6) != 0xFFF0)
612
                break;
613
            fsize = (AV_RB32(buf2+3)>>13) & 0x8FFF;
614
            if(fsize < 7)
615
                break;
616
            buf2 += fsize;
617
        }
618
        max_frames = FFMAX(max_frames, frames);
619
        if(buf == buf0)
620
            first_frames= frames;
621
    }
622
    if   (first_frames>=3) return AVPROBE_SCORE_MAX/2+1;
623
    else if(max_frames>500)return AVPROBE_SCORE_MAX/2;
624
    else if(max_frames>=3) return AVPROBE_SCORE_MAX/4;
625
    else if(max_frames>=1) return 1;
626
    else                   return 0;
627
}
628
#endif
629

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

    
632
#if CONFIG_AAC_DEMUXER
633
AVInputFormat aac_demuxer = {
634
    "aac",
635
    NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
636
    0,
637
    adts_aac_probe,
638
    audio_read_header,
639
    ff_raw_read_partial_packet,
640
    .flags= AVFMT_GENERIC_INDEX,
641
    .extensions = "aac",
642
    .value = CODEC_ID_AAC,
643
};
644
#endif
645

    
646
#if CONFIG_AC3_DEMUXER
647
AVInputFormat ac3_demuxer = {
648
    "ac3",
649
    NULL_IF_CONFIG_SMALL("raw AC-3"),
650
    0,
651
    ac3_probe,
652
    audio_read_header,
653
    ff_raw_read_partial_packet,
654
    .flags= AVFMT_GENERIC_INDEX,
655
    .extensions = "ac3",
656
    .value = CODEC_ID_AC3,
657
};
658
#endif
659

    
660
#if CONFIG_AC3_MUXER
661
AVOutputFormat ac3_muxer = {
662
    "ac3",
663
    NULL_IF_CONFIG_SMALL("raw AC-3"),
664
    "audio/x-ac3",
665
    "ac3",
666
    0,
667
    CODEC_ID_AC3,
668
    CODEC_ID_NONE,
669
    NULL,
670
    raw_write_packet,
671
    .flags= AVFMT_NOTIMESTAMPS,
672
};
673
#endif
674

    
675
#if CONFIG_DIRAC_DEMUXER
676
AVInputFormat dirac_demuxer = {
677
    "dirac",
678
    NULL_IF_CONFIG_SMALL("raw Dirac"),
679
    0,
680
    dirac_probe,
681
    video_read_header,
682
    ff_raw_read_partial_packet,
683
    .flags= AVFMT_GENERIC_INDEX,
684
    .value = CODEC_ID_DIRAC,
685
};
686
#endif
687

    
688
#if CONFIG_DIRAC_MUXER
689
AVOutputFormat dirac_muxer = {
690
    "dirac",
691
    NULL_IF_CONFIG_SMALL("raw Dirac"),
692
    NULL,
693
    "drc",
694
    0,
695
    CODEC_ID_NONE,
696
    CODEC_ID_DIRAC,
697
    NULL,
698
    raw_write_packet,
699
    .flags= AVFMT_NOTIMESTAMPS,
700
};
701
#endif
702

    
703
#if CONFIG_DNXHD_DEMUXER
704
AVInputFormat dnxhd_demuxer = {
705
    "dnxhd",
706
    NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
707
    0,
708
    dnxhd_probe,
709
    video_read_header,
710
    ff_raw_read_partial_packet,
711
    .flags= AVFMT_GENERIC_INDEX,
712
    .value = CODEC_ID_DNXHD,
713
};
714
#endif
715

    
716
#if CONFIG_DNXHD_MUXER
717
AVOutputFormat dnxhd_muxer = {
718
    "dnxhd",
719
    NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
720
    NULL,
721
    "dnxhd",
722
    0,
723
    CODEC_ID_NONE,
724
    CODEC_ID_DNXHD,
725
    NULL,
726
    raw_write_packet,
727
    .flags= AVFMT_NOTIMESTAMPS,
728
};
729
#endif
730

    
731
#if CONFIG_DTS_DEMUXER
732
AVInputFormat dts_demuxer = {
733
    "dts",
734
    NULL_IF_CONFIG_SMALL("raw DTS"),
735
    0,
736
    dts_probe,
737
    audio_read_header,
738
    ff_raw_read_partial_packet,
739
    .flags= AVFMT_GENERIC_INDEX,
740
    .extensions = "dts",
741
    .value = CODEC_ID_DTS,
742
};
743
#endif
744

    
745
#if CONFIG_DTS_MUXER
746
AVOutputFormat dts_muxer = {
747
    "dts",
748
    NULL_IF_CONFIG_SMALL("raw DTS"),
749
    "audio/x-dca",
750
    "dts",
751
    0,
752
    CODEC_ID_DTS,
753
    CODEC_ID_NONE,
754
    NULL,
755
    raw_write_packet,
756
    .flags= AVFMT_NOTIMESTAMPS,
757
};
758
#endif
759

    
760
#if CONFIG_EAC3_DEMUXER
761
AVInputFormat eac3_demuxer = {
762
    "eac3",
763
    NULL_IF_CONFIG_SMALL("raw E-AC-3"),
764
    0,
765
    eac3_probe,
766
    audio_read_header,
767
    ff_raw_read_partial_packet,
768
    .flags= AVFMT_GENERIC_INDEX,
769
    .extensions = "eac3",
770
    .value = CODEC_ID_EAC3,
771
};
772
#endif
773

    
774
#if CONFIG_EAC3_MUXER
775
AVOutputFormat eac3_muxer = {
776
    "eac3",
777
    NULL_IF_CONFIG_SMALL("raw E-AC-3"),
778
    "audio/x-eac3",
779
    "eac3",
780
    0,
781
    CODEC_ID_EAC3,
782
    CODEC_ID_NONE,
783
    NULL,
784
    raw_write_packet,
785
    .flags= AVFMT_NOTIMESTAMPS,
786
};
787
#endif
788

    
789
#if CONFIG_GSM_DEMUXER
790
AVInputFormat gsm_demuxer = {
791
    "gsm",
792
    NULL_IF_CONFIG_SMALL("raw GSM"),
793
    0,
794
    NULL,
795
    audio_read_header,
796
    ff_raw_read_partial_packet,
797
    .flags= AVFMT_GENERIC_INDEX,
798
    .extensions = "gsm",
799
    .value = CODEC_ID_GSM,
800
};
801
#endif
802

    
803
#if CONFIG_H261_DEMUXER
804
AVInputFormat h261_demuxer = {
805
    "h261",
806
    NULL_IF_CONFIG_SMALL("raw H.261"),
807
    0,
808
    h261_probe,
809
    video_read_header,
810
    ff_raw_read_partial_packet,
811
    .flags= AVFMT_GENERIC_INDEX,
812
    .extensions = "h261",
813
    .value = CODEC_ID_H261,
814
};
815
#endif
816

    
817
#if CONFIG_H261_MUXER
818
AVOutputFormat h261_muxer = {
819
    "h261",
820
    NULL_IF_CONFIG_SMALL("raw H.261"),
821
    "video/x-h261",
822
    "h261",
823
    0,
824
    CODEC_ID_NONE,
825
    CODEC_ID_H261,
826
    NULL,
827
    raw_write_packet,
828
    .flags= AVFMT_NOTIMESTAMPS,
829
};
830
#endif
831

    
832
#if CONFIG_H263_DEMUXER
833
AVInputFormat h263_demuxer = {
834
    "h263",
835
    NULL_IF_CONFIG_SMALL("raw H.263"),
836
    0,
837
    h263_probe,
838
    video_read_header,
839
    ff_raw_read_partial_packet,
840
    .flags= AVFMT_GENERIC_INDEX,
841
//    .extensions = "h263", //FIXME remove after writing mpeg4_probe
842
    .value = CODEC_ID_H263,
843
};
844
#endif
845

    
846
#if CONFIG_H263_MUXER
847
AVOutputFormat h263_muxer = {
848
    "h263",
849
    NULL_IF_CONFIG_SMALL("raw H.263"),
850
    "video/x-h263",
851
    "h263",
852
    0,
853
    CODEC_ID_NONE,
854
    CODEC_ID_H263,
855
    NULL,
856
    raw_write_packet,
857
    .flags= AVFMT_NOTIMESTAMPS,
858
};
859
#endif
860

    
861
#if CONFIG_H264_DEMUXER
862
AVInputFormat h264_demuxer = {
863
    "h264",
864
    NULL_IF_CONFIG_SMALL("raw H.264 video format"),
865
    0,
866
    h264_probe,
867
    video_read_header,
868
    ff_raw_read_partial_packet,
869
    .flags= AVFMT_GENERIC_INDEX,
870
    .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
871
    .value = CODEC_ID_H264,
872
};
873
#endif
874

    
875
#if CONFIG_H264_MUXER
876
AVOutputFormat h264_muxer = {
877
    "h264",
878
    NULL_IF_CONFIG_SMALL("raw H.264 video format"),
879
    NULL,
880
    "h264",
881
    0,
882
    CODEC_ID_NONE,
883
    CODEC_ID_H264,
884
    NULL,
885
    raw_write_packet,
886
    .flags= AVFMT_NOTIMESTAMPS,
887
};
888
#endif
889

    
890
#if CONFIG_INGENIENT_DEMUXER
891
AVInputFormat ingenient_demuxer = {
892
    "ingenient",
893
    NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
894
    0,
895
    NULL,
896
    video_read_header,
897
    ingenient_read_packet,
898
    .flags= AVFMT_GENERIC_INDEX,
899
    .extensions = "cgi", // FIXME
900
    .value = CODEC_ID_MJPEG,
901
};
902
#endif
903

    
904
#if CONFIG_M4V_DEMUXER
905
AVInputFormat m4v_demuxer = {
906
    "m4v",
907
    NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
908
    0,
909
    mpeg4video_probe, /** probing for MPEG-4 data */
910
    video_read_header,
911
    ff_raw_read_partial_packet,
912
    .flags= AVFMT_GENERIC_INDEX,
913
    .extensions = "m4v",
914
    .value = CODEC_ID_MPEG4,
915
};
916
#endif
917

    
918
#if CONFIG_M4V_MUXER
919
AVOutputFormat m4v_muxer = {
920
    "m4v",
921
    NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
922
    NULL,
923
    "m4v",
924
    0,
925
    CODEC_ID_NONE,
926
    CODEC_ID_MPEG4,
927
    NULL,
928
    raw_write_packet,
929
    .flags= AVFMT_NOTIMESTAMPS,
930
};
931
#endif
932

    
933
#if CONFIG_MJPEG_DEMUXER
934
AVInputFormat mjpeg_demuxer = {
935
    "mjpeg",
936
    NULL_IF_CONFIG_SMALL("raw MJPEG video"),
937
    0,
938
    NULL,
939
    video_read_header,
940
    ff_raw_read_partial_packet,
941
    .flags= AVFMT_GENERIC_INDEX,
942
    .extensions = "mjpg,mjpeg",
943
    .value = CODEC_ID_MJPEG,
944
};
945
#endif
946

    
947
#if CONFIG_MJPEG_MUXER
948
AVOutputFormat mjpeg_muxer = {
949
    "mjpeg",
950
    NULL_IF_CONFIG_SMALL("raw MJPEG video"),
951
    "video/x-mjpeg",
952
    "mjpg,mjpeg",
953
    0,
954
    CODEC_ID_NONE,
955
    CODEC_ID_MJPEG,
956
    NULL,
957
    raw_write_packet,
958
    .flags= AVFMT_NOTIMESTAMPS,
959
};
960
#endif
961

    
962
#if CONFIG_MLP_DEMUXER
963
AVInputFormat mlp_demuxer = {
964
    "mlp",
965
    NULL_IF_CONFIG_SMALL("raw MLP"),
966
    0,
967
    NULL,
968
    audio_read_header,
969
    ff_raw_read_partial_packet,
970
    .flags= AVFMT_GENERIC_INDEX,
971
    .extensions = "mlp",
972
    .value = CODEC_ID_MLP,
973
};
974
#endif
975

    
976
#if CONFIG_TRUEHD_DEMUXER
977
AVInputFormat truehd_demuxer = {
978
    "truehd",
979
    NULL_IF_CONFIG_SMALL("raw TrueHD"),
980
    0,
981
    NULL,
982
    audio_read_header,
983
    ff_raw_read_partial_packet,
984
    .flags= AVFMT_GENERIC_INDEX,
985
    .extensions = "thd",
986
    .value = CODEC_ID_TRUEHD,
987
};
988
#endif
989

    
990
#if CONFIG_TRUEHD_MUXER
991
AVOutputFormat truehd_muxer = {
992
    "truehd",
993
    NULL_IF_CONFIG_SMALL("raw TrueHD"),
994
    NULL,
995
    "thd",
996
    0,
997
    CODEC_ID_TRUEHD,
998
    CODEC_ID_NONE,
999
    NULL,
1000
    raw_write_packet,
1001
    .flags= AVFMT_NOTIMESTAMPS,
1002
};
1003
#endif
1004

    
1005
#if CONFIG_MPEG1VIDEO_MUXER
1006
AVOutputFormat mpeg1video_muxer = {
1007
    "mpeg1video",
1008
    NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
1009
    "video/x-mpeg",
1010
    "mpg,mpeg,m1v",
1011
    0,
1012
    CODEC_ID_NONE,
1013
    CODEC_ID_MPEG1VIDEO,
1014
    NULL,
1015
    raw_write_packet,
1016
    .flags= AVFMT_NOTIMESTAMPS,
1017
};
1018
#endif
1019

    
1020
#if CONFIG_MPEG2VIDEO_MUXER
1021
AVOutputFormat mpeg2video_muxer = {
1022
    "mpeg2video",
1023
    NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
1024
    NULL,
1025
    "m2v",
1026
    0,
1027
    CODEC_ID_NONE,
1028
    CODEC_ID_MPEG2VIDEO,
1029
    NULL,
1030
    raw_write_packet,
1031
    .flags= AVFMT_NOTIMESTAMPS,
1032
};
1033
#endif
1034

    
1035
#if CONFIG_MPEGVIDEO_DEMUXER
1036
AVInputFormat mpegvideo_demuxer = {
1037
    "mpegvideo",
1038
    NULL_IF_CONFIG_SMALL("raw MPEG video"),
1039
    0,
1040
    mpegvideo_probe,
1041
    video_read_header,
1042
    ff_raw_read_partial_packet,
1043
    .flags= AVFMT_GENERIC_INDEX,
1044
    .value = CODEC_ID_MPEG1VIDEO,
1045
};
1046
#endif
1047

    
1048
#if CONFIG_CAVSVIDEO_DEMUXER
1049
AVInputFormat cavsvideo_demuxer = {
1050
    "cavsvideo",
1051
    NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
1052
    0,
1053
    cavsvideo_probe,
1054
    video_read_header,
1055
    ff_raw_read_partial_packet,
1056
    .flags= AVFMT_GENERIC_INDEX,
1057
    .value = CODEC_ID_CAVS,
1058
};
1059
#endif
1060

    
1061
#if CONFIG_NULL_MUXER
1062
AVOutputFormat null_muxer = {
1063
    "null",
1064
    NULL_IF_CONFIG_SMALL("raw null video format"),
1065
    NULL,
1066
    NULL,
1067
    0,
1068
#ifdef WORDS_BIGENDIAN
1069
    CODEC_ID_PCM_S16BE,
1070
#else
1071
    CODEC_ID_PCM_S16LE,
1072
#endif
1073
    CODEC_ID_RAWVIDEO,
1074
    NULL,
1075
    null_write_packet,
1076
    .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
1077
};
1078
#endif
1079

    
1080
#if CONFIG_RAWVIDEO_DEMUXER
1081
AVInputFormat rawvideo_demuxer = {
1082
    "rawvideo",
1083
    NULL_IF_CONFIG_SMALL("raw video format"),
1084
    0,
1085
    NULL,
1086
    raw_read_header,
1087
    rawvideo_read_packet,
1088
    .flags= AVFMT_GENERIC_INDEX,
1089
    .extensions = "yuv,cif,qcif,rgb",
1090
    .value = CODEC_ID_RAWVIDEO,
1091
};
1092
#endif
1093

    
1094
#if CONFIG_RAWVIDEO_MUXER
1095
AVOutputFormat rawvideo_muxer = {
1096
    "rawvideo",
1097
    NULL_IF_CONFIG_SMALL("raw video format"),
1098
    NULL,
1099
    "yuv,rgb",
1100
    0,
1101
    CODEC_ID_NONE,
1102
    CODEC_ID_RAWVIDEO,
1103
    NULL,
1104
    raw_write_packet,
1105
    .flags= AVFMT_NOTIMESTAMPS,
1106
};
1107
#endif
1108

    
1109
#if CONFIG_ROQ_MUXER
1110
AVOutputFormat roq_muxer =
1111
{
1112
    "RoQ",
1113
    NULL_IF_CONFIG_SMALL("raw id RoQ format"),
1114
    NULL,
1115
    "roq",
1116
    0,
1117
    CODEC_ID_ROQ_DPCM,
1118
    CODEC_ID_ROQ,
1119
    roq_write_header,
1120
    raw_write_packet,
1121
};
1122
#endif
1123

    
1124
#if CONFIG_SHORTEN_DEMUXER
1125
AVInputFormat shorten_demuxer = {
1126
    "shn",
1127
    NULL_IF_CONFIG_SMALL("raw Shorten"),
1128
    0,
1129
    NULL,
1130
    audio_read_header,
1131
    ff_raw_read_partial_packet,
1132
    .flags= AVFMT_GENERIC_INDEX,
1133
    .extensions = "shn",
1134
    .value = CODEC_ID_SHORTEN,
1135
};
1136
#endif
1137

    
1138
#if CONFIG_VC1_DEMUXER
1139
AVInputFormat vc1_demuxer = {
1140
    "vc1",
1141
    NULL_IF_CONFIG_SMALL("raw VC-1"),
1142
    0,
1143
    NULL /* vc1_probe */,
1144
    video_read_header,
1145
    ff_raw_read_partial_packet,
1146
    .extensions = "vc1",
1147
    .value = CODEC_ID_VC1,
1148
};
1149
#endif
1150

    
1151
/* PCM formats */
1152

    
1153
#define PCMINPUTDEF(name, long_name, ext, codec) \
1154
AVInputFormat pcm_ ## name ## _demuxer = {\
1155
    #name,\
1156
    NULL_IF_CONFIG_SMALL(long_name),\
1157
    0,\
1158
    NULL,\
1159
    raw_read_header,\
1160
    raw_read_packet,\
1161
    NULL,\
1162
    pcm_read_seek,\
1163
    .flags= AVFMT_GENERIC_INDEX,\
1164
    .extensions = ext,\
1165
    .value = codec,\
1166
};
1167

    
1168
#define PCMOUTPUTDEF(name, long_name, ext, codec) \
1169
AVOutputFormat pcm_ ## name ## _muxer = {\
1170
    #name,\
1171
    NULL_IF_CONFIG_SMALL(long_name),\
1172
    NULL,\
1173
    ext,\
1174
    0,\
1175
    codec,\
1176
    CODEC_ID_NONE,\
1177
    NULL,\
1178
    raw_write_packet,\
1179
    .flags= AVFMT_NOTIMESTAMPS,\
1180
};
1181

    
1182

    
1183
#if  !CONFIG_MUXERS && CONFIG_DEMUXERS
1184
#define PCMDEF(name, long_name, ext, codec) \
1185
        PCMINPUTDEF(name, long_name, ext, codec)
1186
#elif CONFIG_MUXERS && !CONFIG_DEMUXERS
1187
#define PCMDEF(name, long_name, ext, codec) \
1188
        PCMOUTPUTDEF(name, long_name, ext, codec)
1189
#elif CONFIG_MUXERS && CONFIG_DEMUXERS
1190
#define PCMDEF(name, long_name, ext, codec) \
1191
        PCMINPUTDEF(name, long_name, ext, codec)\
1192
        PCMOUTPUTDEF(name, long_name, ext, codec)
1193
#else
1194
#define PCMDEF(name, long_name, ext, codec)
1195
#endif
1196

    
1197
#ifdef WORDS_BIGENDIAN
1198
#define BE_DEF(s) s
1199
#define LE_DEF(s) NULL
1200
#else
1201
#define BE_DEF(s) NULL
1202
#define LE_DEF(s) s
1203
#endif
1204

    
1205
PCMDEF(f64be, "PCM 64 bit floating-point big-endian format",
1206
       NULL, CODEC_ID_PCM_F64BE)
1207

    
1208
PCMDEF(f64le, "PCM 64 bit floating-point little-endian format",
1209
       NULL, CODEC_ID_PCM_F64LE)
1210

    
1211
PCMDEF(f32be, "PCM 32 bit floating-point big-endian format",
1212
       NULL, CODEC_ID_PCM_F32BE)
1213

    
1214
PCMDEF(f32le, "PCM 32 bit floating-point little-endian format",
1215
       NULL, CODEC_ID_PCM_F32LE)
1216

    
1217
PCMDEF(s32be, "PCM signed 32 bit big-endian format",
1218
       NULL, CODEC_ID_PCM_S32BE)
1219

    
1220
PCMDEF(s32le, "PCM signed 32 bit little-endian format",
1221
       NULL, CODEC_ID_PCM_S32LE)
1222

    
1223
PCMDEF(s24be, "PCM signed 24 bit big-endian format",
1224
       NULL, CODEC_ID_PCM_S24BE)
1225

    
1226
PCMDEF(s24le, "PCM signed 24 bit little-endian format",
1227
       NULL, CODEC_ID_PCM_S24LE)
1228

    
1229
PCMDEF(s16be, "PCM signed 16 bit big-endian format",
1230
       BE_DEF("sw"), CODEC_ID_PCM_S16BE)
1231

    
1232
PCMDEF(s16le, "PCM signed 16 bit little-endian format",
1233
       LE_DEF("sw"), CODEC_ID_PCM_S16LE)
1234

    
1235
PCMDEF(s8, "PCM signed 8 bit format",
1236
       "sb", CODEC_ID_PCM_S8)
1237

    
1238
PCMDEF(u32be, "PCM unsigned 32 bit big-endian format",
1239
       NULL, CODEC_ID_PCM_U32BE)
1240

    
1241
PCMDEF(u32le, "PCM unsigned 32 bit little-endian format",
1242
       NULL, CODEC_ID_PCM_U32LE)
1243

    
1244
PCMDEF(u24be, "PCM unsigned 24 bit big-endian format",
1245
       NULL, CODEC_ID_PCM_U24BE)
1246

    
1247
PCMDEF(u24le, "PCM unsigned 24 bit little-endian format",
1248
       NULL, CODEC_ID_PCM_U24LE)
1249

    
1250
PCMDEF(u16be, "PCM unsigned 16 bit big-endian format",
1251
       BE_DEF("uw"), CODEC_ID_PCM_U16BE)
1252

    
1253
PCMDEF(u16le, "PCM unsigned 16 bit little-endian format",
1254
       LE_DEF("uw"), CODEC_ID_PCM_U16LE)
1255

    
1256
PCMDEF(u8, "PCM unsigned 8 bit format",
1257
       "ub", CODEC_ID_PCM_U8)
1258

    
1259
PCMDEF(alaw, "PCM A-law format",
1260
       "al", CODEC_ID_PCM_ALAW)
1261

    
1262
PCMDEF(mulaw, "PCM mu-law format",
1263
       "ul", CODEC_ID_PCM_MULAW)