Mercurial > libavformat.hg

comparison raw.c @ 4206:c3102b189cb6 libavformat

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Change semantic of CONFIG_*, HAVE_* and ARCH_*. They are now always defined to either 0 or 1.
author aurel
date Tue, 13 Jan 2009 23:44:16 +0000
parents 9b26d29b9020
children 77e0c7511d41
comparison
equal deleted inserted replaced
4205:41878938d030 4206:c3102b189cb6
26 #include "libavcodec/bytestream.h" 26 #include "libavcodec/bytestream.h"
27 #include "avformat.h" 27 #include "avformat.h"
28 #include "raw.h" 28 #include "raw.h"
29 29
30 /* simple formats */ 30 /* simple formats */
31 #ifdef CONFIG_FLAC_MUXER 31 #if CONFIG_FLAC_MUXER
32 static int flac_write_header(struct AVFormatContext *s) 32 static int flac_write_header(struct AVFormatContext *s)
33 { 33 {
34 static const uint8_t header[8] = { 34 static const uint8_t header[8] = {
35 0x66, 0x4C, 0x61, 0x43, 0x80, 0x00, 0x00, 0x22 35 0x66, 0x4C, 0x61, 0x43, 0x80, 0x00, 0x00, 0x22
36 }; 36 };
59 } 59 }
60 return 0; 60 return 0;
61 } 61 }
62 #endif 62 #endif
63 63
64 #ifdef CONFIG_ROQ_MUXER 64 #if CONFIG_ROQ_MUXER
65 static int roq_write_header(struct AVFormatContext *s) 65 static int roq_write_header(struct AVFormatContext *s)
66 { 66 {
67 static const uint8_t header[] = { 67 static const uint8_t header[] = {
68 0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00 68 0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00
69 }; 69 };
73 73
74 return 0; 74 return 0;
75 } 75 }
76 #endif 76 #endif
77 77
78 #ifdef CONFIG_NULL_MUXER 78 #if CONFIG_NULL_MUXER
79 static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt) 79 static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
80 { 80 {
81 return 0; 81 return 0;
82 } 82 }
83 #endif 83 #endif
84 84
85 #ifdef CONFIG_MUXERS 85 #if CONFIG_MUXERS
86 static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt) 86 static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)
87 { 87 {
88 put_buffer(s->pb, pkt->data, pkt->size); 88 put_buffer(s->pb, pkt->data, pkt->size);
89 put_flush_packet(s->pb); 89 put_flush_packet(s->pb);
90 return 0; 90 return 0;
91 } 91 }
92 #endif 92 #endif
93 93
94 #ifdef CONFIG_DEMUXERS 94 #if CONFIG_DEMUXERS
95 /* raw input */ 95 /* raw input */
96 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap) 96 static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
97 { 97 {
98 AVStream *st; 98 AVStream *st;
99 int id; 99 int id;
180 pkt->size = ret; 180 pkt->size = ret;
181 return ret; 181 return ret;
182 } 182 }
183 #endif 183 #endif
184 184
185 #ifdef CONFIG_RAWVIDEO_DEMUXER 185 #if CONFIG_RAWVIDEO_DEMUXER
186 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt) 186 static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
187 { 187 {
188 int packet_size, ret, width, height; 188 int packet_size, ret, width, height;
189 AVStream *st = s->streams[0]; 189 AVStream *st = s->streams[0];
190 190
206 return 0; 206 return 0;
207 } 207 }
208 } 208 }
209 #endif 209 #endif
210 210
211 #ifdef CONFIG_INGENIENT_DEMUXER 211 #if CONFIG_INGENIENT_DEMUXER
212 // http://www.artificis.hu/files/texts/ingenient.txt 212 // http://www.artificis.hu/files/texts/ingenient.txt
213 static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt) 213 static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
214 { 214 {
215 int ret, size, w, h, unk1, unk2; 215 int ret, size, w, h, unk1, unk2;
216 216
244 pkt->size = ret; 244 pkt->size = ret;
245 return ret; 245 return ret;
246 } 246 }
247 #endif 247 #endif
248 248
249 #ifdef CONFIG_DEMUXERS 249 #if CONFIG_DEMUXERS
250 int pcm_read_seek(AVFormatContext *s, 250 int pcm_read_seek(AVFormatContext *s,
251 int stream_index, int64_t timestamp, int flags) 251 int stream_index, int64_t timestamp, int flags)
252 { 252 {
253 AVStream *st; 253 AVStream *st;
254 int block_align, byte_rate, ret; 254 int block_align, byte_rate, ret;
318 318
319 return 0; 319 return 0;
320 } 320 }
321 #endif 321 #endif
322 322
323 #ifdef CONFIG_MPEGVIDEO_DEMUXER 323 #if CONFIG_MPEGVIDEO_DEMUXER
324 #define SEQ_START_CODE 0x000001b3 324 #define SEQ_START_CODE 0x000001b3
325 #define GOP_START_CODE 0x000001b8 325 #define GOP_START_CODE 0x000001b8
326 #define PICTURE_START_CODE 0x00000100 326 #define PICTURE_START_CODE 0x00000100
327 #define SLICE_START_CODE 0x00000101 327 #define SLICE_START_CODE 0x00000101
328 #define PACK_START_CODE 0x000001ba 328 #define PACK_START_CODE 0x000001ba
352 return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg 352 return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
353 return 0; 353 return 0;
354 } 354 }
355 #endif 355 #endif
356 356
357 #ifdef CONFIG_M4V_DEMUXER 357 #if CONFIG_M4V_DEMUXER
358 #define VISUAL_OBJECT_START_CODE 0x000001b5 358 #define VISUAL_OBJECT_START_CODE 0x000001b5
359 #define VOP_START_CODE 0x000001b6 359 #define VOP_START_CODE 0x000001b6
360 360
361 static int mpeg4video_probe(AVProbeData *probe_packet) 361 static int mpeg4video_probe(AVProbeData *probe_packet)
362 { 362 {
381 return AVPROBE_SCORE_MAX/2; 381 return AVPROBE_SCORE_MAX/2;
382 return 0; 382 return 0;
383 } 383 }
384 #endif 384 #endif
385 385
386 #ifdef CONFIG_H264_DEMUXER 386 #if CONFIG_H264_DEMUXER
387 static int h264_probe(AVProbeData *p) 387 static int h264_probe(AVProbeData *p)
388 { 388 {
389 uint32_t code= -1; 389 uint32_t code= -1;
390 int sps=0, pps=0, idr=0, res=0, sli=0; 390 int sps=0, pps=0, idr=0, res=0, sli=0;
391 int i; 391 int i;
428 return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg 428 return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg
429 return 0; 429 return 0;
430 } 430 }
431 #endif 431 #endif
432 432
433 #ifdef CONFIG_H263_DEMUXER 433 #if CONFIG_H263_DEMUXER
434 static int h263_probe(AVProbeData *p) 434 static int h263_probe(AVProbeData *p)
435 { 435 {
436 int code; 436 int code;
437 const uint8_t *d; 437 const uint8_t *d;
438 438
443 } 443 }
444 return 0; 444 return 0;
445 } 445 }
446 #endif 446 #endif
447 447
448 #ifdef CONFIG_H261_DEMUXER 448 #if CONFIG_H261_DEMUXER
449 static int h261_probe(AVProbeData *p) 449 static int h261_probe(AVProbeData *p)
450 { 450 {
451 int code; 451 int code;
452 const uint8_t *d; 452 const uint8_t *d;
453 453
458 } 458 }
459 return 0; 459 return 0;
460 } 460 }
461 #endif 461 #endif
462 462
463 #ifdef CONFIG_DTS_DEMUXER 463 #if CONFIG_DTS_DEMUXER
464 #define DCA_MARKER_14B_BE 0x1FFFE800 464 #define DCA_MARKER_14B_BE 0x1FFFE800
465 #define DCA_MARKER_14B_LE 0xFF1F00E8 465 #define DCA_MARKER_14B_LE 0xFF1F00E8
466 #define DCA_MARKER_RAW_BE 0x7FFE8001 466 #define DCA_MARKER_RAW_BE 0x7FFE8001
467 #define DCA_MARKER_RAW_LE 0xFE7F0180 467 #define DCA_MARKER_RAW_LE 0xFE7F0180
468 static int dts_probe(AVProbeData *p) 468 static int dts_probe(AVProbeData *p)
493 493
494 return 0; 494 return 0;
495 } 495 }
496 #endif 496 #endif
497 497
498 #ifdef CONFIG_DIRAC_DEMUXER 498 #if CONFIG_DIRAC_DEMUXER
499 static int dirac_probe(AVProbeData *p) 499 static int dirac_probe(AVProbeData *p)
500 { 500 {
501 if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D')) 501 if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))
502 return AVPROBE_SCORE_MAX; 502 return AVPROBE_SCORE_MAX;
503 else 503 else
504 return 0; 504 return 0;
505 } 505 }
506 #endif 506 #endif
507 507
508 #ifdef CONFIG_DNXHD_DEMUXER 508 #if CONFIG_DNXHD_DEMUXER
509 static int dnxhd_probe(AVProbeData *p) 509 static int dnxhd_probe(AVProbeData *p)
510 { 510 {
511 static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01}; 511 static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01};
512 if (!memcmp(p->buf, header, 5)) 512 if (!memcmp(p->buf, header, 5))
513 return AVPROBE_SCORE_MAX; 513 return AVPROBE_SCORE_MAX;
514 else 514 else
515 return 0; 515 return 0;
516 } 516 }
517 #endif 517 #endif
518 518
519 #if defined(CONFIG_AC3_DEMUXER) || defined(CONFIG_EAC3_DEMUXER) 519 #if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER
520 static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id) 520 static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id)
521 { 521 {
522 int max_frames, first_frames = 0, frames; 522 int max_frames, first_frames = 0, frames;
523 uint8_t *buf, *buf2, *end; 523 uint8_t *buf, *buf2, *end;
524 AC3HeaderInfo hdr; 524 AC3HeaderInfo hdr;
553 else if(max_frames>=1) return 1; 553 else if(max_frames>=1) return 1;
554 else return 0; 554 else return 0;
555 } 555 }
556 #endif 556 #endif
557 557
558 #ifdef CONFIG_AC3_DEMUXER 558 #if CONFIG_AC3_DEMUXER
559 static int ac3_probe(AVProbeData *p) 559 static int ac3_probe(AVProbeData *p)
560 { 560 {
561 return ac3_eac3_probe(p, CODEC_ID_AC3); 561 return ac3_eac3_probe(p, CODEC_ID_AC3);
562 } 562 }
563 #endif 563 #endif
564 564
565 #ifdef CONFIG_EAC3_DEMUXER 565 #if CONFIG_EAC3_DEMUXER
566 static int eac3_probe(AVProbeData *p) 566 static int eac3_probe(AVProbeData *p)
567 { 567 {
568 return ac3_eac3_probe(p, CODEC_ID_EAC3); 568 return ac3_eac3_probe(p, CODEC_ID_EAC3);
569 } 569 }
570 #endif 570 #endif
571 571
572 #ifdef CONFIG_FLAC_DEMUXER 572 #if CONFIG_FLAC_DEMUXER
573 static int flac_probe(AVProbeData *p) 573 static int flac_probe(AVProbeData *p)
574 { 574 {
575 if(memcmp(p->buf, "fLaC", 4)) return 0; 575 if(memcmp(p->buf, "fLaC", 4)) return 0;
576 else return AVPROBE_SCORE_MAX / 2; 576 else return AVPROBE_SCORE_MAX / 2;
577 } 577 }
578 #endif 578 #endif
579 579
580 #ifdef CONFIG_AAC_DEMUXER 580 #if CONFIG_AAC_DEMUXER
581 static int adts_aac_probe(AVProbeData *p) 581 static int adts_aac_probe(AVProbeData *p)
582 { 582 {
583 int max_frames = 0, first_frames = 0; 583 int max_frames = 0, first_frames = 0;
584 int fsize, frames; 584 int fsize, frames;
585 uint8_t *buf2; 585 uint8_t *buf2;
610 } 610 }
611 #endif 611 #endif
612 612
613 /* Note: Do not forget to add new entries to the Makefile as well. */ 613 /* Note: Do not forget to add new entries to the Makefile as well. */
614 614
615 #ifdef CONFIG_AAC_DEMUXER 615 #if CONFIG_AAC_DEMUXER
616 AVInputFormat aac_demuxer = { 616 AVInputFormat aac_demuxer = {
617 "aac", 617 "aac",
618 NULL_IF_CONFIG_SMALL("ADTS AAC"), 618 NULL_IF_CONFIG_SMALL("ADTS AAC"),
619 0, 619 0,
620 adts_aac_probe, 620 adts_aac_probe,
624 .extensions = "aac", 624 .extensions = "aac",
625 .value = CODEC_ID_AAC, 625 .value = CODEC_ID_AAC,
626 }; 626 };
627 #endif 627 #endif
628 628
629 #ifdef CONFIG_AC3_DEMUXER 629 #if CONFIG_AC3_DEMUXER
630 AVInputFormat ac3_demuxer = { 630 AVInputFormat ac3_demuxer = {
631 "ac3", 631 "ac3",
632 NULL_IF_CONFIG_SMALL("raw AC-3"), 632 NULL_IF_CONFIG_SMALL("raw AC-3"),
633 0, 633 0,
634 ac3_probe, 634 ac3_probe,
638 .extensions = "ac3", 638 .extensions = "ac3",
639 .value = CODEC_ID_AC3, 639 .value = CODEC_ID_AC3,
640 }; 640 };
641 #endif 641 #endif
642 642
643 #ifdef CONFIG_AC3_MUXER 643 #if CONFIG_AC3_MUXER
644 AVOutputFormat ac3_muxer = { 644 AVOutputFormat ac3_muxer = {
645 "ac3", 645 "ac3",
646 NULL_IF_CONFIG_SMALL("raw AC-3"), 646 NULL_IF_CONFIG_SMALL("raw AC-3"),
647 "audio/x-ac3", 647 "audio/x-ac3",
648 "ac3", 648 "ac3",
653 raw_write_packet, 653 raw_write_packet,
654 .flags= AVFMT_NOTIMESTAMPS, 654 .flags= AVFMT_NOTIMESTAMPS,
655 }; 655 };
656 #endif 656 #endif
657 657
658 #ifdef CONFIG_DIRAC_DEMUXER 658 #if CONFIG_DIRAC_DEMUXER
659 AVInputFormat dirac_demuxer = { 659 AVInputFormat dirac_demuxer = {
660 "dirac", 660 "dirac",
661 NULL_IF_CONFIG_SMALL("raw Dirac"), 661 NULL_IF_CONFIG_SMALL("raw Dirac"),
662 0, 662 0,
663 dirac_probe, 663 dirac_probe,
666 .flags= AVFMT_GENERIC_INDEX, 666 .flags= AVFMT_GENERIC_INDEX,
667 .value = CODEC_ID_DIRAC, 667 .value = CODEC_ID_DIRAC,
668 }; 668 };
669 #endif 669 #endif
670 670
671 #ifdef CONFIG_DIRAC_MUXER 671 #if CONFIG_DIRAC_MUXER
672 AVOutputFormat dirac_muxer = { 672 AVOutputFormat dirac_muxer = {
673 "dirac", 673 "dirac",
674 NULL_IF_CONFIG_SMALL("raw Dirac"), 674 NULL_IF_CONFIG_SMALL("raw Dirac"),
675 NULL, 675 NULL,
676 "drc", 676 "drc",
681 raw_write_packet, 681 raw_write_packet,
682 .flags= AVFMT_NOTIMESTAMPS, 682 .flags= AVFMT_NOTIMESTAMPS,
683 }; 683 };
684 #endif 684 #endif
685 685
686 #ifdef CONFIG_DNXHD_DEMUXER 686 #if CONFIG_DNXHD_DEMUXER
687 AVInputFormat dnxhd_demuxer = { 687 AVInputFormat dnxhd_demuxer = {
688 "dnxhd", 688 "dnxhd",
689 NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"), 689 NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
690 0, 690 0,
691 dnxhd_probe, 691 dnxhd_probe,
694 .flags= AVFMT_GENERIC_INDEX, 694 .flags= AVFMT_GENERIC_INDEX,
695 .value = CODEC_ID_DNXHD, 695 .value = CODEC_ID_DNXHD,
696 }; 696 };
697 #endif 697 #endif
698 698
699 #ifdef CONFIG_DNXHD_MUXER 699 #if CONFIG_DNXHD_MUXER
700 AVOutputFormat dnxhd_muxer = { 700 AVOutputFormat dnxhd_muxer = {
701 "dnxhd", 701 "dnxhd",
702 NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"), 702 NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
703 NULL, 703 NULL,
704 "dnxhd", 704 "dnxhd",
709 raw_write_packet, 709 raw_write_packet,
710 .flags= AVFMT_NOTIMESTAMPS, 710 .flags= AVFMT_NOTIMESTAMPS,
711 }; 711 };
712 #endif 712 #endif
713 713
714 #ifdef CONFIG_DTS_DEMUXER 714 #if CONFIG_DTS_DEMUXER
715 AVInputFormat dts_demuxer = { 715 AVInputFormat dts_demuxer = {
716 "dts", 716 "dts",
717 NULL_IF_CONFIG_SMALL("raw DTS"), 717 NULL_IF_CONFIG_SMALL("raw DTS"),
718 0, 718 0,
719 dts_probe, 719 dts_probe,
723 .extensions = "dts", 723 .extensions = "dts",
724 .value = CODEC_ID_DTS, 724 .value = CODEC_ID_DTS,
725 }; 725 };
726 #endif 726 #endif
727 727
728 #ifdef CONFIG_DTS_MUXER 728 #if CONFIG_DTS_MUXER
729 AVOutputFormat dts_muxer = { 729 AVOutputFormat dts_muxer = {
730 "dts", 730 "dts",
731 NULL_IF_CONFIG_SMALL("raw DTS"), 731 NULL_IF_CONFIG_SMALL("raw DTS"),
732 "audio/x-dca", 732 "audio/x-dca",
733 "dts", 733 "dts",
738 raw_write_packet, 738 raw_write_packet,
739 .flags= AVFMT_NOTIMESTAMPS, 739 .flags= AVFMT_NOTIMESTAMPS,
740 }; 740 };
741 #endif 741 #endif
742 742
743 #ifdef CONFIG_EAC3_DEMUXER 743 #if CONFIG_EAC3_DEMUXER
744 AVInputFormat eac3_demuxer = { 744 AVInputFormat eac3_demuxer = {
745 "eac3", 745 "eac3",
746 NULL_IF_CONFIG_SMALL("raw E-AC-3"), 746 NULL_IF_CONFIG_SMALL("raw E-AC-3"),
747 0, 747 0,
748 eac3_probe, 748 eac3_probe,
752 .extensions = "eac3", 752 .extensions = "eac3",
753 .value = CODEC_ID_EAC3, 753 .value = CODEC_ID_EAC3,
754 }; 754 };
755 #endif 755 #endif
756 756
757 #ifdef CONFIG_EAC3_MUXER 757 #if CONFIG_EAC3_MUXER
758 AVOutputFormat eac3_muxer = { 758 AVOutputFormat eac3_muxer = {
759 "eac3", 759 "eac3",
760 NULL_IF_CONFIG_SMALL("raw E-AC-3"), 760 NULL_IF_CONFIG_SMALL("raw E-AC-3"),
761 "audio/x-eac3", 761 "audio/x-eac3",
762 "eac3", 762 "eac3",
767 raw_write_packet, 767 raw_write_packet,
768 .flags= AVFMT_NOTIMESTAMPS, 768 .flags= AVFMT_NOTIMESTAMPS,
769 }; 769 };
770 #endif 770 #endif
771 771
772 #ifdef CONFIG_FLAC_DEMUXER 772 #if CONFIG_FLAC_DEMUXER
773 AVInputFormat flac_demuxer = { 773 AVInputFormat flac_demuxer = {
774 "flac", 774 "flac",
775 NULL_IF_CONFIG_SMALL("raw FLAC"), 775 NULL_IF_CONFIG_SMALL("raw FLAC"),
776 0, 776 0,
777 flac_probe, 777 flac_probe,
781 .extensions = "flac", 781 .extensions = "flac",
782 .value = CODEC_ID_FLAC, 782 .value = CODEC_ID_FLAC,
783 }; 783 };
784 #endif 784 #endif
785 785
786 #ifdef CONFIG_FLAC_MUXER 786 #if CONFIG_FLAC_MUXER
787 AVOutputFormat flac_muxer = { 787 AVOutputFormat flac_muxer = {
788 "flac", 788 "flac",
789 NULL_IF_CONFIG_SMALL("raw FLAC"), 789 NULL_IF_CONFIG_SMALL("raw FLAC"),
790 "audio/x-flac", 790 "audio/x-flac",
791 "flac", 791 "flac",
797 flac_write_trailer, 797 flac_write_trailer,
798 .flags= AVFMT_NOTIMESTAMPS, 798 .flags= AVFMT_NOTIMESTAMPS,
799 }; 799 };
800 #endif 800 #endif
801 801
802 #ifdef CONFIG_GSM_DEMUXER 802 #if CONFIG_GSM_DEMUXER
803 AVInputFormat gsm_demuxer = { 803 AVInputFormat gsm_demuxer = {
804 "gsm", 804 "gsm",
805 NULL_IF_CONFIG_SMALL("GSM"), 805 NULL_IF_CONFIG_SMALL("GSM"),
806 0, 806 0,
807 NULL, 807 NULL,
811 .extensions = "gsm", 811 .extensions = "gsm",
812 .value = CODEC_ID_GSM, 812 .value = CODEC_ID_GSM,
813 }; 813 };
814 #endif 814 #endif
815 815
816 #ifdef CONFIG_H261_DEMUXER 816 #if CONFIG_H261_DEMUXER
817 AVInputFormat h261_demuxer = { 817 AVInputFormat h261_demuxer = {
818 "h261", 818 "h261",
819 NULL_IF_CONFIG_SMALL("raw H.261"), 819 NULL_IF_CONFIG_SMALL("raw H.261"),
820 0, 820 0,
821 h261_probe, 821 h261_probe,
825 .extensions = "h261", 825 .extensions = "h261",
826 .value = CODEC_ID_H261, 826 .value = CODEC_ID_H261,
827 }; 827 };
828 #endif 828 #endif
829 829
830 #ifdef CONFIG_H261_MUXER 830 #if CONFIG_H261_MUXER
831 AVOutputFormat h261_muxer = { 831 AVOutputFormat h261_muxer = {
832 "h261", 832 "h261",
833 NULL_IF_CONFIG_SMALL("raw H.261"), 833 NULL_IF_CONFIG_SMALL("raw H.261"),
834 "video/x-h261", 834 "video/x-h261",
835 "h261", 835 "h261",
840 raw_write_packet, 840 raw_write_packet,
841 .flags= AVFMT_NOTIMESTAMPS, 841 .flags= AVFMT_NOTIMESTAMPS,
842 }; 842 };
843 #endif 843 #endif
844 844
845 #ifdef CONFIG_H263_DEMUXER 845 #if CONFIG_H263_DEMUXER
846 AVInputFormat h263_demuxer = { 846 AVInputFormat h263_demuxer = {
847 "h263", 847 "h263",
848 NULL_IF_CONFIG_SMALL("raw H.263"), 848 NULL_IF_CONFIG_SMALL("raw H.263"),
849 0, 849 0,
850 h263_probe, 850 h263_probe,
854 // .extensions = "h263", //FIXME remove after writing mpeg4_probe 854 // .extensions = "h263", //FIXME remove after writing mpeg4_probe
855 .value = CODEC_ID_H263, 855 .value = CODEC_ID_H263,
856 }; 856 };
857 #endif 857 #endif
858 858
859 #ifdef CONFIG_H263_MUXER 859 #if CONFIG_H263_MUXER
860 AVOutputFormat h263_muxer = { 860 AVOutputFormat h263_muxer = {
861 "h263", 861 "h263",
862 NULL_IF_CONFIG_SMALL("raw H.263"), 862 NULL_IF_CONFIG_SMALL("raw H.263"),
863 "video/x-h263", 863 "video/x-h263",
864 "h263", 864 "h263",
869 raw_write_packet, 869 raw_write_packet,
870 .flags= AVFMT_NOTIMESTAMPS, 870 .flags= AVFMT_NOTIMESTAMPS,
871 }; 871 };
872 #endif 872 #endif
873 873
874 #ifdef CONFIG_H264_DEMUXER 874 #if CONFIG_H264_DEMUXER
875 AVInputFormat h264_demuxer = { 875 AVInputFormat h264_demuxer = {
876 "h264", 876 "h264",
877 NULL_IF_CONFIG_SMALL("raw H.264 video format"), 877 NULL_IF_CONFIG_SMALL("raw H.264 video format"),
878 0, 878 0,
879 h264_probe, 879 h264_probe,
883 .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe 883 .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe
884 .value = CODEC_ID_H264, 884 .value = CODEC_ID_H264,
885 }; 885 };
886 #endif 886 #endif
887 887
888 #ifdef CONFIG_H264_MUXER 888 #if CONFIG_H264_MUXER
889 AVOutputFormat h264_muxer = { 889 AVOutputFormat h264_muxer = {
890 "h264", 890 "h264",
891 NULL_IF_CONFIG_SMALL("raw H.264 video format"), 891 NULL_IF_CONFIG_SMALL("raw H.264 video format"),
892 NULL, 892 NULL,
893 "h264", 893 "h264",
898 raw_write_packet, 898 raw_write_packet,
899 .flags= AVFMT_NOTIMESTAMPS, 899 .flags= AVFMT_NOTIMESTAMPS,
900 }; 900 };
901 #endif 901 #endif
902 902
903 #ifdef CONFIG_INGENIENT_DEMUXER 903 #if CONFIG_INGENIENT_DEMUXER
904 AVInputFormat ingenient_demuxer = { 904 AVInputFormat ingenient_demuxer = {
905 "ingenient", 905 "ingenient",
906 NULL_IF_CONFIG_SMALL("Ingenient MJPEG"), 906 NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),
907 0, 907 0,
908 NULL, 908 NULL,
912 .extensions = "cgi", // FIXME 912 .extensions = "cgi", // FIXME
913 .value = CODEC_ID_MJPEG, 913 .value = CODEC_ID_MJPEG,
914 }; 914 };
915 #endif 915 #endif
916 916
917 #ifdef CONFIG_M4V_DEMUXER 917 #if CONFIG_M4V_DEMUXER
918 AVInputFormat m4v_demuxer = { 918 AVInputFormat m4v_demuxer = {
919 "m4v", 919 "m4v",
920 NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"), 920 NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
921 0, 921 0,
922 mpeg4video_probe, /** probing for MPEG-4 data */ 922 mpeg4video_probe, /** probing for MPEG-4 data */
926 .extensions = "m4v", 926 .extensions = "m4v",
927 .value = CODEC_ID_MPEG4, 927 .value = CODEC_ID_MPEG4,
928 }; 928 };
929 #endif 929 #endif
930 930
931 #ifdef CONFIG_M4V_MUXER 931 #if CONFIG_M4V_MUXER
932 AVOutputFormat m4v_muxer = { 932 AVOutputFormat m4v_muxer = {
933 "m4v", 933 "m4v",
934 NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"), 934 NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
935 NULL, 935 NULL,
936 "m4v", 936 "m4v",
941 raw_write_packet, 941 raw_write_packet,
942 .flags= AVFMT_NOTIMESTAMPS, 942 .flags= AVFMT_NOTIMESTAMPS,
943 }; 943 };
944 #endif 944 #endif
945 945
946 #ifdef CONFIG_MJPEG_DEMUXER 946 #if CONFIG_MJPEG_DEMUXER
947 AVInputFormat mjpeg_demuxer = { 947 AVInputFormat mjpeg_demuxer = {
948 "mjpeg", 948 "mjpeg",
949 NULL_IF_CONFIG_SMALL("MJPEG video"), 949 NULL_IF_CONFIG_SMALL("MJPEG video"),
950 0, 950 0,
951 NULL, 951 NULL,
955 .extensions = "mjpg,mjpeg", 955 .extensions = "mjpg,mjpeg",
956 .value = CODEC_ID_MJPEG, 956 .value = CODEC_ID_MJPEG,
957 }; 957 };
958 #endif 958 #endif
959 959
960 #ifdef CONFIG_MJPEG_MUXER 960 #if CONFIG_MJPEG_MUXER
961 AVOutputFormat mjpeg_muxer = { 961 AVOutputFormat mjpeg_muxer = {
962 "mjpeg", 962 "mjpeg",
963 NULL_IF_CONFIG_SMALL("MJPEG video"), 963 NULL_IF_CONFIG_SMALL("MJPEG video"),
964 "video/x-mjpeg", 964 "video/x-mjpeg",
965 "mjpg,mjpeg", 965 "mjpg,mjpeg",
970 raw_write_packet, 970 raw_write_packet,
971 .flags= AVFMT_NOTIMESTAMPS, 971 .flags= AVFMT_NOTIMESTAMPS,
972 }; 972 };
973 #endif 973 #endif
974 974
975 #ifdef CONFIG_MLP_DEMUXER 975 #if CONFIG_MLP_DEMUXER
976 AVInputFormat mlp_demuxer = { 976 AVInputFormat mlp_demuxer = {
977 "mlp", 977 "mlp",
978 NULL_IF_CONFIG_SMALL("raw MLP"), 978 NULL_IF_CONFIG_SMALL("raw MLP"),
979 0, 979 0,
980 NULL, 980 NULL,
984 .extensions = "mlp", 984 .extensions = "mlp",
985 .value = CODEC_ID_MLP, 985 .value = CODEC_ID_MLP,
986 }; 986 };
987 #endif 987 #endif
988 988
989 #ifdef CONFIG_MPEG1VIDEO_MUXER 989 #if CONFIG_MPEG1VIDEO_MUXER
990 AVOutputFormat mpeg1video_muxer = { 990 AVOutputFormat mpeg1video_muxer = {
991 "mpeg1video", 991 "mpeg1video",
992 NULL_IF_CONFIG_SMALL("MPEG video"), 992 NULL_IF_CONFIG_SMALL("MPEG video"),
993 "video/x-mpeg", 993 "video/x-mpeg",
994 "mpg,mpeg,m1v", 994 "mpg,mpeg,m1v",
999 raw_write_packet, 999 raw_write_packet,
1000 .flags= AVFMT_NOTIMESTAMPS, 1000 .flags= AVFMT_NOTIMESTAMPS,
1001 }; 1001 };
1002 #endif 1002 #endif
1003 1003
1004 #ifdef CONFIG_MPEG2VIDEO_MUXER 1004 #if CONFIG_MPEG2VIDEO_MUXER
1005 AVOutputFormat mpeg2video_muxer = { 1005 AVOutputFormat mpeg2video_muxer = {
1006 "mpeg2video", 1006 "mpeg2video",
1007 NULL_IF_CONFIG_SMALL("MPEG-2 video"), 1007 NULL_IF_CONFIG_SMALL("MPEG-2 video"),
1008 NULL, 1008 NULL,
1009 "m2v", 1009 "m2v",
1014 raw_write_packet, 1014 raw_write_packet,
1015 .flags= AVFMT_NOTIMESTAMPS, 1015 .flags= AVFMT_NOTIMESTAMPS,
1016 }; 1016 };
1017 #endif 1017 #endif
1018 1018
1019 #ifdef CONFIG_MPEGVIDEO_DEMUXER 1019 #if CONFIG_MPEGVIDEO_DEMUXER
1020 AVInputFormat mpegvideo_demuxer = { 1020 AVInputFormat mpegvideo_demuxer = {
1021 "mpegvideo", 1021 "mpegvideo",
1022 NULL_IF_CONFIG_SMALL("MPEG video"), 1022 NULL_IF_CONFIG_SMALL("MPEG video"),
1023 0, 1023 0,
1024 mpegvideo_probe, 1024 mpegvideo_probe,
1027 .flags= AVFMT_GENERIC_INDEX, 1027 .flags= AVFMT_GENERIC_INDEX,
1028 .value = CODEC_ID_MPEG1VIDEO, 1028 .value = CODEC_ID_MPEG1VIDEO,
1029 }; 1029 };
1030 #endif 1030 #endif
1031 1031
1032 #ifdef CONFIG_NULL_MUXER 1032 #if CONFIG_NULL_MUXER
1033 AVOutputFormat null_muxer = { 1033 AVOutputFormat null_muxer = {
1034 "null", 1034 "null",
1035 NULL_IF_CONFIG_SMALL("null video format"), 1035 NULL_IF_CONFIG_SMALL("null video format"),
1036 NULL, 1036 NULL,
1037 NULL, 1037 NULL,
1046 null_write_packet, 1046 null_write_packet,
1047 .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS, 1047 .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
1048 }; 1048 };
1049 #endif 1049 #endif
1050 1050
1051 #ifdef CONFIG_RAWVIDEO_DEMUXER 1051 #if CONFIG_RAWVIDEO_DEMUXER
1052 AVInputFormat rawvideo_demuxer = { 1052 AVInputFormat rawvideo_demuxer = {
1053 "rawvideo", 1053 "rawvideo",
1054 NULL_IF_CONFIG_SMALL("raw video format"), 1054 NULL_IF_CONFIG_SMALL("raw video format"),
1055 0, 1055 0,
1056 NULL, 1056 NULL,
1060 .extensions = "yuv,cif,qcif,rgb", 1060 .extensions = "yuv,cif,qcif,rgb",
1061 .value = CODEC_ID_RAWVIDEO, 1061 .value = CODEC_ID_RAWVIDEO,
1062 }; 1062 };
1063 #endif 1063 #endif
1064 1064
1065 #ifdef CONFIG_RAWVIDEO_MUXER 1065 #if CONFIG_RAWVIDEO_MUXER
1066 AVOutputFormat rawvideo_muxer = { 1066 AVOutputFormat rawvideo_muxer = {
1067 "rawvideo", 1067 "rawvideo",
1068 NULL_IF_CONFIG_SMALL("raw video format"), 1068 NULL_IF_CONFIG_SMALL("raw video format"),
1069 NULL, 1069 NULL,
1070 "yuv,rgb", 1070 "yuv,rgb",
1075 raw_write_packet, 1075 raw_write_packet,
1076 .flags= AVFMT_NOTIMESTAMPS, 1076 .flags= AVFMT_NOTIMESTAMPS,
1077 }; 1077 };
1078 #endif 1078 #endif
1079 1079
1080 #ifdef CONFIG_ROQ_MUXER 1080 #if CONFIG_ROQ_MUXER
1081 AVOutputFormat roq_muxer = 1081 AVOutputFormat roq_muxer =
1082 { 1082 {
1083 "RoQ", 1083 "RoQ",
1084 NULL_IF_CONFIG_SMALL("id RoQ format"), 1084 NULL_IF_CONFIG_SMALL("id RoQ format"),
1085 NULL, 1085 NULL,
1090 roq_write_header, 1090 roq_write_header,
1091 raw_write_packet, 1091 raw_write_packet,
1092 }; 1092 };
1093 #endif 1093 #endif
1094 1094
1095 #ifdef CONFIG_SHORTEN_DEMUXER 1095 #if CONFIG_SHORTEN_DEMUXER
1096 AVInputFormat shorten_demuxer = { 1096 AVInputFormat shorten_demuxer = {
1097 "shn", 1097 "shn",
1098 NULL_IF_CONFIG_SMALL("raw Shorten"), 1098 NULL_IF_CONFIG_SMALL("raw Shorten"),
1099 0, 1099 0,
1100 NULL, 1100 NULL,
1104 .extensions = "shn", 1104 .extensions = "shn",
1105 .value = CODEC_ID_SHORTEN, 1105 .value = CODEC_ID_SHORTEN,
1106 }; 1106 };
1107 #endif 1107 #endif
1108 1108
1109 #ifdef CONFIG_VC1_DEMUXER 1109 #if CONFIG_VC1_DEMUXER
1110 AVInputFormat vc1_demuxer = { 1110 AVInputFormat vc1_demuxer = {
1111 "vc1", 1111 "vc1",
1112 NULL_IF_CONFIG_SMALL("raw VC-1"), 1112 NULL_IF_CONFIG_SMALL("raw VC-1"),
1113 0, 1113 0,
1114 NULL /* vc1_probe */, 1114 NULL /* vc1_probe */,
1149 raw_write_packet,\ 1149 raw_write_packet,\
1150 .flags= AVFMT_NOTIMESTAMPS,\ 1150 .flags= AVFMT_NOTIMESTAMPS,\
1151 }; 1151 };
1152 1152
1153 1153
1154 #if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS) 1154 #if !CONFIG_MUXERS && CONFIG_DEMUXERS
1155 #define PCMDEF(name, long_name, ext, codec) \ 1155 #define PCMDEF(name, long_name, ext, codec) \
1156 PCMINPUTDEF(name, long_name, ext, codec) 1156 PCMINPUTDEF(name, long_name, ext, codec)
1157 #elif defined(CONFIG_MUXERS) && !defined(CONFIG_DEMUXERS) 1157 #elif CONFIG_MUXERS && !CONFIG_DEMUXERS
1158 #define PCMDEF(name, long_name, ext, codec) \ 1158 #define PCMDEF(name, long_name, ext, codec) \
1159 PCMOUTPUTDEF(name, long_name, ext, codec) 1159 PCMOUTPUTDEF(name, long_name, ext, codec)
1160 #elif defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS) 1160 #elif CONFIG_MUXERS && CONFIG_DEMUXERS
1161 #define PCMDEF(name, long_name, ext, codec) \ 1161 #define PCMDEF(name, long_name, ext, codec) \
1162 PCMINPUTDEF(name, long_name, ext, codec)\ 1162 PCMINPUTDEF(name, long_name, ext, codec)\
1163 PCMOUTPUTDEF(name, long_name, ext, codec) 1163 PCMOUTPUTDEF(name, long_name, ext, codec)
1164 #else 1164 #else
1165 #define PCMDEF(name, long_name, ext, codec) 1165 #define PCMDEF(name, long_name, ext, codec)