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