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