falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
15703 Commits
32 Branches
283MB
Tree: 2988c93d94
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2988c93d94'
${ noResults }
FFmpeg/libavformat/raw.c

1152 lines
27KB
Raw Blame History 

  1. /*

  2.  * RAW muxer and demuxer

  3.  * Copyright (c) 2001 Fabrice Bellard.

  4.  * Copyright (c) 2005 Alex Beregszaszi

  5.  *

  6.  * This file is part of FFmpeg.

  7.  *

  8.  * FFmpeg is free software; you can redistribute it and/or

  9.  * modify it under the terms of the GNU Lesser General Public

  10.  * License as published by the Free Software Foundation; either

  11.  * version 2.1 of the License, or (at your option) any later version.

  12.  *

  13.  * FFmpeg is distributed in the hope that it will be useful,

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  16.  * Lesser General Public License for more details.

  17.  *

  18.  * You should have received a copy of the GNU Lesser General Public

  19.  * License along with FFmpeg; if not, write to the Free Software

  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  21.  */

  22. 

  23. #include "libavutil/crc.h"

  24. #include "libavcodec/ac3_parser.h"

  25. #include "libavcodec/bitstream.h"

  26. #include "libavcodec/bytestream.h"

  27. #include "avformat.h"

  28. #include "raw.h"

  29. 

  30. /* simple formats */

  31. #ifdef CONFIG_FLAC_MUXER

  32. static int flac_write_header(struct AVFormatContext *s)

  33. {

  34.     static const uint8_t header[8] = {

  35.         0x66, 0x4C, 0x61, 0x43, 0x80, 0x00, 0x00, 0x22

  36.     };

  37.     uint8_t *streaminfo = s->streams[0]->codec->extradata;

  38.     int len = s->streams[0]->codec->extradata_size;

  39.     if(streaminfo != NULL && len > 0) {

  40.         put_buffer(s->pb, header, 8);

  41.         put_buffer(s->pb, streaminfo, len);

  42.     }

  43.     return 0;

  44. }

  45. #endif

  46. 

  47. #ifdef CONFIG_ROQ_MUXER

  48. static int roq_write_header(struct AVFormatContext *s)

  49. {

  50.     static const uint8_t header[] = {

  51.         0x84, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x00

  52.     };

  53. 

  54.     put_buffer(s->pb, header, 8);

  55.     put_flush_packet(s->pb);

  56. 

  57.     return 0;

  58. }

  59. #endif

  60. 

  61. #ifdef CONFIG_NULL_MUXER

  62. static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)

  63. {

  64.     return 0;

  65. }

  66. #endif

  67. 

  68. #ifdef CONFIG_MUXERS

  69. static int raw_write_packet(struct AVFormatContext *s, AVPacket *pkt)

  70. {

  71.     put_buffer(s->pb, pkt->data, pkt->size);

  72.     put_flush_packet(s->pb);

  73.     return 0;

  74. }

  75. #endif

  76. 

  77. #ifdef CONFIG_DEMUXERS

  78. /* raw input */

  79. static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)

  80. {

  81.     AVStream *st;

  82.     int id;

  83. 

  84.     st = av_new_stream(s, 0);

  85.     if (!st)

  86.         return AVERROR(ENOMEM);

  87. 

  88.         id = s->iformat->value;

  89.         if (id == CODEC_ID_RAWVIDEO) {

  90.             st->codec->codec_type = CODEC_TYPE_VIDEO;

  91.         } else {

  92.             st->codec->codec_type = CODEC_TYPE_AUDIO;

  93.         }

  94.         st->codec->codec_id = id;

  95. 

  96.         switch(st->codec->codec_type) {

  97.         case CODEC_TYPE_AUDIO:

  98.             st->codec->sample_rate = ap->sample_rate;

  99.             st->codec->channels = ap->channels;

  100.             av_set_pts_info(st, 64, 1, st->codec->sample_rate);

  101.             break;

  102.         case CODEC_TYPE_VIDEO:

  103.             if(ap->time_base.num)

  104.                 av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);

  105.             else

  106.                 av_set_pts_info(st, 64, 1, 25);

  107.             st->codec->width = ap->width;

  108.             st->codec->height = ap->height;

  109.             st->codec->pix_fmt = ap->pix_fmt;

  110.             if(st->codec->pix_fmt == PIX_FMT_NONE)

  111.                 st->codec->pix_fmt= PIX_FMT_YUV420P;

  112.             break;

  113.         default:

  114.             return -1;

  115.         }

  116.     return 0;

  117. }

  118. 

  119. #define RAW_PACKET_SIZE 1024

  120. 

  121. static int raw_read_packet(AVFormatContext *s, AVPacket *pkt)

  122. {

  123.     int ret, size, bps;

  124.     //    AVStream *st = s->streams[0];

  125. 

  126.     size= RAW_PACKET_SIZE;

  127. 

  128.     ret= av_get_packet(s->pb, pkt, size);

  129. 

  130.     pkt->stream_index = 0;

  131.     if (ret <= 0) {

  132.         return AVERROR(EIO);

  133.     }

  134.     /* note: we need to modify the packet size here to handle the last

  135.        packet */

  136.     pkt->size = ret;

  137. 

  138.     bps= av_get_bits_per_sample(s->streams[0]->codec->codec_id);

  139.     assert(bps); // if false there IS a bug elsewhere (NOT in this function)

  140.     pkt->dts=

  141.     pkt->pts= pkt->pos*8 / (bps * s->streams[0]->codec->channels);

  142. 

  143.     return ret;

  144. }

  145. 

  146. static int raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)

  147. {

  148.     int ret, size;

  149. 

  150.     size = RAW_PACKET_SIZE;

  151. 

  152.     if (av_new_packet(pkt, size) < 0)

  153.         return AVERROR(EIO);

  154. 

  155.     pkt->pos= url_ftell(s->pb);

  156.     pkt->stream_index = 0;

  157.     ret = get_partial_buffer(s->pb, pkt->data, size);

  158.     if (ret <= 0) {

  159.         av_free_packet(pkt);

  160.         return AVERROR(EIO);

  161.     }

  162.     pkt->size = ret;

  163.     return ret;

  164. }

  165. #endif

  166. 

  167. #ifdef CONFIG_RAWVIDEO_DEMUXER

  168. static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)

  169. {

  170.     int packet_size, ret, width, height;

  171.     AVStream *st = s->streams[0];

  172. 

  173.     width = st->codec->width;

  174.     height = st->codec->height;

  175. 

  176.     packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);

  177.     if (packet_size < 0)

  178.         return -1;

  179. 

  180.     ret= av_get_packet(s->pb, pkt, packet_size);

  181.     pkt->pts=

  182.     pkt->dts= pkt->pos / packet_size;

  183. 

  184.     pkt->stream_index = 0;

  185.     if (ret != packet_size) {

  186.         return AVERROR(EIO);

  187.     } else {

  188.         return 0;

  189.     }

  190. }

  191. #endif

  192. 

  193. #ifdef CONFIG_INGENIENT_DEMUXER

  194. // http://www.artificis.hu/files/texts/ingenient.txt

  195. static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)

  196. {

  197.     int ret, size, w, h, unk1, unk2;

  198. 

  199.     if (get_le32(s->pb) != MKTAG('M', 'J', 'P', 'G'))

  200.         return AVERROR(EIO); // FIXME

  201. 

  202.     size = get_le32(s->pb);

  203. 

  204.     w = get_le16(s->pb);

  205.     h = get_le16(s->pb);

  206. 

  207.     url_fskip(s->pb, 8); // zero + size (padded?)

  208.     url_fskip(s->pb, 2);

  209.     unk1 = get_le16(s->pb);

  210.     unk2 = get_le16(s->pb);

  211.     url_fskip(s->pb, 22); // ASCII timestamp

  212. 

  213.     av_log(NULL, AV_LOG_DEBUG, "Ingenient packet: size=%d, width=%d, height=%d, unk1=%d unk2=%d\n",

  214.         size, w, h, unk1, unk2);

  215. 

  216.     if (av_new_packet(pkt, size) < 0)

  217.         return AVERROR(EIO);

  218. 

  219.     pkt->pos = url_ftell(s->pb);

  220.     pkt->stream_index = 0;

  221.     ret = get_buffer(s->pb, pkt->data, size);

  222.     if (ret <= 0) {

  223.         av_free_packet(pkt);

  224.         return AVERROR(EIO);

  225.     }

  226.     pkt->size = ret;

  227.     return ret;

  228. }

  229. #endif

  230. 

  231. #ifdef CONFIG_DEMUXERS

  232. int pcm_read_seek(AVFormatContext *s,

  233.                   int stream_index, int64_t timestamp, int flags)

  234. {

  235.     AVStream *st;

  236.     int block_align, byte_rate, ret;

  237.     int64_t pos;

  238. 

  239.     st = s->streams[0];

  240. 

  241.     block_align = st->codec->block_align ? st->codec->block_align :

  242.         (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;

  243.     byte_rate = st->codec->bit_rate ? st->codec->bit_rate >> 3 :

  244.         block_align * st->codec->sample_rate;

  245. 

  246.     if (block_align <= 0 || byte_rate <= 0)

  247.         return -1;

  248. 

  249.     /* compute the position by aligning it to block_align */

  250.     pos = av_rescale_rnd(timestamp * byte_rate,

  251.                          st->time_base.num,

  252.                          st->time_base.den * (int64_t)block_align,

  253.                          (flags & AVSEEK_FLAG_BACKWARD) ? AV_ROUND_DOWN : AV_ROUND_UP);

  254.     pos *= block_align;

  255. 

  256.     /* recompute exact position */

  257.     st->cur_dts = av_rescale(pos, st->time_base.den, byte_rate * (int64_t)st->time_base.num);

  258.     if ((ret = url_fseek(s->pb, pos + s->data_offset, SEEK_SET)) < 0)

  259.         return ret;

  260.     return 0;

  261. }

  262. 

  263. static int audio_read_header(AVFormatContext *s,

  264.                              AVFormatParameters *ap)

  265. {

  266.     AVStream *st = av_new_stream(s, 0);

  267.     if (!st)

  268.         return AVERROR(ENOMEM);

  269.     st->codec->codec_type = CODEC_TYPE_AUDIO;

  270.     st->codec->codec_id = s->iformat->value;

  271.     st->need_parsing = AVSTREAM_PARSE_FULL;

  272.     /* the parameters will be extracted from the compressed bitstream */

  273.     return 0;

  274. }

  275. 

  276. /* MPEG-1/H.263 input */

  277. static int video_read_header(AVFormatContext *s,

  278.                              AVFormatParameters *ap)

  279. {

  280.     AVStream *st;

  281. 

  282.     st = av_new_stream(s, 0);

  283.     if (!st)

  284.         return AVERROR(ENOMEM);

  285. 

  286.     st->codec->codec_type = CODEC_TYPE_VIDEO;

  287.     st->codec->codec_id = s->iformat->value;

  288.     st->need_parsing = AVSTREAM_PARSE_FULL;

  289. 

  290.     /* for MJPEG, specify frame rate */

  291.     /* for MPEG-4 specify it, too (most MPEG-4 streams do not have the fixed_vop_rate set ...)*/

  292.     if (ap->time_base.num) {

  293.         av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);

  294.     } else if ( st->codec->codec_id == CODEC_ID_MJPEG ||

  295.                 st->codec->codec_id == CODEC_ID_MPEG4 ||

  296.                 st->codec->codec_id == CODEC_ID_DIRAC ||

  297.                 st->codec->codec_id == CODEC_ID_H264) {

  298.         av_set_pts_info(st, 64, 1, 25);

  299.     }

  300. 

  301.     return 0;

  302. }

  303. #endif

  304. 

  305. #ifdef CONFIG_MPEGVIDEO_DEMUXER

  306. #define SEQ_START_CODE          0x000001b3

  307. #define GOP_START_CODE          0x000001b8

  308. #define PICTURE_START_CODE      0x00000100

  309. #define SLICE_START_CODE        0x00000101

  310. #define PACK_START_CODE         0x000001ba

  311. #define VIDEO_ID                0x000001e0

  312. #define AUDIO_ID                0x000001c0

  313. 

  314. static int mpegvideo_probe(AVProbeData *p)

  315. {

  316.     uint32_t code= -1;

  317.     int pic=0, seq=0, slice=0, pspack=0, pes=0;

  318.     int i;

  319. 

  320.     for(i=0; i<p->buf_size; i++){

  321.         code = (code<<8) + p->buf[i];

  322.         if ((code & 0xffffff00) == 0x100) {

  323.             switch(code){

  324.             case     SEQ_START_CODE:   seq++; break;

  325.             case PICTURE_START_CODE:   pic++; break;

  326.             case   SLICE_START_CODE: slice++; break;

  327.             case    PACK_START_CODE: pspack++; break;

  328.             }

  329.             if     ((code & 0x1f0) == VIDEO_ID)   pes++;

  330.             else if((code & 0x1e0) == AUDIO_ID)   pes++;

  331.         }

  332.     }

  333.     if(seq && seq*9<=pic*10 && pic*9<=slice*10 && !pspack && !pes)

  334.         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg

  335.     return 0;

  336. }

  337. #endif

  338. 

  339. #ifdef CONFIG_M4V_DEMUXER

  340. #define VISUAL_OBJECT_START_CODE       0x000001b5

  341. #define VOP_START_CODE                 0x000001b6

  342. 

  343. static int mpeg4video_probe(AVProbeData *probe_packet)

  344. {

  345.     uint32_t temp_buffer= -1;

  346.     int VO=0, VOL=0, VOP = 0, VISO = 0, res=0;

  347.     int i;

  348. 

  349.     for(i=0; i<probe_packet->buf_size; i++){

  350.         temp_buffer = (temp_buffer<<8) + probe_packet->buf[i];

  351.         if ((temp_buffer & 0xffffff00) != 0x100)

  352.             continue;

  353. 

  354.         if (temp_buffer == VOP_START_CODE)                         VOP++;

  355.         else if (temp_buffer == VISUAL_OBJECT_START_CODE)          VISO++;

  356.         else if (temp_buffer < 0x120)                              VO++;

  357.         else if (temp_buffer < 0x130)                              VOL++;

  358.         else if (   !(0x1AF < temp_buffer && temp_buffer < 0x1B7)

  359.                  && !(0x1B9 < temp_buffer && temp_buffer < 0x1C4)) res++;

  360.     }

  361. 

  362.     if ( VOP >= VISO && VOP >= VOL && VO >= VOL && VOL > 0 && res==0)

  363.         return AVPROBE_SCORE_MAX/2;

  364.     return 0;

  365. }

  366. #endif

  367. 

  368. #ifdef CONFIG_H264_DEMUXER

  369. static int h264_probe(AVProbeData *p)

  370. {

  371.     uint32_t code= -1;

  372.     int sps=0, pps=0, idr=0, res=0, sli=0;

  373.     int i;

  374. 

  375.     for(i=0; i<p->buf_size; i++){

  376.         code = (code<<8) + p->buf[i];

  377.         if ((code & 0xffffff00) == 0x100) {

  378.             int ref_idc= (code>>5)&3;

  379.             int type   = code & 0x1F;

  380.             static const int8_t ref_zero[32]={

  381.                 2, 0, 0, 0, 0,-1, 1,-1,

  382.                -1, 1, 1, 1, 1,-1, 2, 2,

  383.                 2, 2, 2, 0, 2, 2, 2, 2,

  384.                 2, 2, 2, 2, 2, 2, 2, 2

  385.             };

  386. 

  387.             if(code & 0x80) //forbidden bit

  388.                 return 0;

  389. 

  390.             if(ref_zero[type] == 1 && ref_idc)

  391.                 return 0;

  392.             if(ref_zero[type] ==-1 && !ref_idc)

  393.                 return 0;

  394.             if(ref_zero[type] == 2)

  395.                 res++;

  396. 

  397.             switch(type){

  398.             case     1:   sli++; break;

  399.             case     5:   idr++; break;

  400.             case     7:

  401.                 if(p->buf[i+2]&0x0F)

  402.                     return 0;

  403.                 sps++;

  404.                 break;

  405.             case     8:   pps++; break;

  406.             }

  407.         }

  408.     }

  409.     if(sps && pps && (idr||sli>3) && res<(sps+pps+idr))

  410.         return AVPROBE_SCORE_MAX/2+1; // +1 for .mpg

  411.     return 0;

  412. }

  413. #endif

  414. 

  415. #ifdef CONFIG_H263_DEMUXER

  416. static int h263_probe(AVProbeData *p)

  417. {

  418.     int code;

  419.     const uint8_t *d;

  420. 

  421.     d = p->buf;

  422.     code = (d[0] << 14) | (d[1] << 6) | (d[2] >> 2);

  423.     if (code == 0x20) {

  424.         return 50;

  425.     }

  426.     return 0;

  427. }

  428. #endif

  429. 

  430. #ifdef CONFIG_H261_DEMUXER

  431. static int h261_probe(AVProbeData *p)

  432. {

  433.     int code;

  434.     const uint8_t *d;

  435. 

  436.     d = p->buf;

  437.     code = (d[0] << 12) | (d[1] << 4) | (d[2] >> 4);

  438.     if (code == 0x10) {

  439.         return 50;

  440.     }

  441.     return 0;

  442. }

  443. #endif

  444. 

  445. #ifdef CONFIG_DTS_DEMUXER

  446. #define DCA_MARKER_14B_BE 0x1FFFE800

  447. #define DCA_MARKER_14B_LE 0xFF1F00E8

  448. #define DCA_MARKER_RAW_BE 0x7FFE8001

  449. #define DCA_MARKER_RAW_LE 0xFE7F0180

  450. static int dts_probe(AVProbeData *p)

  451. {

  452.     const uint8_t *buf, *bufp;

  453.     uint32_t state = -1;

  454. 

  455.     buf = p->buf;

  456. 

  457.     for(; buf < (p->buf+p->buf_size)-2; buf+=2) {

  458.         bufp = buf;

  459.         state = (state << 16) | bytestream_get_be16(&bufp);

  460. 

  461.         /* regular bitstream */

  462.         if (state == DCA_MARKER_RAW_BE || state == DCA_MARKER_RAW_LE)

  463.             return AVPROBE_SCORE_MAX/2+1;

  464. 

  465.         /* 14 bits big-endian bitstream */

  466.         if (state == DCA_MARKER_14B_BE)

  467.             if ((bytestream_get_be16(&bufp) & 0xFFF0) == 0x07F0)

  468.                 return AVPROBE_SCORE_MAX/2+1;

  469. 

  470.         /* 14 bits little-endian bitstream */

  471.         if (state == DCA_MARKER_14B_LE)

  472.             if ((bytestream_get_be16(&bufp) & 0xF0FF) == 0xF007)

  473.                 return AVPROBE_SCORE_MAX/2+1;

  474.     }

  475. 

  476.     return 0;

  477. }

  478. #endif

  479. 

  480. #ifdef CONFIG_DIRAC_DEMUXER

  481. static int dirac_probe(AVProbeData *p)

  482. {

  483.     if (AV_RL32(p->buf) == MKTAG('B', 'B', 'C', 'D'))

  484.         return AVPROBE_SCORE_MAX;

  485.     else

  486.         return 0;

  487. }

  488. #endif

  489. 

  490. #if (CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER)

  491. static int ac3_eac3_probe(AVProbeData *p, int *codec_id)

  492. {

  493.     int max_frames, first_frames = 0, frames;

  494.     uint8_t *buf, *buf2, *end;

  495.     AC3HeaderInfo hdr;

  496.     GetBitContext gbc;

  497. 

  498.     max_frames = 0;

  499.     buf = p->buf;

  500.     end = buf + p->buf_size;

  501. 

  502.     *codec_id = CODEC_ID_AC3;

  503.     for(; buf < end; buf++) {

  504.         buf2 = buf;

  505. 

  506.         for(frames = 0; buf2 < end; frames++) {

  507.             init_get_bits(&gbc, buf2, 54);

  508.             if(ff_ac3_parse_header(&gbc, &hdr) < 0)

  509.                 break;

  510.             if(buf2 + hdr.frame_size > end ||

  511.                av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, buf2 + 2, hdr.frame_size - 2))

  512.                 break;

  513.             if (hdr.bitstream_id > 10)

  514.                 *codec_id = CODEC_ID_EAC3;

  515.             buf2 += hdr.frame_size;

  516.         }

  517.         max_frames = FFMAX(max_frames, frames);

  518.         if(buf == p->buf)

  519.             first_frames = frames;

  520.     }

  521.     if   (first_frames>=3) return AVPROBE_SCORE_MAX * 3 / 4;

  522.     else if(max_frames>=3) return AVPROBE_SCORE_MAX / 2;

  523.     else if(max_frames>=1) return 1;

  524.     else                   return 0;

  525. }

  526. #endif

  527. 

  528. #ifdef CONFIG_AC3_DEMUXER

  529. static int ac3_probe(AVProbeData *p)

  530. {

  531.     int codec_id = CODEC_ID_NONE;

  532.     int score = ac3_eac3_probe(p, &codec_id);

  533.     if(codec_id == CODEC_ID_AC3)

  534.         return score;

  535.     return 0;

  536. }

  537. #endif

  538. 

  539. #ifdef CONFIG_EAC3_DEMUXER

  540. static int eac3_probe(AVProbeData *p)

  541. {

  542.     int codec_id = CODEC_ID_NONE;

  543.     int score = ac3_eac3_probe(p, &codec_id);

  544.     if(codec_id == CODEC_ID_EAC3)

  545.         return score;

  546.     return 0;

  547. }

  548. #endif

  549. 

  550. #ifdef CONFIG_FLAC_DEMUXER

  551. static int flac_probe(AVProbeData *p)

  552. {

  553.     if(memcmp(p->buf, "fLaC", 4)) return 0;

  554.     else                          return AVPROBE_SCORE_MAX / 2;

  555. }

  556. #endif

  557. 

  558. 

  559. /* Note: Do not forget to add new entries to the Makefile as well. */

  560. 

  561. #ifdef CONFIG_AAC_DEMUXER

  562. AVInputFormat aac_demuxer = {

  563.     "aac",

  564.     NULL_IF_CONFIG_SMALL("ADTS AAC"),

  565.     0,

  566.     NULL,

  567.     audio_read_header,

  568.     raw_read_partial_packet,

  569.     .flags= AVFMT_GENERIC_INDEX,

  570.     .extensions = "aac",

  571.     .value = CODEC_ID_AAC,

  572. };

  573. #endif

  574. 

  575. #ifdef CONFIG_AC3_DEMUXER

  576. AVInputFormat ac3_demuxer = {

  577.     "ac3",

  578.     NULL_IF_CONFIG_SMALL("raw AC-3"),

  579.     0,

  580.     ac3_probe,

  581.     audio_read_header,

  582.     raw_read_partial_packet,

  583.     .flags= AVFMT_GENERIC_INDEX,

  584.     .extensions = "ac3",

  585.     .value = CODEC_ID_AC3,

  586. };

  587. #endif

  588. 

  589. #ifdef CONFIG_AC3_MUXER

  590. AVOutputFormat ac3_muxer = {

  591.     "ac3",

  592.     NULL_IF_CONFIG_SMALL("raw AC-3"),

  593.     "audio/x-ac3",

  594.     "ac3",

  595.     0,

  596.     CODEC_ID_AC3,

  597.     CODEC_ID_NONE,

  598.     NULL,

  599.     raw_write_packet,

  600.     .flags= AVFMT_NOTIMESTAMPS,

  601. };

  602. #endif

  603. 

  604. #ifdef CONFIG_DIRAC_DEMUXER

  605. AVInputFormat dirac_demuxer = {

  606.     "dirac",

  607.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  608.     0,

  609.     dirac_probe,

  610.     video_read_header,

  611.     raw_read_partial_packet,

  612.     .flags= AVFMT_GENERIC_INDEX,

  613.     .value = CODEC_ID_DIRAC,

  614. };

  615. #endif

  616. 

  617. #ifdef CONFIG_DIRAC_MUXER

  618. AVOutputFormat dirac_muxer = {

  619.     "dirac",

  620.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  621.     NULL,

  622.     "drc",

  623.     0,

  624.     CODEC_ID_NONE,

  625.     CODEC_ID_DIRAC,

  626.     NULL,

  627.     raw_write_packet,

  628.     .flags= AVFMT_NOTIMESTAMPS,

  629. };

  630. #endif

  631. 

  632. #ifdef CONFIG_DTS_DEMUXER

  633. AVInputFormat dts_demuxer = {

  634.     "dts",

  635.     NULL_IF_CONFIG_SMALL("raw DTS"),

  636.     0,

  637.     dts_probe,

  638.     audio_read_header,

  639.     raw_read_partial_packet,

  640.     .flags= AVFMT_GENERIC_INDEX,

  641.     .extensions = "dts",

  642.     .value = CODEC_ID_DTS,

  643. };

  644. #endif

  645. 

  646. #ifdef CONFIG_DTS_MUXER

  647. AVOutputFormat dts_muxer = {

  648.     "dts",

  649.     NULL_IF_CONFIG_SMALL("raw DTS"),

  650.     "audio/x-dca",

  651.     "dts",

  652.     0,

  653.     CODEC_ID_DTS,

  654.     CODEC_ID_NONE,

  655.     NULL,

  656.     raw_write_packet,

  657.     .flags= AVFMT_NOTIMESTAMPS,

  658. };

  659. #endif

  660. 

  661. #ifdef CONFIG_EAC3_DEMUXER

  662. AVInputFormat eac3_demuxer = {

  663.     "eac3",

  664.     NULL_IF_CONFIG_SMALL("raw E-AC-3"),

  665.     0,

  666.     eac3_probe,

  667.     audio_read_header,

  668.     raw_read_partial_packet,

  669.     .flags= AVFMT_GENERIC_INDEX,

  670.     .extensions = "eac3",

  671.     .value = CODEC_ID_EAC3,

  672. };

  673. #endif

  674. 

  675. #ifdef CONFIG_EAC3_MUXER

  676. AVOutputFormat eac3_muxer = {

  677.     "eac3",

  678.     NULL_IF_CONFIG_SMALL("raw E-AC-3"),

  679.     "audio/x-eac3",

  680.     "eac3",

  681.     0,

  682.     CODEC_ID_EAC3,

  683.     CODEC_ID_NONE,

  684.     NULL,

  685.     raw_write_packet,

  686.     .flags= AVFMT_NOTIMESTAMPS,

  687. };

  688. #endif

  689. 

  690. #ifdef CONFIG_FLAC_DEMUXER

  691. AVInputFormat flac_demuxer = {

  692.     "flac",

  693.     NULL_IF_CONFIG_SMALL("raw FLAC"),

  694.     0,

  695.     flac_probe,

  696.     audio_read_header,

  697.     raw_read_partial_packet,

  698.     .flags= AVFMT_GENERIC_INDEX,

  699.     .extensions = "flac",

  700.     .value = CODEC_ID_FLAC,

  701. };

  702. #endif

  703. 

  704. #ifdef CONFIG_FLAC_MUXER

  705. AVOutputFormat flac_muxer = {

  706.     "flac",

  707.     NULL_IF_CONFIG_SMALL("raw FLAC"),

  708.     "audio/x-flac",

  709.     "flac",

  710.     0,

  711.     CODEC_ID_FLAC,

  712.     CODEC_ID_NONE,

  713.     flac_write_header,

  714.     raw_write_packet,

  715.     .flags= AVFMT_NOTIMESTAMPS,

  716. };

  717. #endif

  718. 

  719. #ifdef CONFIG_GSM_DEMUXER

  720. AVInputFormat gsm_demuxer = {

  721.     "gsm",

  722.     NULL_IF_CONFIG_SMALL("GSM"),

  723.     0,

  724.     NULL,

  725.     audio_read_header,

  726.     raw_read_partial_packet,

  727.     .flags= AVFMT_GENERIC_INDEX,

  728.     .extensions = "gsm",

  729.     .value = CODEC_ID_GSM,

  730. };

  731. #endif

  732. 

  733. #ifdef CONFIG_H261_DEMUXER

  734. AVInputFormat h261_demuxer = {

  735.     "h261",

  736.     NULL_IF_CONFIG_SMALL("raw H.261"),

  737.     0,

  738.     h261_probe,

  739.     video_read_header,

  740.     raw_read_partial_packet,

  741.     .flags= AVFMT_GENERIC_INDEX,

  742.     .extensions = "h261",

  743.     .value = CODEC_ID_H261,

  744. };

  745. #endif

  746. 

  747. #ifdef CONFIG_H261_MUXER

  748. AVOutputFormat h261_muxer = {

  749.     "h261",

  750.     NULL_IF_CONFIG_SMALL("raw H.261"),

  751.     "video/x-h261",

  752.     "h261",

  753.     0,

  754.     CODEC_ID_NONE,

  755.     CODEC_ID_H261,

  756.     NULL,

  757.     raw_write_packet,

  758.     .flags= AVFMT_NOTIMESTAMPS,

  759. };

  760. #endif

  761. 

  762. #ifdef CONFIG_H263_DEMUXER

  763. AVInputFormat h263_demuxer = {

  764.     "h263",

  765.     NULL_IF_CONFIG_SMALL("raw H.263"),

  766.     0,

  767.     h263_probe,

  768.     video_read_header,

  769.     raw_read_partial_packet,

  770.     .flags= AVFMT_GENERIC_INDEX,

  771. //    .extensions = "h263", //FIXME remove after writing mpeg4_probe

  772.     .value = CODEC_ID_H263,

  773. };

  774. #endif

  775. 

  776. #ifdef CONFIG_H263_MUXER

  777. AVOutputFormat h263_muxer = {

  778.     "h263",

  779.     NULL_IF_CONFIG_SMALL("raw H.263"),

  780.     "video/x-h263",

  781.     "h263",

  782.     0,

  783.     CODEC_ID_NONE,

  784.     CODEC_ID_H263,

  785.     NULL,

  786.     raw_write_packet,

  787.     .flags= AVFMT_NOTIMESTAMPS,

  788. };

  789. #endif

  790. 

  791. #ifdef CONFIG_H264_DEMUXER

  792. AVInputFormat h264_demuxer = {

  793.     "h264",

  794.     NULL_IF_CONFIG_SMALL("raw H.264 video format"),

  795.     0,

  796.     h264_probe,

  797.     video_read_header,

  798.     raw_read_partial_packet,

  799.     .flags= AVFMT_GENERIC_INDEX,

  800.     .extensions = "h26l,h264,264", //FIXME remove after writing mpeg4_probe

  801.     .value = CODEC_ID_H264,

  802. };

  803. #endif

  804. 

  805. #ifdef CONFIG_H264_MUXER

  806. AVOutputFormat h264_muxer = {

  807.     "h264",

  808.     NULL_IF_CONFIG_SMALL("raw H.264 video format"),

  809.     NULL,

  810.     "h264",

  811.     0,

  812.     CODEC_ID_NONE,

  813.     CODEC_ID_H264,

  814.     NULL,

  815.     raw_write_packet,

  816.     .flags= AVFMT_NOTIMESTAMPS,

  817. };

  818. #endif

  819. 

  820. #ifdef CONFIG_INGENIENT_DEMUXER

  821. AVInputFormat ingenient_demuxer = {

  822.     "ingenient",

  823.     NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),

  824.     0,

  825.     NULL,

  826.     video_read_header,

  827.     ingenient_read_packet,

  828.     .flags= AVFMT_GENERIC_INDEX,

  829.     .extensions = "cgi", // FIXME

  830.     .value = CODEC_ID_MJPEG,

  831. };

  832. #endif

  833. 

  834. #ifdef CONFIG_M4V_DEMUXER

  835. AVInputFormat m4v_demuxer = {

  836.     "m4v",

  837.     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),

  838.     0,

  839.     mpeg4video_probe, /** probing for MPEG-4 data */

  840.     video_read_header,

  841.     raw_read_partial_packet,

  842.     .flags= AVFMT_GENERIC_INDEX,

  843.     .extensions = "m4v", //FIXME remove after writing mpeg4_probe

  844.     .value = CODEC_ID_MPEG4,

  845. };

  846. #endif

  847. 

  848. #ifdef CONFIG_M4V_MUXER

  849. AVOutputFormat m4v_muxer = {

  850.     "m4v",

  851.     NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),

  852.     NULL,

  853.     "m4v",

  854.     0,

  855.     CODEC_ID_NONE,

  856.     CODEC_ID_MPEG4,

  857.     NULL,

  858.     raw_write_packet,

  859.     .flags= AVFMT_NOTIMESTAMPS,

  860. };

  861. #endif

  862. 

  863. #ifdef CONFIG_MJPEG_DEMUXER

  864. AVInputFormat mjpeg_demuxer = {

  865.     "mjpeg",

  866.     NULL_IF_CONFIG_SMALL("MJPEG video"),

  867.     0,

  868.     NULL,

  869.     video_read_header,

  870.     raw_read_partial_packet,

  871.     .flags= AVFMT_GENERIC_INDEX,

  872.     .extensions = "mjpg,mjpeg",

  873.     .value = CODEC_ID_MJPEG,

  874. };

  875. #endif

  876. 

  877. #ifdef CONFIG_MJPEG_MUXER

  878. AVOutputFormat mjpeg_muxer = {

  879.     "mjpeg",

  880.     NULL_IF_CONFIG_SMALL("MJPEG video"),

  881.     "video/x-mjpeg",

  882.     "mjpg,mjpeg",

  883.     0,

  884.     CODEC_ID_NONE,

  885.     CODEC_ID_MJPEG,

  886.     NULL,

  887.     raw_write_packet,

  888.     .flags= AVFMT_NOTIMESTAMPS,

  889. };

  890. #endif

  891. 

  892. #ifdef CONFIG_MLP_DEMUXER

  893. AVInputFormat mlp_demuxer = {

  894.     "mlp",

  895.     NULL_IF_CONFIG_SMALL("raw MLP"),

  896.     0,

  897.     NULL,

  898.     audio_read_header,

  899.     raw_read_partial_packet,

  900.     .flags= AVFMT_GENERIC_INDEX,

  901.     .extensions = "mlp",

  902.     .value = CODEC_ID_MLP,

  903. };

  904. #endif

  905. 

  906. #ifdef CONFIG_MPEG1VIDEO_MUXER

  907. AVOutputFormat mpeg1video_muxer = {

  908.     "mpeg1video",

  909.     NULL_IF_CONFIG_SMALL("MPEG video"),

  910.     "video/x-mpeg",

  911.     "mpg,mpeg,m1v",

  912.     0,

  913.     CODEC_ID_NONE,

  914.     CODEC_ID_MPEG1VIDEO,

  915.     NULL,

  916.     raw_write_packet,

  917.     .flags= AVFMT_NOTIMESTAMPS,

  918. };

  919. #endif

  920. 

  921. #ifdef CONFIG_MPEG2VIDEO_MUXER

  922. AVOutputFormat mpeg2video_muxer = {

  923.     "mpeg2video",

  924.     NULL_IF_CONFIG_SMALL("MPEG-2 video"),

  925.     NULL,

  926.     "m2v",

  927.     0,

  928.     CODEC_ID_NONE,

  929.     CODEC_ID_MPEG2VIDEO,

  930.     NULL,

  931.     raw_write_packet,

  932.     .flags= AVFMT_NOTIMESTAMPS,

  933. };

  934. #endif

  935. 

  936. #ifdef CONFIG_MPEGVIDEO_DEMUXER

  937. AVInputFormat mpegvideo_demuxer = {

  938.     "mpegvideo",

  939.     NULL_IF_CONFIG_SMALL("MPEG video"),

  940.     0,

  941.     mpegvideo_probe,

  942.     video_read_header,

  943.     raw_read_partial_packet,

  944.     .flags= AVFMT_GENERIC_INDEX,

  945.     .value = CODEC_ID_MPEG1VIDEO,

  946. };

  947. #endif

  948. 

  949. #ifdef CONFIG_NULL_MUXER

  950. AVOutputFormat null_muxer = {

  951.     "null",

  952.     NULL_IF_CONFIG_SMALL("null video format"),

  953.     NULL,

  954.     NULL,

  955.     0,

  956. #ifdef WORDS_BIGENDIAN

  957.     CODEC_ID_PCM_S16BE,

  958. #else

  959.     CODEC_ID_PCM_S16LE,

  960. #endif

  961.     CODEC_ID_RAWVIDEO,

  962.     NULL,

  963.     null_write_packet,

  964.     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,

  965. };

  966. #endif

  967. 

  968. #ifdef CONFIG_RAWVIDEO_DEMUXER

  969. AVInputFormat rawvideo_demuxer = {

  970.     "rawvideo",

  971.     NULL_IF_CONFIG_SMALL("raw video format"),

  972.     0,

  973.     NULL,

  974.     raw_read_header,

  975.     rawvideo_read_packet,

  976.     .flags= AVFMT_GENERIC_INDEX,

  977.     .extensions = "yuv,cif,qcif,rgb",

  978.     .value = CODEC_ID_RAWVIDEO,

  979. };

  980. #endif

  981. 

  982. #ifdef CONFIG_RAWVIDEO_MUXER

  983. AVOutputFormat rawvideo_muxer = {

  984.     "rawvideo",

  985.     NULL_IF_CONFIG_SMALL("raw video format"),

  986.     NULL,

  987.     "yuv,rgb",

  988.     0,

  989.     CODEC_ID_NONE,

  990.     CODEC_ID_RAWVIDEO,

  991.     NULL,

  992.     raw_write_packet,

  993.     .flags= AVFMT_NOTIMESTAMPS,

  994. };

  995. #endif

  996. 

  997. #ifdef CONFIG_ROQ_MUXER

  998. AVOutputFormat roq_muxer =

  999. {

  1000.     "RoQ",

  1001.     NULL_IF_CONFIG_SMALL("id RoQ format"),

  1002.     NULL,

  1003.     "roq",

  1004.     0,

  1005.     CODEC_ID_ROQ_DPCM,

  1006.     CODEC_ID_ROQ,

  1007.     roq_write_header,

  1008.     raw_write_packet,

  1009. };

  1010. #endif

  1011. 

  1012. #ifdef CONFIG_SHORTEN_DEMUXER

  1013. AVInputFormat shorten_demuxer = {

  1014.     "shn",

  1015.     NULL_IF_CONFIG_SMALL("raw Shorten"),

  1016.     0,

  1017.     NULL,

  1018.     audio_read_header,

  1019.     raw_read_partial_packet,

  1020.     .flags= AVFMT_GENERIC_INDEX,

  1021.     .extensions = "shn",

  1022.     .value = CODEC_ID_SHORTEN,

  1023. };

  1024. #endif

  1025. 

  1026. #ifdef CONFIG_VC1_DEMUXER

  1027. AVInputFormat vc1_demuxer = {

  1028.     "vc1",

  1029.     NULL_IF_CONFIG_SMALL("raw VC-1"),

  1030.     0,

  1031.     NULL /* vc1_probe */,

  1032.     video_read_header,

  1033.     raw_read_partial_packet,

  1034.     .extensions = "vc1",

  1035.     .value = CODEC_ID_VC1,

  1036. };

  1037. #endif

  1038. 

  1039. /* PCM formats */

  1040. 

  1041. #define PCMINPUTDEF(name, long_name, ext, codec) \

  1042. AVInputFormat pcm_ ## name ## _demuxer = {\

  1043.     #name,\

  1044.     NULL_IF_CONFIG_SMALL(long_name),\

  1045.     0,\

  1046.     NULL,\

  1047.     raw_read_header,\

  1048.     raw_read_packet,\

  1049.     NULL,\

  1050.     pcm_read_seek,\

  1051.     .flags= AVFMT_GENERIC_INDEX,\

  1052.     .extensions = ext,\

  1053.     .value = codec,\

  1054. };

  1055. 

  1056. #define PCMOUTPUTDEF(name, long_name, ext, codec) \

  1057. AVOutputFormat pcm_ ## name ## _muxer = {\

  1058.     #name,\

  1059.     NULL_IF_CONFIG_SMALL(long_name),\

  1060.     NULL,\

  1061.     ext,\

  1062.     0,\

  1063.     codec,\

  1064.     CODEC_ID_NONE,\

  1065.     NULL,\

  1066.     raw_write_packet,\

  1067.     .flags= AVFMT_NOTIMESTAMPS,\

  1068. };

  1069. 

  1070. 

  1071. #if !defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)

  1072. #define PCMDEF(name, long_name, ext, codec) \

  1073.         PCMINPUTDEF(name, long_name, ext, codec)

  1074. #elif defined(CONFIG_MUXERS) && !defined(CONFIG_DEMUXERS)

  1075. #define PCMDEF(name, long_name, ext, codec) \

  1076.         PCMOUTPUTDEF(name, long_name, ext, codec)

  1077. #elif defined(CONFIG_MUXERS) && defined(CONFIG_DEMUXERS)

  1078. #define PCMDEF(name, long_name, ext, codec) \

  1079.         PCMINPUTDEF(name, long_name, ext, codec)\

  1080.         PCMOUTPUTDEF(name, long_name, ext, codec)

  1081. #else

  1082. #define PCMDEF(name, long_name, ext, codec)

  1083. #endif

  1084. 

  1085. #ifdef WORDS_BIGENDIAN

  1086. #define BE_DEF(s) s

  1087. #define LE_DEF(s) NULL

  1088. #else

  1089. #define BE_DEF(s) NULL

  1090. #define LE_DEF(s) s

  1091. #endif

  1092. 

  1093. PCMDEF(f64be, "PCM 64 bit floating-point big-endian format",

  1094.        NULL, CODEC_ID_PCM_F64BE)

  1095. 

  1096. PCMDEF(f64le, "PCM 64 bit floating-point little-endian format",

  1097.        NULL, CODEC_ID_PCM_F64LE)

  1098. 

  1099. PCMDEF(f32be, "PCM 32 bit floating-point big-endian format",

  1100.        NULL, CODEC_ID_PCM_F32BE)

  1101. 

  1102. PCMDEF(f32le, "PCM 32 bit floating-point little-endian format",

  1103.        NULL, CODEC_ID_PCM_F32LE)

  1104. 

  1105. PCMDEF(s32be, "PCM signed 32 bit big-endian format",

  1106.        NULL, CODEC_ID_PCM_S32BE)

  1107. 

  1108. PCMDEF(s32le, "PCM signed 32 bit little-endian format",

  1109.        NULL, CODEC_ID_PCM_S32LE)

  1110. 

  1111. PCMDEF(s24be, "PCM signed 24 bit big-endian format",

  1112.        NULL, CODEC_ID_PCM_S24BE)

  1113. 

  1114. PCMDEF(s24le, "PCM signed 24 bit little-endian format",

  1115.        NULL, CODEC_ID_PCM_S24LE)

  1116. 

  1117. PCMDEF(s16be, "PCM signed 16 bit big-endian format",

  1118.        BE_DEF("sw"), CODEC_ID_PCM_S16BE)

  1119. 

  1120. PCMDEF(s16le, "PCM signed 16 bit little-endian format",

  1121.        LE_DEF("sw"), CODEC_ID_PCM_S16LE)

  1122. 

  1123. PCMDEF(s8, "PCM signed 8 bit format",

  1124.        "sb", CODEC_ID_PCM_S8)

  1125. 

  1126. PCMDEF(u32be, "PCM unsigned 32 bit big-endian format",

  1127.        NULL, CODEC_ID_PCM_U32BE)

  1128. 

  1129. PCMDEF(u32le, "PCM unsigned 32 bit little-endian format",

  1130.        NULL, CODEC_ID_PCM_U32LE)

  1131. 

  1132. PCMDEF(u24be, "PCM unsigned 24 bit big-endian format",

  1133.        NULL, CODEC_ID_PCM_U24BE)

  1134. 

  1135. PCMDEF(u24le, "PCM unsigned 24 bit little-endian format",

  1136.        NULL, CODEC_ID_PCM_U24LE)

  1137. 

  1138. PCMDEF(u16be, "PCM unsigned 16 bit big-endian format",

  1139.        BE_DEF("uw"), CODEC_ID_PCM_U16BE)

  1140. 

  1141. PCMDEF(u16le, "PCM unsigned 16 bit little-endian format",

  1142.        LE_DEF("uw"), CODEC_ID_PCM_U16LE)

  1143. 

  1144. PCMDEF(u8, "PCM unsigned 8 bit format",

  1145.        "ub", CODEC_ID_PCM_U8)

  1146. 

  1147. PCMDEF(alaw, "PCM A-law format",

  1148.        "al", CODEC_ID_PCM_ALAW)

  1149. 

  1150. PCMDEF(mulaw, "PCM mu-law format",

  1151.        "ul", CODEC_ID_PCM_MULAW)