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