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