273c3ec4e1cdc2dfe72511888f975de8875dd1d6
[ffmpeg.git] / libavformat / raw.c
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 #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             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
88             break;
89         case CODEC_TYPE_VIDEO:
90             if(ap->time_base.num)
91                 av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
92             else
93                 av_set_pts_info(st, 64, 1, 25);
94             st->codec->width = ap->width;
95             st->codec->height = ap->height;
96             st->codec->pix_fmt = ap->pix_fmt;
97             if(st->codec->pix_fmt == PIX_FMT_NONE)
98                 st->codec->pix_fmt= PIX_FMT_YUV420P;
99             break;
100         default:
101             return -1;
102         }
103     return 0;
104 }
105
106 #define RAW_PACKET_SIZE 1024
107
108 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
109 {
110     int ret, size, bps;
111     //    AVStream *st = s->streams[0];
112
113     size= RAW_PACKET_SIZE;
114
115     ret= av_get_packet(s->pb, pkt, size);
116
117     pkt->stream_index = 0;
118     if (ret <= 0) {
119         return AVERROR(EIO);
120     }
121     /* note: we need to modify the packet size here to handle the last
122        packet */
123     pkt->size = ret;
124
125     bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id);
126     assert(bps); // if false there IS a bug elsewhere (NOT in this function)
127     pkt->dts=
128     pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels);
129
130     return ret;
131 }
132
133 static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
134 {
135     int ret, size;
136
137     size = RAW_PACKET_SIZE;
138
139     if (av_new_packet(pkt, size) < 0)
140         return AVERROR(EIO);
141
142     pkt->pos= url_ftell(s->pb);
143     pkt->stream_index = 0;
144     ret = get_partial_buffer(s->pb, pkt->data, size);
145     if (ret <= 0) {
146         av_free_packet(pkt);
147         return AVERROR(EIO);
148     }
149     pkt->size = ret;
150     return ret;
151 }
152 #endif
153
154 #if CONFIG_RAWVIDEO_DEMUXER
155 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
156 {
157     int packet_size, ret, width, height;
158     AVStream *st = s->streams[0];
159
160     width = st->codec->width;
161     height = st->codec->height;
162
163     packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
164     if (packet_size < 0)
165         return -1;
166
167     ret= av_get_packet(s->pb, pkt, packet_size);
168     pkt->pts=
169     pkt->dts= pkt->pos / packet_size;
170
171     pkt->stream_index = 0;
172     if (ret != packet_size) {
173         return AVERROR(EIO);
174     } else {
175         return 0;
176     }
177 }
178 #endif
179
180 #if CONFIG_INGENIENT_DEMUXER
181 // http://www.artificis.hu/files/texts/ingenient.txt
182 static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
183 {
184     int ret, size, w, h, unk1, unk2;
185
186     if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))
187         return AVERROR(EIO); // FIXME
188
189     size = get_le32(s->pb);
190
191     w = get_le16(s->pb);
192     h = get_le16(s->pb);
193
194     url_fskip(s->pb, 8); // zero + size (padded?)
195     url_fskip(s->pb, 2);
196     unk1 = get_le16(s->pb);
197     unk2 = get_le16(s->pb);
198     url_fskip(s->pb, 22); // ASCII timestamp
199
200     av_log(s, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
201         size, w, h, unk1, unk2);
202
203     if (av_new_packet(pkt, size) < 0)
204         return AVERROR(EIO);
205
206     pkt->pos = url_ftell(s->pb);
207     pkt->stream_index = 0;
208     ret = get_buffer(s->pb, pkt->data, size);
209     if (ret <= 0) {
210         av_free_packet(pkt);
211         return AVERROR(EIO);
212     }
213     pkt->size = ret;
214     return ret;
215 }
216 #endif
217
218 #if CONFIG_DEMUXERS
219 int pcm_read_seek(AVFormatContext *s,
220                   int stream_index, int64_t timestamp, int flags)
221 {
222     AVStream *st;
223     int block_align, byte_rate, ret;
224     int64_t pos;
225
226     st = s->streams[0];
227
228     block_align = st->codec->block_align ? st->codec->block_align :
229         (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
230     byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :
231         block_align * st->codec->sample_rate;
232
233     if (block_align <= 0 || byte_rate <= 0)
234         return -1;
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 = CODEC_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     if(st->codec->codec_id == CODEC_ID_FLAC) {
262         /* skip ID3v2 header if found */
263         uint8_t buf[ID3v2_HEADER_SIZE];
264         int ret = get_buffer(s->pb, buf, ID3v2_HEADER_SIZE);
265         if (ret == ID3v2_HEADER_SIZE && ff_id3v2_match(buf)) {
266             int len = ff_id3v2_tag_len(buf);
267             url_fseek(s->pb, len - ID3v2_HEADER_SIZE, SEEK_CUR);
268         } else {
269             url_fseek(s->pb, 0, SEEK_SET);
270         }
271     }
272     return 0;
273 }
274
275 /* MPEG-1/H.263 input */
276 static int video_read_header(AVFormatContext *s,
277                              AVFormatParameters *ap)
278 {
279     AVStream *st;
280
281     st = av_new_stream(s, 0);
282     if (!st)
283         return AVERROR(ENOMEM);
284
285     st->codec->codec_type = CODEC_TYPE_VIDEO;
286     st->codec->codec_id = s->iformat->value;
287     st->need_parsing = AVSTREAM_PARSE_FULL;
288
289     /* for MJPEG, specify frame rate */
290     /* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop_rate set ...)*/
291     if (ap->time_base.num) {
292         av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
293     } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
294                 st->codec->codec_id == CODEC_ID_MPEG4 ||
295                 st->codec->codec_id == CODEC_ID_DIRAC ||
296                 st->codec->codec_id == CODEC_ID_H264) {
297         av_set_pts_info(st, 64, 1, 25);
298     }
299
300     return 0;
301 }
302 #endif
303
304 #if CONFIG_MPEGVIDEO_DEMUXER
305 #define SEQ_START_CODE          0x000001b3
306 #define GOP_START_CODE          0x000001b8
307 #define PICTURE_START_CODE      0x00000100
308 #define SLICE_START_CODE        0x00000101
309 #define PACK_START_CODE         0x000001ba
310 #define VIDEO_ID                0x000001e0
311 #define AUDIO_ID                0x000001c0
312
313 static int mpegvideo_probe(AVProbeData *p)
314 {
315     uint32_t code= -1;
316     int pic=0, seq=0, slice=0, pspack=0, pes=0;
317     int i;
318
319     for(i=0; i<p->buf_size; i++){
320         code = (code<<8) + p->buf[i];
321         if ((code & 0xffffff00) == 0x100) {
322             switch(code){
323             case     SEQ_START_CODE:   seq++; break;
324             case PICTURE_START_CODE:   pic++; break;
325             case   SLICE_START_CODE: slice++; break;
326             case    PACK_START_CODE: pspack++; break;
327             }
328             if     ((code & 0x1f0) == VIDEO_ID)   pes++;
329             else if((code & 0x1e0) == AUDIO_ID)   pes++;
330         }
331     }
332     if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)
333         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
334     return 0;
335 }
336
337 #define CAVS_SEQ_START_CODE       0x000001b0
338 #define CAVS_PIC_I_START_CODE     0x000001b3
339 #define CAVS_UNDEF_START_CODE     0x000001b4
340 #define CAVS_PIC_PB_START_CODE    0x000001b6
341 #define CAVS_VIDEO_EDIT_CODE      0x000001b7
342 #define CAVS_PROFILE_JIZHUN       0x20
343
344 static int cavsvideo_probe(AVProbeData *p)
345 {
346     uint32_t code= -1;
347     int pic=0, seq=0, slice_pos = 0;
348     int i;
349
350     for(i=0; i<p->buf_size; i++){
351         code = (code<<8) + p->buf[i];
352         if ((code & 0xffffff00) == 0x100) {
353             if(code < CAVS_SEQ_START_CODE) {
354                 /* slices have to be consecutive */
355                 if(code < slice_pos)
356                     return 0;
357                 slice_pos = code;
358             } else {
359                 slice_pos = 0;
360             }
361             if (code == CAVS_SEQ_START_CODE) {
362                 seq++;
363                 /* check for the only currently supported profile */
364                 if(p->buf[i+1] != CAVS_PROFILE_JIZHUN)
365                     return 0;
366             } else if ((code == CAVS_PIC_I_START_CODE) ||
367                        (code == CAVS_PIC_PB_START_CODE)) {
368                 pic++;
369             } else if ((code == CAVS_UNDEF_START_CODE) ||
370                        (code >  CAVS_VIDEO_EDIT_CODE)) {
371                 return 0;
372             }
373         }
374     }
375     if(seq && seq*9<=pic*10)
376         return AVPROBE_SCORE_MAX/2;
377     return 0;
378 }
379 #endif
380
381 #if CONFIG_M4V_DEMUXER
382 #define VISUAL_OBJECT_START_CODE       0x000001b5
383 #define VOP_START_CODE                 0x000001b6
384
385 static int mpeg4video_probe(AVProbeData *probe_packet)
386 {
387     uint32_t temp_buffer= -1;
388     int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;
389     int i;
390
391     for(i=0; i<probe_packet->buf_size; i++){
392         temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];
393         if ((temp_buffer & 0xffffff00) != 0x100)
394             continue;
395
396         if (temp_buffer == VOP_START_CODE)                         VOP++;
397         else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;
398         else if (temp_buffer < 0x120)                              VO++;
399         else if (temp_buffer < 0x130)                              VOL++;
400         else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)
401                  && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;
402     }
403
404     if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)
405         return AVPROBE_SCORE_MAX/2;
406     return 0;
407 }
408 #endif
409
410 #if CONFIG_H264_DEMUXER
411 static int h264_probe(AVProbeData *p)
412 {
413     uint32_t code= -1;
414     int sps=0, pps=0, idr=0, res=0, sli=0;
415     int i;
416
417     for(i=0; i<p->buf_size; i++){
418         code = (code<<8) + p->buf[i];
419         if ((code & 0xffffff00) == 0x100) {
420             int ref_idc= (code>>5)&3;
421             int type   = code & 0x1F;
422             static const int8_t ref_zero[32]={
423                 2, 0, 0, 0, 0,-1, 1,-1,
424                -1, 1, 1, 1, 1,-1, 2, 2,
425                 2, 2, 2, 0, 2, 2, 2, 2,
426                 2, 2, 2, 2, 2, 2, 2, 2
427             };
428
429             if(code & 0x80) //forbidden bit
430                 return 0;
431
432             if(ref_zero[type] == 1 && ref_idc)
433                 return 0;
434             if(ref_zero[type] ==-1 && !ref_idc)
435                 return 0;
436             if(ref_zero[type] == 2)
437                 res++;
438
439             switch(type){
440             case     1:   sli++; break;
441             case     5:   idr++; break;
442             case     7:
443                 if(p->buf[i+2]&0x0F)
444                     return 0;
445                 sps++;
446                 break;
447             case     8:   pps++; break;
448             }
449         }
450     }
451     if(sps && pps && (idr||sli>3) && res<(sps+pps+idr))
452         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
453     return 0;
454 }
455 #endif
456
457 #if CONFIG_H263_DEMUXER
458 static int h263_probe(AVProbeData *p)
459 {
460     int code;
461     const uint8_t *d;
462
463     d = p->buf;
464     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
465     if (code == 0x20) {
466         return 50;
467     }
468     return 0;
469 }
470 #endif
471
472 #if CONFIG_H261_DEMUXER
473 static int h261_probe(AVProbeData *p)
474 {
475     int code;
476     const uint8_t *d;
477
478     d = p->buf;
479     code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
480     if (code == 0x10) {
481         return 50;
482     }
483     return 0;
484 }
485 #endif
486
487 #if CONFIG_DTS_DEMUXER
488 #define DCA_MARKER_14B_BE 0x1FFFE800
489 #define DCA_MARKER_14B_LE 0xFF1F00E8
490 #define DCA_MARKER_RAW_BE 0x7FFE8001
491 #define DCA_MARKER_RAW_LE 0xFE7F0180
492 static int dts_probe(AVProbeData *p)
493 {
494     const uint8_t *buf, *bufp;
495     uint32_t state = -1;
496
497     buf = p->buf;
498
499     for(; buf < (p->buf+p->buf_size)-2; buf+=2) {
500         bufp = buf;
501         state = (state << 16) | bytestream_get_be16(&bufp);
502
503         /* regular bitstream */
504         if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)
505             return AVPROBE_SCORE_MAX/2+1;
506
507         /* 14 bits big-endian bitstream */
508         if (state == DCA_MARKER_14B_BE)
509             if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)
510                 return AVPROBE_SCORE_MAX/2+1;
511
512         /* 14 bits little-endian bitstream */
513         if (state == DCA_MARKER_14B_LE)
514             if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)
515                 return AVPROBE_SCORE_MAX/2+1;
516     }
517
518     return 0;
519 }
520 #endif
521
522 #if CONFIG_DIRAC_DEMUXER
523 static int dirac_probe(AVProbeData *p)
524 {
525     if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
526         return AVPROBE_SCORE_MAX;
527     else
528         return 0;
529 }
530 #endif
531
532 #if CONFIG_DNXHD_DEMUXER
533 static int dnxhd_probe(AVProbeData *p)
534 {
535     static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01};
536     if (!memcmp(p->buf, header, 5))
537         return AVPROBE_SCORE_MAX;
538     else
539         return 0;
540 }
541 #endif
542
543 #if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER
544 static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id)
545 {
546     int max_frames, first_frames = 0, frames;
547     uint8_t *buf, *buf2, *end;
548     AC3HeaderInfo hdr;
549     GetBitContext gbc;
550     enum CodecID codec_id = CODEC_ID_AC3;
551
552     max_frames = 0;
553     buf = p->buf;
554     end = buf + p->buf_size;
555
556     for(; buf < end; buf++) {
557         buf2 = buf;
558
559         for(frames = 0; buf2 < end; frames++) {
560             init_get_bits(&gbc, buf2, 54);
561             if(ff_ac3_parse_header(&gbc, &hdr) < 0)
562                 break;
563             if(buf2 + hdr.frame_size > end ||
564                av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))
565                 break;
566             if (hdr.bitstream_id > 10)
567                 codec_id = CODEC_ID_EAC3;
568             buf2 += hdr.frame_size;
569         }
570         max_frames = FFMAX(max_frames, frames);
571         if(buf == p->buf)
572             first_frames = frames;
573     }
574     if(codec_id != expected_codec_id) return 0;
575     if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
576     else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
577     else if(max_frames>=1) return 1;
578     else                   return 0;
579 }
580 #endif
581
582 #if CONFIG_AC3_DEMUXER
583 static int ac3_probe(AVProbeData *p)
584 {
585     return ac3_eac3_probe(p, CODEC_ID_AC3);
586 }
587 #endif
588
589 #if CONFIG_EAC3_DEMUXER
590 static int eac3_probe(AVProbeData *p)
591 {
592     return ac3_eac3_probe(p, CODEC_ID_EAC3);
593 }
594 #endif
595
596 #if CONFIG_FLAC_DEMUXER
597 static int flac_probe(AVProbeData *p)
598 {
599     uint8_t *bufptr = p->buf;
600     uint8_t *end    = p->buf + p->buf_size;
601
602     if(ff_id3v2_match(bufptr))
603         bufptr += ff_id3v2_tag_len(bufptr);
604
605     if(bufptr > end-4 || memcmp(bufptr, "fLaC", 4)) return 0;
606     else                                            return AVPROBE_SCORE_MAX/2;
607 }
608 #endif
609
610 #if CONFIG_AAC_DEMUXER
611 static int adts_aac_probe(AVProbeData *p)
612 {
613     int max_frames = 0, first_frames = 0;
614     int fsize, frames;
615     uint8_t *buf0 = p->buf;
616     uint8_t *buf2;
617     uint8_t *buf;
618     uint8_t *end = buf0 + p->buf_size - 7;
619
620     if (ff_id3v2_match(buf0)) {
621         buf0 += ff_id3v2_tag_len(buf0);
622     }
623     buf = buf0;
624
625     for(; buf < end; buf= buf2+1) {
626         buf2 = buf;
627
628         for(frames = 0; buf2 < end; frames++) {
629             uint32_t header = AV_RB16(buf2);
630             if((header&0xFFF6) != 0xFFF0)
631                 break;
632             fsize = (AV_RB32(buf2+3)>>13) & 0x8FFF;
633             if(fsize < 7)
634                 break;
635             buf2 += fsize;
636         }
637         max_frames = FFMAX(max_frames, frames);
638         if(buf == buf0)
639             first_frames= frames;
640     }
641     if   (first_frames>=3) return AVPROBE_SCORE_MAX/2+1;
642     else if(max_frames>500)return AVPROBE_SCORE_MAX/2;
643     else if(max_frames>=3) return AVPROBE_SCORE_MAX/4;
644     else if(max_frames>=1) return 1;
645     else                   return 0;
646 }
647 #endif
648
649 /* Note: Do not forget to add new entries to the Makefile as well. */
650
651 #if CONFIG_AAC_DEMUXER
652 AVInputFormat aac_demuxer = {
653     "aac",
654     NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
655     0,
656     adts_aac_probe,
657     audio_read_header,
658     raw_read_partial_packet,
659     .flags= AVFMT_GENERIC_INDEX,
660     .extensions = "aac",
661     .value = CODEC_ID_AAC,
662 };
663 #endif
664
665 #if CONFIG_AC3_DEMUXER
666 AVInputFormat ac3_demuxer = {
667     "ac3",
668     NULL_IF_CONFIG_SMALL("raw AC-3"),
669     0,
670     ac3_probe,
671     audio_read_header,
672     raw_read_partial_packet,
673     .flags= AVFMT_GENERIC_INDEX,
674     .extensions = "ac3",
675     .value = CODEC_ID_AC3,
676 };
677 #endif
678
679 #if CONFIG_AC3_MUXER
680 AVOutputFormat ac3_muxer = {
681     "ac3",
682     NULL_IF_CONFIG_SMALL("raw AC-3"),
683     "audio/x-ac3",
684     "ac3",
685     0,
686     CODEC_ID_AC3,
687     CODEC_ID_NONE,
688     NULL,
689     raw_write_packet,
690     .flags= AVFMT_NOTIMESTAMPS,
691 };
692 #endif
693
694 #if CONFIG_DIRAC_DEMUXER
695 AVInputFormat dirac_demuxer = {
696     "dirac",
697     NULL_IF_CONFIG_SMALL("raw Dirac"),
698     0,
699     dirac_probe,
700     video_read_header,
701     raw_read_partial_packet,
702     .flags= AVFMT_GENERIC_INDEX,
703     .value = CODEC_ID_DIRAC,
704 };
705 #endif
706
707 #if CONFIG_DIRAC_MUXER
708 AVOutputFormat dirac_muxer = {
709     "dirac",
710     NULL_IF_CONFIG_SMALL("raw Dirac"),
711     NULL,
712     "drc",
713     0,
714     CODEC_ID_NONE,
715     CODEC_ID_DIRAC,
716     NULL,
717     raw_write_packet,
718     .flags= AVFMT_NOTIMESTAMPS,
719 };
720 #endif
721
722 #if CONFIG_DNXHD_DEMUXER
723 AVInputFormat dnxhd_demuxer = {
724     "dnxhd",
725     NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
726     0,
727     dnxhd_probe,
728     video_read_header,
729     raw_read_partial_packet,
730     .flags= AVFMT_GENERIC_INDEX,
731     .value = CODEC_ID_DNXHD,
732 };
733 #endif
734
735 #if CONFIG_DNXHD_MUXER
736 AVOutputFormat dnxhd_muxer = {
737     "dnxhd",
738     NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
739     NULL,
740     "dnxhd",
741     0,
742     CODEC_ID_NONE,
743     CODEC_ID_DNXHD,
744     NULL,
745     raw_write_packet,
746     .flags= AVFMT_NOTIMESTAMPS,
747 };
748 #endif
749
750 #if CONFIG_DTS_DEMUXER
751 AVInputFormat dts_demuxer = {
752     "dts",
753     NULL_IF_CONFIG_SMALL("raw DTS"),
754     0,
755     dts_probe,
756     audio_read_header,
757     raw_read_partial_packet,
758     .flags= AVFMT_GENERIC_INDEX,
759     .extensions = "dts",
760     .value = CODEC_ID_DTS,
761 };
762 #endif
763
764 #if CONFIG_DTS_MUXER
765 AVOutputFormat dts_muxer = {
766     "dts",
767     NULL_IF_CONFIG_SMALL("raw DTS"),
768     "audio/x-dca",
769     "dts",
770     0,
771     CODEC_ID_DTS,
772     CODEC_ID_NONE,
773     NULL,
774     raw_write_packet,
775     .flags= AVFMT_NOTIMESTAMPS,
776 };
777 #endif
778
779 #if CONFIG_EAC3_DEMUXER
780 AVInputFormat eac3_demuxer = {
781     "eac3",
782     NULL_IF_CONFIG_SMALL("raw E-AC-3"),
783     0,
784     eac3_probe,
785     audio_read_header,
786     raw_read_partial_packet,
787     .flags= AVFMT_GENERIC_INDEX,
788     .extensions = "eac3",
789     .value = CODEC_ID_EAC3,
790 };
791 #endif
792
793 #if CONFIG_EAC3_MUXER
794 AVOutputFormat eac3_muxer = {
795     "eac3",
796     NULL_IF_CONFIG_SMALL("raw E-AC-3"),
797     "audio/x-eac3",
798     "eac3",
799     0,
800     CODEC_ID_EAC3,
801     CODEC_ID_NONE,
802     NULL,
803     raw_write_packet,
804     .flags= AVFMT_NOTIMESTAMPS,
805 };
806 #endif
807
808 #if CONFIG_FLAC_DEMUXER
809 AVInputFormat flac_demuxer = {
810     "flac",
811     NULL_IF_CONFIG_SMALL("raw FLAC"),
812     0,
813     flac_probe,
814     audio_read_header,
815     raw_read_partial_packet,
816     .flags= AVFMT_GENERIC_INDEX,
817     .extensions = "flac",
818     .value = CODEC_ID_FLAC,
819 };
820 #endif
821
822 #if CONFIG_GSM_DEMUXER
823 AVInputFormat gsm_demuxer = {
824     "gsm",
825     NULL_IF_CONFIG_SMALL("raw GSM"),
826     0,
827     NULL,
828     audio_read_header,
829     raw_read_partial_packet,
830     .flags= AVFMT_GENERIC_INDEX,
831     .extensions = "gsm",
832     .value = CODEC_ID_GSM,
833 };
834 #endif
835
836 #if CONFIG_H261_DEMUXER
837 AVInputFormat h261_demuxer = {
838     "h261",
839     NULL_IF_CONFIG_SMALL("raw H.261"),
840     0,
841     h261_probe,
842     video_read_header,
843     raw_read_partial_packet,
844     .flags= AVFMT_GENERIC_INDEX,
845     .extensions = "h261",
846     .value = CODEC_ID_H261,
847 };
848 #endif
849
850 #if CONFIG_H261_MUXER
851 AVOutputFormat h261_muxer = {
852     "h261",
853     NULL_IF_CONFIG_SMALL("raw H.261"),
854     "video/x-h261",
855     "h261",
856     0,
857     CODEC_ID_NONE,
858     CODEC_ID_H261,
859     NULL,
860     raw_write_packet,
861     .flags= AVFMT_NOTIMESTAMPS,
862 };
863 #endif
864
865 #if CONFIG_H263_DEMUXER
866 AVInputFormat h263_demuxer = {
867     "h263",
868     NULL_IF_CONFIG_SMALL("raw H.263"),
869     0,
870     h263_probe,
871     video_read_header,
872     raw_read_partial_packet,
873     .flags= AVFMT_GENERIC_INDEX,
874 //    .extensions = "h263", //FIXME remove after writing mpeg4_probe
875     .value = CODEC_ID_H263,
876 };
877 #endif
878
879 #if CONFIG_H263_MUXER
880 AVOutputFormat h263_muxer = {
881     "h263",
882     NULL_IF_CONFIG_SMALL("raw H.263"),
883     "video/x-h263",
884     "h263",
885     0,
886     CODEC_ID_NONE,
887     CODEC_ID_H263,
888     NULL,
889     raw_write_packet,
890     .flags= AVFMT_NOTIMESTAMPS,
891 };
892 #endif
893
894 #if CONFIG_H264_DEMUXER
895 AVInputFormat h264_demuxer = {
896     "h264",
897     NULL_IF_CONFIG_SMALL("raw H.264 video format"),
898     0,
899     h264_probe,
900     video_read_header,
901     raw_read_partial_packet,
902     .flags= AVFMT_GENERIC_INDEX,
903     .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
904     .value = CODEC_ID_H264,
905 };
906 #endif
907
908 #if CONFIG_H264_MUXER
909 AVOutputFormat h264_muxer = {
910     "h264",
911     NULL_IF_CONFIG_SMALL("raw H.264 video format"),
912     NULL,
913     "h264",
914     0,
915     CODEC_ID_NONE,
916     CODEC_ID_H264,
917     NULL,
918     raw_write_packet,
919     .flags= AVFMT_NOTIMESTAMPS,
920 };
921 #endif
922
923 #if CONFIG_INGENIENT_DEMUXER
924 AVInputFormat ingenient_demuxer = {
925     "ingenient",
926     NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
927     0,
928     NULL,
929     video_read_header,
930     ingenient_read_packet,
931     .flags= AVFMT_GENERIC_INDEX,
932     .extensions = "cgi", // FIXME
933     .value = CODEC_ID_MJPEG,
934 };
935 #endif
936
937 #if CONFIG_M4V_DEMUXER
938 AVInputFormat m4v_demuxer = {
939     "m4v",
940     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
941     0,
942     mpeg4video_probe, /** probing for MPEG-4 data */
943     video_read_header,
944     raw_read_partial_packet,
945     .flags= AVFMT_GENERIC_INDEX,
946     .extensions = "m4v",
947     .value = CODEC_ID_MPEG4,
948 };
949 #endif
950
951 #if CONFIG_M4V_MUXER
952 AVOutputFormat m4v_muxer = {
953     "m4v",
954     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
955     NULL,
956     "m4v",
957     0,
958     CODEC_ID_NONE,
959     CODEC_ID_MPEG4,
960     NULL,
961     raw_write_packet,
962     .flags= AVFMT_NOTIMESTAMPS,
963 };
964 #endif
965
966 #if CONFIG_MJPEG_DEMUXER
967 AVInputFormat mjpeg_demuxer = {
968     "mjpeg",
969     NULL_IF_CONFIG_SMALL("raw MJPEG video"),
970     0,
971     NULL,
972     video_read_header,
973     raw_read_partial_packet,
974     .flags= AVFMT_GENERIC_INDEX,
975     .extensions = "mjpg,mjpeg",
976     .value = CODEC_ID_MJPEG,
977 };
978 #endif
979
980 #if CONFIG_MJPEG_MUXER
981 AVOutputFormat mjpeg_muxer = {
982     "mjpeg",
983     NULL_IF_CONFIG_SMALL("raw MJPEG video"),
984     "video/x-mjpeg",
985     "mjpg,mjpeg",
986     0,
987     CODEC_ID_NONE,
988     CODEC_ID_MJPEG,
989     NULL,
990     raw_write_packet,
991     .flags= AVFMT_NOTIMESTAMPS,
992 };
993 #endif
994
995 #if CONFIG_MLP_DEMUXER
996 AVInputFormat mlp_demuxer = {
997     "mlp",
998     NULL_IF_CONFIG_SMALL("raw MLP"),
999     0,
1000     NULL,
1001     audio_read_header,
1002     raw_read_partial_packet,
1003     .flags= AVFMT_GENERIC_INDEX,
1004     .extensions = "mlp",
1005     .value = CODEC_ID_MLP,
1006 };
1007 #endif
1008
1009 #if CONFIG_MPEG1VIDEO_MUXER
1010 AVOutputFormat mpeg1video_muxer = {
1011     "mpeg1video",
1012     NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
1013     "video/x-mpeg",
1014     "mpg,mpeg,m1v",
1015     0,
1016     CODEC_ID_NONE,
1017     CODEC_ID_MPEG1VIDEO,
1018     NULL,
1019     raw_write_packet,
1020     .flags= AVFMT_NOTIMESTAMPS,
1021 };
1022 #endif
1023
1024 #if CONFIG_MPEG2VIDEO_MUXER
1025 AVOutputFormat mpeg2video_muxer = {
1026     "mpeg2video",
1027     NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
1028     NULL,
1029     "m2v",
1030     0,
1031     CODEC_ID_NONE,
1032     CODEC_ID_MPEG2VIDEO,
1033     NULL,
1034     raw_write_packet,
1035     .flags= AVFMT_NOTIMESTAMPS,
1036 };
1037 #endif
1038
1039 #if CONFIG_MPEGVIDEO_DEMUXER
1040 AVInputFormat mpegvideo_demuxer = {
1041     "mpegvideo",
1042     NULL_IF_CONFIG_SMALL("raw MPEG video"),
1043     0,
1044     mpegvideo_probe,
1045     video_read_header,
1046     raw_read_partial_packet,
1047     .flags= AVFMT_GENERIC_INDEX,
1048     .value = CODEC_ID_MPEG1VIDEO,
1049 };
1050 #endif
1051
1052 #if CONFIG_CAVSVIDEO_DEMUXER
1053 AVInputFormat cavsvideo_demuxer = {
1054     "cavsvideo",
1055     NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
1056     0,
1057     cavsvideo_probe,
1058     video_read_header,
1059     raw_read_partial_packet,
1060     .flags= AVFMT_GENERIC_INDEX,
1061     .value = CODEC_ID_CAVS,
1062 };
1063 #endif
1064
1065 #if CONFIG_NULL_MUXER
1066 AVOutputFormat null_muxer = {
1067     "null",
1068     NULL_IF_CONFIG_SMALL("raw null video format"),
1069     NULL,
1070     NULL,
1071     0,
1072 #ifdef WORDS_BIGENDIAN
1073     CODEC_ID_PCM_S16BE,
1074 #else
1075     CODEC_ID_PCM_S16LE,
1076 #endif
1077     CODEC_ID_RAWVIDEO,
1078     NULL,
1079     null_write_packet,
1080     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
1081 };
1082 #endif
1083
1084 #if CONFIG_RAWVIDEO_DEMUXER
1085 AVInputFormat rawvideo_demuxer = {
1086     "rawvideo",
1087     NULL_IF_CONFIG_SMALL("raw video format"),
1088     0,
1089     NULL,
1090     raw_read_header,
1091     rawvideo_read_packet,
1092     .flags= AVFMT_GENERIC_INDEX,
1093     .extensions = "yuv,cif,qcif,rgb",
1094     .value = CODEC_ID_RAWVIDEO,
1095 };
1096 #endif
1097
1098 #if CONFIG_RAWVIDEO_MUXER
1099 AVOutputFormat rawvideo_muxer = {
1100     "rawvideo",
1101     NULL_IF_CONFIG_SMALL("raw video format"),
1102     NULL,
1103     "yuv,rgb",
1104     0,
1105     CODEC_ID_NONE,
1106     CODEC_ID_RAWVIDEO,
1107     NULL,
1108     raw_write_packet,
1109     .flags= AVFMT_NOTIMESTAMPS,
1110 };
1111 #endif
1112
1113 #if CONFIG_ROQ_MUXER
1114 AVOutputFormat roq_muxer =
1115 {
1116     "RoQ",
1117     NULL_IF_CONFIG_SMALL("raw id RoQ format"),
1118     NULL,
1119     "roq",
1120     0,
1121     CODEC_ID_ROQ_DPCM,
1122     CODEC_ID_ROQ,
1123     roq_write_header,
1124     raw_write_packet,
1125 };
1126 #endif
1127
1128 #if CONFIG_SHORTEN_DEMUXER
1129 AVInputFormat shorten_demuxer = {
1130     "shn",
1131     NULL_IF_CONFIG_SMALL("raw Shorten"),
1132     0,
1133     NULL,
1134     audio_read_header,
1135     raw_read_partial_packet,
1136     .flags= AVFMT_GENERIC_INDEX,
1137     .extensions = "shn",
1138     .value = CODEC_ID_SHORTEN,
1139 };
1140 #endif
1141
1142 #if CONFIG_VC1_DEMUXER
1143 AVInputFormat vc1_demuxer = {
1144     "vc1",
1145     NULL_IF_CONFIG_SMALL("raw VC-1"),
1146     0,
1147     NULL /* vc1_probe */,
1148     video_read_header,
1149     raw_read_partial_packet,
1150     .extensions = "vc1",
1151     .value = CODEC_ID_VC1,
1152 };
1153 #endif
1154
1155 /* PCM formats */
1156
1157 #define PCMINPUTDEF(name, long_name, ext, codec) \
1158 AVInputFormat pcm_ ## name ## _demuxer = {\
1159     #name,\
1160     NULL_IF_CONFIG_SMALL(long_name),\
1161     0,\
1162     NULL,\
1163     raw_read_header,\
1164     raw_read_packet,\
1165     NULL,\
1166     pcm_read_seek,\
1167     .flags= AVFMT_GENERIC_INDEX,\
1168     .extensions = ext,\
1169     .value = codec,\
1170 };
1171
1172 #define PCMOUTPUTDEF(name, long_name, ext, codec) \
1173 AVOutputFormat pcm_ ## name ## _muxer = {\
1174     #name,\
1175     NULL_IF_CONFIG_SMALL(long_name),\
1176     NULL,\
1177     ext,\
1178     0,\
1179     codec,\
1180     CODEC_ID_NONE,\
1181     NULL,\
1182     raw_write_packet,\
1183     .flags= AVFMT_NOTIMESTAMPS,\
1184 };
1185
1186
1187 #if  !CONFIG_MUXERS && CONFIG_DEMUXERS
1188 #define PCMDEF(name, long_name, ext, codec) \
1189         PCMINPUTDEF(name, long_name, ext, codec)
1190 #elif CONFIG_MUXERS && !CONFIG_DEMUXERS
1191 #define PCMDEF(name, long_name, ext, codec) \
1192         PCMOUTPUTDEF(name, long_name, ext, codec)
1193 #elif CONFIG_MUXERS && CONFIG_DEMUXERS
1194 #define PCMDEF(name, long_name, ext, codec) \
1195         PCMINPUTDEF(name, long_name, ext, codec)\
1196         PCMOUTPUTDEF(name, long_name, ext, codec)
1197 #else
1198 #define PCMDEF(name, long_name, ext, codec)
1199 #endif
1200
1201 #ifdef WORDS_BIGENDIAN
1202 #define BE_DEF(s) s
1203 #define LE_DEF(s) NULL
1204 #else
1205 #define BE_DEF(s) NULL
1206 #define LE_DEF(s) s
1207 #endif
1208
1209 PCMDEF(f64be, "PCM 64 bit floating-point big-endian format",
1210        NULL, CODEC_ID_PCM_F64BE)
1211
1212 PCMDEF(f64le, "PCM 64 bit floating-point little-endian format",
1213        NULL, CODEC_ID_PCM_F64LE)
1214
1215 PCMDEF(f32be, "PCM 32 bit floating-point big-endian format",
1216        NULL, CODEC_ID_PCM_F32BE)
1217
1218 PCMDEF(f32le, "PCM 32 bit floating-point little-endian format",
1219        NULL, CODEC_ID_PCM_F32LE)
1220
1221 PCMDEF(s32be, "PCM signed 32 bit big-endian format",
1222        NULL, CODEC_ID_PCM_S32BE)
1223
1224 PCMDEF(s32le, "PCM signed 32 bit little-endian format",
1225        NULL, CODEC_ID_PCM_S32LE)
1226
1227 PCMDEF(s24be, "PCM signed 24 bit big-endian format",
1228        NULL, CODEC_ID_PCM_S24BE)
1229
1230 PCMDEF(s24le, "PCM signed 24 bit little-endian format",
1231        NULL, CODEC_ID_PCM_S24LE)
1232
1233 PCMDEF(s16be, "PCM signed 16 bit big-endian format",
1234        BE_DEF("sw"), CODEC_ID_PCM_S16BE)
1235
1236 PCMDEF(s16le, "PCM signed 16 bit little-endian format",
1237        LE_DEF("sw"), CODEC_ID_PCM_S16LE)
1238
1239 PCMDEF(s8, "PCM signed 8 bit format",
1240        "sb", CODEC_ID_PCM_S8)
1241
1242 PCMDEF(u32be, "PCM unsigned 32 bit big-endian format",
1243        NULL, CODEC_ID_PCM_U32BE)
1244
1245 PCMDEF(u32le, "PCM unsigned 32 bit little-endian format",
1246        NULL, CODEC_ID_PCM_U32LE)
1247
1248 PCMDEF(u24be, "PCM unsigned 24 bit big-endian format",
1249        NULL, CODEC_ID_PCM_U24BE)
1250
1251 PCMDEF(u24le, "PCM unsigned 24 bit little-endian format",
1252        NULL, CODEC_ID_PCM_U24LE)
1253
1254 PCMDEF(u16be, "PCM unsigned 16 bit big-endian format",
1255        BE_DEF("uw"), CODEC_ID_PCM_U16BE)
1256
1257 PCMDEF(u16le, "PCM unsigned 16 bit little-endian format",
1258        LE_DEF("uw"), CODEC_ID_PCM_U16LE)
1259
1260 PCMDEF(u8, "PCM unsigned 8 bit format",
1261        "ub", CODEC_ID_PCM_U8)
1262
1263 PCMDEF(alaw, "PCM A-law format",
1264        "al", CODEC_ID_PCM_ALAW)
1265
1266 PCMDEF(mulaw, "PCM mu-law format",
1267        "ul", CODEC_ID_PCM_MULAW)