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