remove useless close funcs
[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 #ifdef CONFIG_MUXERS
31 /* simple formats */
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
47 static int roq_write_header(struct AVFormatContext *s)
48 {
49     static const uint8_t header[] = {
50         0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00
51     };
52
53     put_buffer(s->pb, header, 8);
54     put_flush_packet(s->pb);
55
56     return 0;
57 }
58
59 static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)
60 {
61     put_buffer(s->pb, pkt->data, pkt->size);
62     put_flush_packet(s->pb);
63     return 0;
64 }
65 #endif //CONFIG_MUXERS
66
67 /* raw input */
68 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
69 {
70     AVStream *st;
71     int id;
72
73     st = av_new_stream(s, 0);
74     if (!st)
75         return AVERROR(ENOMEM);
76
77         id = s->iformat->value;
78         if (id == CODEC_ID_RAWVIDEO) {
79             st->codec->codec_type = CODEC_TYPE_VIDEO;
80         } else {
81             st->codec->codec_type = CODEC_TYPE_AUDIO;
82         }
83         st->codec->codec_id = id;
84
85         switch(st->codec->codec_type) {
86         case CODEC_TYPE_AUDIO:
87             st->codec->sample_rate = ap->sample_rate;
88             st->codec->channels = ap->channels;
89             av_set_pts_info(st, 64, 1, st->codec->sample_rate);
90             break;
91         case CODEC_TYPE_VIDEO:
92             if(ap->time_base.num)
93                 av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
94             else
95                 av_set_pts_info(st, 64, 1, 25);
96             st->codec->width = ap->width;
97             st->codec->height = ap->height;
98             st->codec->pix_fmt = ap->pix_fmt;
99             if(st->codec->pix_fmt == PIX_FMT_NONE)
100                 st->codec->pix_fmt= PIX_FMT_YUV420P;
101             break;
102         default:
103             return -1;
104         }
105     return 0;
106 }
107
108 #define RAW_PACKET_SIZE 1024
109
110 static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)
111 {
112     int ret, size, bps;
113     //    AVStream *st = s->streams[0];
114
115     size= RAW_PACKET_SIZE;
116
117     ret= av_get_packet(s->pb, pkt, size);
118
119     pkt->stream_index = 0;
120     if (ret <= 0) {
121         return AVERROR(EIO);
122     }
123     /* note: we need to modify the packet size here to handle the last
124        packet */
125     pkt->size = ret;
126
127     bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id);
128     assert(bps); // if false there IS a bug elsewhere (NOT in this function)
129     pkt->dts=
130     pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels);
131
132     return ret;
133 }
134
135 static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)
136 {
137     int ret, size;
138
139     size = RAW_PACKET_SIZE;
140
141     if (av_new_packet(pkt, size) < 0)
142         return AVERROR(EIO);
143
144     pkt->pos= url_ftell(s->pb);
145     pkt->stream_index = 0;
146     ret = get_partial_buffer(s->pb, pkt->data, size);
147     if (ret <= 0) {
148         av_free_packet(pkt);
149         return AVERROR(EIO);
150     }
151     pkt->size = ret;
152     return ret;
153 }
154
155 // http://www.artificis.hu/files/texts/ingenient.txt
156 static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
157 {
158     int ret, size, w, h, unk1, unk2;
159
160     if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))
161         return AVERROR(EIO); // FIXME
162
163     size = get_le32(s->pb);
164
165     w = get_le16(s->pb);
166     h = get_le16(s->pb);
167
168     url_fskip(s->pb, 8); // zero + size (padded?)
169     url_fskip(s->pb, 2);
170     unk1 = get_le16(s->pb);
171     unk2 = get_le16(s->pb);
172     url_fskip(s->pb, 22); // ascii timestamp
173
174     av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",
175         size, w, h, unk1, unk2);
176
177     if (av_new_packet(pkt, size) < 0)
178         return AVERROR(EIO);
179
180     pkt->pos = url_ftell(s->pb);
181     pkt->stream_index = 0;
182     ret = get_buffer(s->pb, pkt->data, size);
183     if (ret <= 0) {
184         av_free_packet(pkt);
185         return AVERROR(EIO);
186     }
187     pkt->size = ret;
188     return ret;
189 }
190
191 int pcm_read_seek(AVFormatContext *s,
192                   int stream_index, int64_t timestamp, int flags)
193 {
194     AVStream *st;
195     int block_align, byte_rate;
196     int64_t pos;
197
198     st = s->streams[0];
199
200     block_align = st->codec->block_align ? st->codec->block_align :
201         (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
202     byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :
203         block_align * st->codec->sample_rate;
204
205     if (block_align <= 0 || byte_rate <= 0)
206         return -1;
207
208     /* compute the position by aligning it to block_align */
209     pos = av_rescale_rnd(timestamp * byte_rate,
210                          st->time_base.num,
211                          st->time_base.den * (int64_t)block_align,
212                          (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);
213     pos *= block_align;
214
215     /* recompute exact position */
216     st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);
217     url_fseek(s->pb, pos + s->data_offset, SEEK_SET);
218     return 0;
219 }
220
221 static int audio_read_header(AVFormatContext *s,
222                              AVFormatParameters *ap)
223 {
224     AVStream *st = av_new_stream(s, 0);
225     if (!st)
226         return AVERROR(ENOMEM);
227     st->codec->codec_type = CODEC_TYPE_AUDIO;
228     st->codec->codec_id = s->iformat->value;
229     st->need_parsing = AVSTREAM_PARSE_FULL;
230     /* the parameters will be extracted from the compressed bitstream */
231     return 0;
232 }
233
234 /* mpeg1/h263 input */
235 static int video_read_header(AVFormatContext *s,
236                              AVFormatParameters *ap)
237 {
238     AVStream *st;
239
240     st = av_new_stream(s, 0);
241     if (!st)
242         return AVERROR(ENOMEM);
243
244     st->codec->codec_type = CODEC_TYPE_VIDEO;
245     st->codec->codec_id = s->iformat->value;
246     st->need_parsing = AVSTREAM_PARSE_FULL;
247
248     /* for mjpeg, specify frame rate */
249     /* for mpeg4 specify it too (most mpeg4 streams do not have the fixed_vop_rate set ...)*/
250     if (ap->time_base.num) {
251         av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
252     } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
253                 st->codec->codec_id == CODEC_ID_MPEG4 ||
254                 st->codec->codec_id == CODEC_ID_DIRAC ||
255                 st->codec->codec_id == CODEC_ID_H264) {
256         av_set_pts_info(st, 64, 1, 25);
257     }
258
259     return 0;
260 }
261
262 #define SEQ_START_CODE          0x000001b3
263 #define GOP_START_CODE          0x000001b8
264 #define PICTURE_START_CODE      0x00000100
265 #define SLICE_START_CODE        0x00000101
266 #define PACK_START_CODE         0x000001ba
267 #define VIDEO_ID                0x000001e0
268 #define AUDIO_ID                0x000001c0
269
270 static int mpegvideo_probe(AVProbeData *p)
271 {
272     uint32_t code= -1;
273     int pic=0, seq=0, slice=0, pspack=0, pes=0;
274     int i;
275
276     for(i=0; i<p->buf_size; i++){
277         code = (code<<8) + p->buf[i];
278         if ((code & 0xffffff00) == 0x100) {
279             switch(code){
280             case     SEQ_START_CODE:   seq++; break;
281             case PICTURE_START_CODE:   pic++; break;
282             case   SLICE_START_CODE: slice++; break;
283             case    PACK_START_CODE: pspack++; break;
284             }
285             if     ((code & 0x1f0) == VIDEO_ID)   pes++;
286             else if((code & 0x1e0) == AUDIO_ID)   pes++;
287         }
288     }
289     if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)
290         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
291     return 0;
292 }
293
294 #define VISUAL_OBJECT_START_CODE       0x000001b5
295 #define VOP_START_CODE                 0x000001b6
296
297 static int mpeg4video_probe(AVProbeData *probe_packet)
298 {
299     uint32_t temp_buffer= -1;
300     int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;
301     int i;
302
303     for(i=0; i<probe_packet->buf_size; i++){
304         temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];
305         if ((temp_buffer & 0xffffff00) != 0x100)
306             continue;
307
308         if (temp_buffer == VOP_START_CODE)                         VOP++;
309         else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;
310         else if (temp_buffer < 0x120)                              VO++;
311         else if (temp_buffer < 0x130)                              VOL++;
312         else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)
313                  && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;
314     }
315
316     if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)
317         return AVPROBE_SCORE_MAX/2;
318     return 0;
319 }
320
321 static int h263_probe(AVProbeData *p)
322 {
323     int code;
324     const uint8_t *d;
325
326     d = p->buf;
327     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);
328     if (code == 0x20) {
329         return 50;
330     }
331     return 0;
332 }
333
334 static int h261_probe(AVProbeData *p)
335 {
336     int code;
337     const uint8_t *d;
338
339     d = p->buf;
340     code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);
341     if (code == 0x10) {
342         return 50;
343     }
344     return 0;
345 }
346
347 #define DCA_MARKER_14B_BE 0x1FFFE800
348 #define DCA_MARKER_14B_LE 0xFF1F00E8
349 #define DCA_MARKER_RAW_BE 0x7FFE8001
350 #define DCA_MARKER_RAW_LE 0xFE7F0180
351 static int dts_probe(AVProbeData *p)
352 {
353     const uint8_t *buf, *bufp;
354     uint32_t state = -1;
355
356     buf = p->buf;
357
358     for(; buf < (p->buf+p->buf_size)-2; buf+=2) {
359         bufp = buf;
360         state = (state << 16) | bytestream_get_be16(&bufp);
361
362         /* Regular bitstream */
363         if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)
364             return AVPROBE_SCORE_MAX/2+1;
365
366         /* 14 bits big endian bitstream */
367         if (state == DCA_MARKER_14B_BE)
368             if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)
369                 return AVPROBE_SCORE_MAX/2+1;
370
371         /* 14 bits little endian bitstream */
372         if (state == DCA_MARKER_14B_LE)
373             if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)
374                 return AVPROBE_SCORE_MAX/2+1;
375     }
376
377     return 0;
378 }
379
380 static int dirac_probe(AVProbeData *p)
381 {
382     if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
383         return AVPROBE_SCORE_MAX;
384     else
385         return 0;
386 }
387
388 static int ac3_probe(AVProbeData *p)
389 {
390     int max_frames, first_frames = 0, frames;
391     uint8_t *buf, *buf2, *end;
392     AC3HeaderInfo hdr;
393     GetBitContext gbc;
394
395     max_frames = 0;
396     buf = p->buf;
397     end = buf + p->buf_size;
398
399     for(; buf < end; buf++) {
400         buf2 = buf;
401
402         for(frames = 0; buf2 < end; frames++) {
403             init_get_bits(&gbc, buf2, 54);
404             if(ff_ac3_parse_header(&gbc, &hdr) < 0)
405                 break;
406             if(buf2 + hdr.frame_size > end ||
407                av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))
408                 break;
409             buf2 += hdr.frame_size;
410         }
411         max_frames = FFMAX(max_frames, frames);
412         if(buf == p->buf)
413             first_frames = frames;
414     }
415     if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;
416     else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;
417     else if(max_frames>=1) return 1;
418     else                   return 0;
419 }
420
421 static int flac_probe(AVProbeData *p)
422 {
423     if(memcmp(p->buf, "fLaC", 4)) return 0;
424     else                          return AVPROBE_SCORE_MAX / 2;
425 }
426
427 AVInputFormat shorten_demuxer = {
428     "shn",
429     NULL_IF_CONFIG_SMALL("raw Shorten"),
430     0,
431     NULL,
432     audio_read_header,
433     raw_read_partial_packet,
434     .flags= AVFMT_GENERIC_INDEX,
435     .extensions = "shn",
436     .value = CODEC_ID_SHORTEN,
437 };
438
439 AVInputFormat mlp_demuxer = {
440     "mlp",
441     NULL_IF_CONFIG_SMALL("raw MLP"),
442     0,
443     NULL,
444     audio_read_header,
445     raw_read_partial_packet,
446     .flags= AVFMT_GENERIC_INDEX,
447     .extensions = "mlp",
448     .value = CODEC_ID_MLP,
449 };
450
451 AVInputFormat flac_demuxer = {
452     "flac",
453     NULL_IF_CONFIG_SMALL("raw FLAC"),
454     0,
455     flac_probe,
456     audio_read_header,
457     raw_read_partial_packet,
458     .flags= AVFMT_GENERIC_INDEX,
459     .extensions = "flac",
460     .value = CODEC_ID_FLAC,
461 };
462
463 #ifdef CONFIG_MUXERS
464 AVOutputFormat flac_muxer = {
465     "flac",
466     NULL_IF_CONFIG_SMALL("raw FLAC"),
467     "audio/x-flac",
468     "flac",
469     0,
470     CODEC_ID_FLAC,
471     CODEC_ID_NONE,
472     flac_write_header,
473     raw_write_packet,
474     .flags= AVFMT_NOTIMESTAMPS,
475 };
476 #endif //CONFIG_MUXERS
477
478 #ifdef CONFIG_AC3_DEMUXER
479 AVInputFormat ac3_demuxer = {
480     "ac3",
481     NULL_IF_CONFIG_SMALL("raw AC-3"),
482     0,
483     ac3_probe,
484     audio_read_header,
485     raw_read_partial_packet,
486     .flags= AVFMT_GENERIC_INDEX,
487     .extensions = "ac3",
488     .value = CODEC_ID_AC3,
489 };
490 #endif
491
492 #ifdef CONFIG_MUXERS
493 AVOutputFormat ac3_muxer = {
494     "ac3",
495     NULL_IF_CONFIG_SMALL("raw AC-3"),
496     "audio/x-ac3",
497     "ac3",
498     0,
499     CODEC_ID_AC3,
500     CODEC_ID_NONE,
501     NULL,
502     raw_write_packet,
503     .flags= AVFMT_NOTIMESTAMPS,
504 };
505
506 AVOutputFormat dts_muxer = {
507     "dts",
508     NULL_IF_CONFIG_SMALL("raw DTS"),
509     "audio/x-dca",
510     "dts",
511     0,
512     CODEC_ID_DTS,
513     CODEC_ID_NONE,
514     NULL,
515     raw_write_packet,
516     .flags= AVFMT_NOTIMESTAMPS,
517 };
518
519 #endif //CONFIG_MUXERS
520
521 AVInputFormat dirac_demuxer = {
522     "dirac",
523     NULL_IF_CONFIG_SMALL("raw Dirac"),
524     0,
525     dirac_probe,
526     video_read_header,
527     raw_read_partial_packet,
528     .flags= AVFMT_GENERIC_INDEX,
529     .value = CODEC_ID_DIRAC,
530 };
531
532 #ifdef CONFIG_MUXERS
533 AVOutputFormat dirac_muxer = {
534     "dirac",
535     NULL_IF_CONFIG_SMALL("raw Dirac"),
536     NULL,
537     "drc",
538     0,
539     CODEC_ID_NONE,
540     CODEC_ID_DIRAC,
541     NULL,
542     raw_write_packet,
543     .flags= AVFMT_NOTIMESTAMPS,
544 };
545 #endif
546
547 AVInputFormat dts_demuxer = {
548     "dts",
549     NULL_IF_CONFIG_SMALL("raw DTS"),
550     0,
551     dts_probe,
552     audio_read_header,
553     raw_read_partial_packet,
554     .flags= AVFMT_GENERIC_INDEX,
555     .extensions = "dts",
556     .value = CODEC_ID_DTS,
557 };
558
559 AVInputFormat aac_demuxer = {
560     "aac",
561     NULL_IF_CONFIG_SMALL("ADTS AAC"),
562     0,
563     NULL,
564     audio_read_header,
565     raw_read_partial_packet,
566     .flags= AVFMT_GENERIC_INDEX,
567     .extensions = "aac",
568     .value = CODEC_ID_AAC,
569 };
570
571 AVInputFormat gsm_demuxer = {
572     "gsm",
573     NULL_IF_CONFIG_SMALL("GSM"),
574     0,
575     NULL,
576     audio_read_header,
577     raw_read_partial_packet,
578     .flags= AVFMT_GENERIC_INDEX,
579     .extensions = "gsm",
580     .value = CODEC_ID_GSM,
581 };
582
583 #ifdef CONFIG_ROQ_MUXER
584 AVOutputFormat roq_muxer =
585 {
586     "RoQ",
587     NULL_IF_CONFIG_SMALL("id RoQ format"),
588     NULL,
589     "roq",
590     0,
591     CODEC_ID_ROQ_DPCM,
592     CODEC_ID_ROQ,
593     roq_write_header,
594     raw_write_packet,
595 };
596 #endif //CONFIG_ROQ_MUXER
597
598 AVInputFormat h261_demuxer = {
599     "h261",
600     NULL_IF_CONFIG_SMALL("raw H.261"),
601     0,
602     h261_probe,
603     video_read_header,
604     raw_read_partial_packet,
605     .flags= AVFMT_GENERIC_INDEX,
606     .extensions = "h261",
607     .value = CODEC_ID_H261,
608 };
609
610 #ifdef CONFIG_MUXERS
611 AVOutputFormat h261_muxer = {
612     "h261",
613     NULL_IF_CONFIG_SMALL("raw H.261"),
614     "video/x-h261",
615     "h261",
616     0,
617     CODEC_ID_NONE,
618     CODEC_ID_H261,
619     NULL,
620     raw_write_packet,
621     .flags= AVFMT_NOTIMESTAMPS,
622 };
623 #endif //CONFIG_MUXERS
624
625 AVInputFormat h263_demuxer = {
626     "h263",
627     NULL_IF_CONFIG_SMALL("raw H.263"),
628     0,
629     h263_probe,
630     video_read_header,
631     raw_read_partial_packet,
632     .flags= AVFMT_GENERIC_INDEX,
633 //    .extensions = "h263", //FIXME remove after writing mpeg4_probe
634     .value = CODEC_ID_H263,
635 };
636
637 #ifdef CONFIG_MUXERS
638 AVOutputFormat h263_muxer = {
639     "h263",
640     NULL_IF_CONFIG_SMALL("raw H.263"),
641     "video/x-h263",
642     "h263",
643     0,
644     CODEC_ID_NONE,
645     CODEC_ID_H263,
646     NULL,
647     raw_write_packet,
648     .flags= AVFMT_NOTIMESTAMPS,
649 };
650 #endif //CONFIG_MUXERS
651
652 AVInputFormat m4v_demuxer = {
653     "m4v",
654     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
655     0,
656     mpeg4video_probe, /** probing for mpeg4 data */
657     video_read_header,
658     raw_read_partial_packet,
659     .flags= AVFMT_GENERIC_INDEX,
660     .extensions = "m4v", //FIXME remove after writing mpeg4_probe
661     .value = CODEC_ID_MPEG4,
662 };
663
664 #ifdef CONFIG_MUXERS
665 AVOutputFormat m4v_muxer = {
666     "m4v",
667     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
668     NULL,
669     "m4v",
670     0,
671     CODEC_ID_NONE,
672     CODEC_ID_MPEG4,
673     NULL,
674     raw_write_packet,
675     .flags= AVFMT_NOTIMESTAMPS,
676 };
677 #endif //CONFIG_MUXERS
678
679 AVInputFormat h264_demuxer = {
680     "h264",
681     NULL_IF_CONFIG_SMALL("raw H.264 video format"),
682     0,
683     NULL /*mpegvideo_probe*/,
684     video_read_header,
685     raw_read_partial_packet,
686     .flags= AVFMT_GENERIC_INDEX,
687     .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
688     .value = CODEC_ID_H264,
689 };
690
691 #ifdef CONFIG_MUXERS
692 AVOutputFormat h264_muxer = {
693     "h264",
694     NULL_IF_CONFIG_SMALL("raw H.264 video format"),
695     NULL,
696     "h264",
697     0,
698     CODEC_ID_NONE,
699     CODEC_ID_H264,
700     NULL,
701     raw_write_packet,
702     .flags= AVFMT_NOTIMESTAMPS,
703 };
704 #endif //CONFIG_MUXERS
705
706 AVInputFormat mpegvideo_demuxer = {
707     "mpegvideo",
708     NULL_IF_CONFIG_SMALL("MPEG video"),
709     0,
710     mpegvideo_probe,
711     video_read_header,
712     raw_read_partial_packet,
713     .flags= AVFMT_GENERIC_INDEX,
714     .value = CODEC_ID_MPEG1VIDEO,
715 };
716
717 #ifdef CONFIG_MUXERS
718 AVOutputFormat mpeg1video_muxer = {
719     "mpeg1video",
720     NULL_IF_CONFIG_SMALL("MPEG video"),
721     "video/x-mpeg",
722     "mpg,mpeg,m1v",
723     0,
724     CODEC_ID_NONE,
725     CODEC_ID_MPEG1VIDEO,
726     NULL,
727     raw_write_packet,
728     .flags= AVFMT_NOTIMESTAMPS,
729 };
730 #endif //CONFIG_MUXERS
731
732 #ifdef CONFIG_MUXERS
733 AVOutputFormat mpeg2video_muxer = {
734     "mpeg2video",
735     NULL_IF_CONFIG_SMALL("MPEG-2 video"),
736     NULL,
737     "m2v",
738     0,
739     CODEC_ID_NONE,
740     CODEC_ID_MPEG2VIDEO,
741     NULL,
742     raw_write_packet,
743     .flags= AVFMT_NOTIMESTAMPS,
744 };
745 #endif //CONFIG_MUXERS
746
747 AVInputFormat mjpeg_demuxer = {
748     "mjpeg",
749     NULL_IF_CONFIG_SMALL("MJPEG video"),
750     0,
751     NULL,
752     video_read_header,
753     raw_read_partial_packet,
754     .flags= AVFMT_GENERIC_INDEX,
755     .extensions = "mjpg,mjpeg",
756     .value = CODEC_ID_MJPEG,
757 };
758
759 AVInputFormat ingenient_demuxer = {
760     "ingenient",
761     NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),
762     0,
763     NULL,
764     video_read_header,
765     ingenient_read_packet,
766     .flags= AVFMT_GENERIC_INDEX,
767     .extensions = "cgi", // FIXME
768     .value = CODEC_ID_MJPEG,
769 };
770
771 #ifdef CONFIG_MUXERS
772 AVOutputFormat mjpeg_muxer = {
773     "mjpeg",
774     NULL_IF_CONFIG_SMALL("MJPEG video"),
775     "video/x-mjpeg",
776     "mjpg,mjpeg",
777     0,
778     CODEC_ID_NONE,
779     CODEC_ID_MJPEG,
780     NULL,
781     raw_write_packet,
782     .flags= AVFMT_NOTIMESTAMPS,
783 };
784 #endif //CONFIG_MUXERS
785
786 AVInputFormat vc1_demuxer = {
787     "vc1",
788     NULL_IF_CONFIG_SMALL("raw VC-1"),
789     0,
790     NULL /* vc1_probe */,
791     video_read_header,
792     raw_read_partial_packet,
793     .extensions = "vc1",
794     .value = CODEC_ID_VC1,
795 };
796
797 /* pcm formats */
798
799 #define PCMINPUTDEF(name, long_name, ext, codec) \
800 AVInputFormat pcm_ ## name ## _demuxer = {\
801     #name,\
802     NULL_IF_CONFIG_SMALL(long_name),\
803     0,\
804     NULL,\
805     raw_read_header,\
806     raw_read_packet,\
807     NULL,\
808     pcm_read_seek,\
809     .flags= AVFMT_GENERIC_INDEX,\
810     .extensions = ext,\
811     .value = codec,\
812 };
813
814 #define PCMOUTPUTDEF(name, long_name, ext, codec) \
815 AVOutputFormat pcm_ ## name ## _muxer = {\
816     #name,\
817     NULL_IF_CONFIG_SMALL(long_name),\
818     NULL,\
819     ext,\
820     0,\
821     codec,\
822     CODEC_ID_NONE,\
823     NULL,\
824     raw_write_packet,\
825     .flags= AVFMT_NOTIMESTAMPS,\
826 };
827
828
829 #if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
830 #define PCMDEF(name, long_name, ext, codec) \
831         PCMINPUTDEF(name, long_name, ext, codec)
832 #elif defined(CONFIG_MUXERS) && !defined(CONFIG_DEMUXERS)
833 #define PCMDEF(name, long_name, ext, codec) \
834         PCMOUTPUTDEF(name, long_name, ext, codec)
835 #elif defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)
836 #define PCMDEF(name, long_name, ext, codec) \
837         PCMINPUTDEF(name, long_name, ext, codec)\
838         PCMOUTPUTDEF(name, long_name, ext, codec)
839 #else
840 #define PCMDEF(name, long_name, ext, codec)
841 #endif
842
843 #ifdef WORDS_BIGENDIAN
844 #define BE_DEF(s) s
845 #define LE_DEF(s) NULL
846 #else
847 #define BE_DEF(s) NULL
848 #define LE_DEF(s) s
849 #endif
850
851
852 PCMDEF(s16le, "pcm signed 16 bit little endian format",
853        LE_DEF("sw"), CODEC_ID_PCM_S16LE)
854
855 PCMDEF(s16be, "pcm signed 16 bit big endian format",
856        BE_DEF("sw"), CODEC_ID_PCM_S16BE)
857
858 PCMDEF(u16le, "pcm unsigned 16 bit little endian format",
859        LE_DEF("uw"), CODEC_ID_PCM_U16LE)
860
861 PCMDEF(u16be, "pcm unsigned 16 bit big endian format",
862        BE_DEF("uw"), CODEC_ID_PCM_U16BE)
863
864 PCMDEF(s8, "pcm signed 8 bit format",
865        "sb", CODEC_ID_PCM_S8)
866
867 PCMDEF(u8, "pcm unsigned 8 bit format",
868        "ub", CODEC_ID_PCM_U8)
869
870 PCMDEF(mulaw, "pcm mu law format",
871        "ul", CODEC_ID_PCM_MULAW)
872
873 PCMDEF(alaw, "pcm A law format",
874        "al", CODEC_ID_PCM_ALAW)
875
876 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
877 {
878     int packet_size, ret, width, height;
879     AVStream *st = s->streams[0];
880
881     width = st->codec->width;
882     height = st->codec->height;
883
884     packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
885     if (packet_size < 0)
886         return -1;
887
888     ret= av_get_packet(s->pb, pkt, packet_size);
889     pkt->pts=
890     pkt->dts= pkt->pos / packet_size;
891
892     pkt->stream_index = 0;
893     if (ret != packet_size) {
894         return AVERROR(EIO);
895     } else {
896         return 0;
897     }
898 }
899
900 AVInputFormat rawvideo_demuxer = {
901     "rawvideo",
902     NULL_IF_CONFIG_SMALL("raw video format"),
903     0,
904     NULL,
905     raw_read_header,
906     rawvideo_read_packet,
907     .flags= AVFMT_GENERIC_INDEX,
908     .extensions = "yuv,cif,qcif,rgb",
909     .value = CODEC_ID_RAWVIDEO,
910 };
911
912 #ifdef CONFIG_MUXERS
913 AVOutputFormat rawvideo_muxer = {
914     "rawvideo",
915     NULL_IF_CONFIG_SMALL("raw video format"),
916     NULL,
917     "yuv,rgb",
918     0,
919     CODEC_ID_NONE,
920     CODEC_ID_RAWVIDEO,
921     NULL,
922     raw_write_packet,
923     .flags= AVFMT_NOTIMESTAMPS,
924 };
925 #endif //CONFIG_MUXERS
926
927 #ifdef CONFIG_MUXERS
928 static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
929 {
930     return 0;
931 }
932
933 AVOutputFormat null_muxer = {
934     "null",
935     NULL_IF_CONFIG_SMALL("null video format"),
936     NULL,
937     NULL,
938     0,
939 #ifdef WORDS_BIGENDIAN
940     CODEC_ID_PCM_S16BE,
941 #else
942     CODEC_ID_PCM_S16LE,
943 #endif
944     CODEC_ID_RAWVIDEO,
945     NULL,
946     null_write_packet,
947     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
948 };
949 #endif //CONFIG_MUXERS