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.
20959 Commits
32 Branches
290MB
Tree: 6945c2bc4c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6945c2bc4c'
${ noResults }
FFmpeg/libavformat/raw.c

1363 lines
33KB
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/get_bits.h"

  26. #include "libavcodec/bytestream.h"

  27. #include "avformat.h"

  28. #include "raw.h"

  29. #include "id3v2.h"

  30. #include "id3v1.h"

  31. 

  32. /* simple formats */

  33. 

  34. #if CONFIG_ROQ_MUXER

  35. static int roq_write_header(struct AVFormatContext *s)

  36. {

  37.     static const uint8_t header[] = {

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

  39.     };

  40. 

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

  42.     put_flush_packet(s->pb);

  43. 

  44.     return 0;

  45. }

  46. #endif

  47. 

  48. #if CONFIG_NULL_MUXER

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

  50. {

  51.     return 0;

  52. }

  53. #endif

  54. 

  55. #if CONFIG_MUXERS

  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

  63. 

  64. #if CONFIG_DEMUXERS

  65. /* raw input */

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

  67. {

  68.     AVStream *st;

  69.     int id;

  70. 

  71.     st = av_new_stream(s, 0);

  72.     if (!st)

  73.         return AVERROR(ENOMEM);

  74. 

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

  76.         if (id == CODEC_ID_RAWVIDEO) {

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

  78.         } else {

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

  80.         }

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

  82. 

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

  84.         case CODEC_TYPE_AUDIO:

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

  86.             if(ap->channels) st->codec->channels = ap->channels;

  87.             else             st->codec->channels = 1;

  88.             st->codec->bits_per_coded_sample = av_get_bits_per_sample(st->codec->codec_id);

  89.             assert(st->codec->bits_per_coded_sample > 0);

  90.             st->codec->block_align = st->codec->bits_per_coded_sample*st->codec->channels/8;

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

  92.             break;

  93.         case CODEC_TYPE_VIDEO:

  94.             if(ap->time_base.num)

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

  96.             else

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

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

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

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

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

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

  103.             break;

  104.         default:

  105.             return -1;

  106.         }

  107.     return 0;

  108. }

  109. 

  110. #define RAW_PACKET_SIZE 1024

  111. #define RAW_SAMPLES     1024

  112. 

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

  114. {

  115.     int ret, size, bps;

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

  117. 

  118.     size= RAW_SAMPLES*s->streams[0]->codec->block_align;

  119. 

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

  121. 

  122.     pkt->stream_index = 0;

  123.     if (ret <= 0) {

  124.         return AVERROR(EIO);

  125.     }

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

  127.        packet */

  128.     pkt->size = ret;

  129. 

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

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

  132.     pkt->dts=

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

  134. 

  135.     return ret;

  136. }

  137. 

  138. int ff_raw_read_partial_packet(AVFormatContext *s, AVPacket *pkt)

  139. {

  140.     int ret, size;

  141. 

  142.     size = RAW_PACKET_SIZE;

  143. 

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

  145.         return AVERROR(EIO);

  146. 

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

  148.     pkt->stream_index = 0;

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

  150.     if (ret <= 0) {

  151.         av_free_packet(pkt);

  152.         return AVERROR(EIO);

  153.     }

  154.     pkt->size = ret;

  155.     return ret;

  156. }

  157. #endif

  158. 

  159. #if CONFIG_RAWVIDEO_DEMUXER

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

  161. {

  162.     int packet_size, ret, width, height;

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

  164. 

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

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

  167. 

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

  169.     if (packet_size < 0)

  170.         return -1;

  171. 

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

  173.     pkt->pts=

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

  175. 

  176.     pkt->stream_index = 0;

  177.     if (ret != packet_size) {

  178.         return AVERROR(EIO);

  179.     } else {

  180.         return 0;

  181.     }

  182. }

  183. #endif

  184. 

  185. #if CONFIG_INGENIENT_DEMUXER

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

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

  188. {

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

  190. 

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

  192.         return AVERROR(EIO); // FIXME

  193. 

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

  195. 

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

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

  198. 

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

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

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

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

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

  204. 

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

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

  207. 

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

  209.         return AVERROR(EIO);

  210. 

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

  212.     pkt->stream_index = 0;

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

  214.     if (ret <= 0) {

  215.         av_free_packet(pkt);

  216.         return AVERROR(EIO);

  217.     }

  218.     pkt->size = ret;

  219.     return ret;

  220. }

  221. #endif

  222. 

  223. #if CONFIG_DEMUXERS

  224. int pcm_read_seek(AVFormatContext *s,

  225.                   int stream_index, int64_t timestamp, int flags)

  226. {

  227.     AVStream *st;

  228.     int block_align, byte_rate, ret;

  229.     int64_t pos;

  230. 

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

  232. 

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

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

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

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

  237. 

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

  239.         return -1;

  240.     if (timestamp < 0) timestamp = 0;

  241. 

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

  243.     pos = av_rescale_rnd(timestamp * byte_rate,

  244.                          st->time_base.num,

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

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

  247.     pos *= block_align;

  248. 

  249.     /* recompute exact position */

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

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

  252.         return ret;

  253.     return 0;

  254. }

  255. 

  256. static int audio_read_header(AVFormatContext *s,

  257.                              AVFormatParameters *ap)

  258. {

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

  260.     if (!st)

  261.         return AVERROR(ENOMEM);

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

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

  264.     st->need_parsing = AVSTREAM_PARSE_FULL;

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

  266. 

  267.     return 0;

  268. }

  269. 

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

  271. static int video_read_header(AVFormatContext *s,

  272.                              AVFormatParameters *ap)

  273. {

  274.     AVStream *st;

  275. 

  276.     st = av_new_stream(s, 0);

  277.     if (!st)

  278.         return AVERROR(ENOMEM);

  279. 

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

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

  282.     st->need_parsing = AVSTREAM_PARSE_FULL;

  283. 

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

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

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

  287.         st->codec->time_base= ap->time_base;

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

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

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

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

  292.         st->codec->time_base= (AVRational){1,25};

  293.     }

  294.     av_set_pts_info(st, 64, 1, 1200000);

  295. 

  296.     return 0;

  297. }

  298. #endif

  299. 

  300. #if CONFIG_MPEGVIDEO_DEMUXER

  301. #define SEQ_START_CODE          0x000001b3

  302. #define GOP_START_CODE          0x000001b8

  303. #define PICTURE_START_CODE      0x00000100

  304. #define SLICE_START_CODE        0x00000101

  305. #define PACK_START_CODE         0x000001ba

  306. #define VIDEO_ID                0x000001e0

  307. #define AUDIO_ID                0x000001c0

  308. 

  309. static int mpegvideo_probe(AVProbeData *p)

  310. {

  311.     uint32_t code= -1;

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

  313.     int i;

  314. 

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

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

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

  318.             switch(code){

  319.             case     SEQ_START_CODE:   seq++; break;

  320.             case PICTURE_START_CODE:   pic++; break;

  321.             case   SLICE_START_CODE: slice++; break;

  322.             case    PACK_START_CODE: pspack++; break;

  323.             }

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

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

  326.         }

  327.     }

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

  329.         return pic>1 ? AVPROBE_SCORE_MAX/2+1 : AVPROBE_SCORE_MAX/4; // +1 for .mpg

  330.     return 0;

  331. }

  332. #endif

  333. 

  334. #if CONFIG_CAVSVIDEO_DEMUXER

  335. #define CAVS_SEQ_START_CODE       0x000001b0

  336. #define CAVS_PIC_I_START_CODE     0x000001b3

  337. #define CAVS_UNDEF_START_CODE     0x000001b4

  338. #define CAVS_PIC_PB_START_CODE    0x000001b6

  339. #define CAVS_VIDEO_EDIT_CODE      0x000001b7

  340. #define CAVS_PROFILE_JIZHUN       0x20

  341. 

  342. static int cavsvideo_probe(AVProbeData *p)

  343. {

  344.     uint32_t code= -1;

  345.     int pic=0, seq=0, slice_pos = 0;

  346.     int i;

  347. 

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

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

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

  351.             if(code < CAVS_SEQ_START_CODE) {

  352.                 /* slices have to be consecutive */

  353.                 if(code < slice_pos)

  354.                     return 0;

  355.                 slice_pos = code;

  356.             } else {

  357.                 slice_pos = 0;

  358.             }

  359.             if (code == CAVS_SEQ_START_CODE) {

  360.                 seq++;

  361.                 /* check for the only currently supported profile */

  362.                 if(p->buf[i+1] != CAVS_PROFILE_JIZHUN)

  363.                     return 0;

  364.             } else if ((code == CAVS_PIC_I_START_CODE) ||

  365.                        (code == CAVS_PIC_PB_START_CODE)) {

  366.                 pic++;

  367.             } else if ((code == CAVS_UNDEF_START_CODE) ||

  368.                        (code >  CAVS_VIDEO_EDIT_CODE)) {

  369.                 return 0;

  370.             }

  371.         }

  372.     }

  373.     if(seq && seq*9<=pic*10)

  374.         return AVPROBE_SCORE_MAX/2;

  375.     return 0;

  376. }

  377. #endif

  378. 

  379. #if CONFIG_M4V_DEMUXER

  380. #define VISUAL_OBJECT_START_CODE       0x000001b5

  381. #define VOP_START_CODE                 0x000001b6

  382. 

  383. static int mpeg4video_probe(AVProbeData *probe_packet)

  384. {

  385.     uint32_t temp_buffer= -1;

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

  387.     int i;

  388. 

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

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

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

  392.             continue;

  393. 

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

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

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

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

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

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

  400.     }

  401. 

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

  403.         return AVPROBE_SCORE_MAX/2;

  404.     return 0;

  405. }

  406. #endif

  407. 

  408. #if CONFIG_H264_DEMUXER

  409. static int h264_probe(AVProbeData *p)

  410. {

  411.     uint32_t code= -1;

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

  413.     int i;

  414. 

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

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

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

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

  419.             int type   = code & 0x1F;

  420.             static const int8_t ref_zero[32]={

  421.                 2, 0, 0, 0, 0,-1, 1,-1,

  422.                -1, 1, 1, 1, 1,-1, 2, 2,

  423.                 2, 2, 2, 0, 2, 2, 2, 2,

  424.                 2, 2, 2, 2, 2, 2, 2, 2

  425.             };

  426. 

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

  428.                 return 0;

  429. 

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

  431.                 return 0;

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

  433.                 return 0;

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

  435.                 res++;

  436. 

  437.             switch(type){

  438.             case     1:   sli++; break;

  439.             case     5:   idr++; break;

  440.             case     7:

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

  442.                     return 0;

  443.                 sps++;

  444.                 break;

  445.             case     8:   pps++; break;

  446.             }

  447.         }

  448.     }

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

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

  451.     return 0;

  452. }

  453. #endif

  454. 

  455. #if CONFIG_H263_DEMUXER

  456. static int h263_probe(AVProbeData *p)

  457. {

  458.     uint64_t code= -1;

  459.     int i;

  460.     int valid_psc=0;

  461.     int invalid_psc=0;

  462.     int res_change=0;

  463.     int src_fmt, last_src_fmt=-1;

  464. 

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

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

  467.         if ((code & 0xfffffc0000) == 0x800000) {

  468.             src_fmt= (code>>2)&3;

  469.             if(   src_fmt != last_src_fmt

  470.                && last_src_fmt>0 && last_src_fmt<6

  471.                && src_fmt<6)

  472.                 res_change++;

  473. 

  474.             if((code&0x300)==0x200 && src_fmt){

  475.                 valid_psc++;

  476.             }else

  477.                 invalid_psc++;

  478.             last_src_fmt= src_fmt;

  479.         }

  480.     }

  481.     if(valid_psc > 2*invalid_psc + 2*res_change + 2){

  482.         return 50;

  483.     }else if(valid_psc > 2*invalid_psc)

  484.         return 25;

  485.     return 0;

  486. }

  487. #endif

  488. 

  489. #if CONFIG_H261_DEMUXER

  490. static int h261_probe(AVProbeData *p)

  491. {

  492.     uint32_t code= -1;

  493.     int i;

  494.     int valid_psc=0;

  495.     int invalid_psc=0;

  496.     int next_gn=0;

  497.     int src_fmt=0;

  498.     GetBitContext gb;

  499. 

  500.     init_get_bits(&gb, p->buf, p->buf_size*8);

  501. 

  502.     for(i=0; i<p->buf_size*8; i++){

  503.         code = (code<<1) + get_bits1(&gb);

  504.         if ((code & 0xffff0000) == 0x10000) {

  505.             int gn= (code>>12)&0xf;

  506.             if(!gn)

  507.                 src_fmt= code&8;

  508.             if(gn != next_gn) invalid_psc++;

  509.             else              valid_psc++;

  510. 

  511.             if(src_fmt){ // CIF

  512.                 next_gn= (gn+1     )%13;

  513.             }else{       //QCIF

  514.                 next_gn= (gn+1+!!gn)% 7;

  515.             }

  516.         }

  517.     }

  518.     if(valid_psc > 2*invalid_psc + 6){

  519.         return 50;

  520.     }else if(valid_psc > 2*invalid_psc + 2)

  521.         return 25;

  522.     return 0;

  523. }

  524. #endif

  525. 

  526. #if CONFIG_DTS_DEMUXER

  527. #define DCA_MARKER_14B_BE 0x1FFFE800

  528. #define DCA_MARKER_14B_LE 0xFF1F00E8

  529. #define DCA_MARKER_RAW_BE 0x7FFE8001

  530. #define DCA_MARKER_RAW_LE 0xFE7F0180

  531. static int dts_probe(AVProbeData *p)

  532. {

  533.     const uint8_t *buf, *bufp;

  534.     uint32_t state = -1;

  535.     int markers[3] = {0};

  536.     int sum, max;

  537. 

  538.     buf = p->buf;

  539. 

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

  541.         bufp = buf;

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

  543. 

  544.         /* regular bitstream */

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

  546.             markers[0]++;

  547. 

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

  549.         if (state == DCA_MARKER_14B_BE)

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

  551.                 markers[1]++;

  552. 

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

  554.         if (state == DCA_MARKER_14B_LE)

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

  556.                 markers[2]++;

  557.     }

  558.     sum = markers[0] + markers[1] + markers[2];

  559.     max = markers[1] > markers[0];

  560.     max = markers[2] > markers[max] ? 2 : max;

  561.     if (markers[max] > 3 && p->buf_size / markers[max] < 32*1024 &&

  562.         markers[max] * 4 > sum * 3)

  563.         return AVPROBE_SCORE_MAX/2+1;

  564. 

  565.     return 0;

  566. }

  567. #endif

  568. 

  569. #if CONFIG_DIRAC_DEMUXER

  570. static int dirac_probe(AVProbeData *p)

  571. {

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

  573.         return AVPROBE_SCORE_MAX;

  574.     else

  575.         return 0;

  576. }

  577. #endif

  578. 

  579. #if CONFIG_DNXHD_DEMUXER

  580. static int dnxhd_probe(AVProbeData *p)

  581. {

  582.     static const uint8_t header[] = {0x00,0x00,0x02,0x80,0x01};

  583.     int w, h, compression_id;

  584.     if (p->buf_size < 0x2c)

  585.         return 0;

  586.     if (memcmp(p->buf, header, 5))

  587.         return 0;

  588.     h = AV_RB16(p->buf + 0x18);

  589.     w = AV_RB16(p->buf + 0x1a);

  590.     if (!w || !h)

  591.         return 0;

  592.     compression_id = AV_RB32(p->buf + 0x28);

  593.     if (compression_id < 1237 || compression_id > 1253)

  594.         return 0;

  595.     return AVPROBE_SCORE_MAX;

  596. }

  597. #endif

  598. 

  599. #if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER

  600. static int ac3_eac3_probe(AVProbeData *p, enum CodecID expected_codec_id)

  601. {

  602.     int max_frames, first_frames = 0, frames;

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

  604.     AC3HeaderInfo hdr;

  605.     GetBitContext gbc;

  606.     enum CodecID codec_id = CODEC_ID_AC3;

  607. 

  608.     max_frames = 0;

  609.     buf = p->buf;

  610.     end = buf + p->buf_size;

  611. 

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

  613.         buf2 = buf;

  614. 

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

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

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

  618.                 break;

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

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

  621.                 break;

  622.             if (hdr.bitstream_id > 10)

  623.                 codec_id = CODEC_ID_EAC3;

  624.             buf2 += hdr.frame_size;

  625.         }

  626.         max_frames = FFMAX(max_frames, frames);

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

  628.             first_frames = frames;

  629.     }

  630.     if(codec_id != expected_codec_id) return 0;

  631.     // keep this in sync with mp3 probe, both need to avoid

  632.     // issues with MPEG-files!

  633.     if   (first_frames>=4) return AVPROBE_SCORE_MAX/2+1;

  634.     else if(max_frames>500)return AVPROBE_SCORE_MAX/2;

  635.     else if(max_frames>=4) return AVPROBE_SCORE_MAX/4;

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

  637.     else                   return 0;

  638. }

  639. #endif

  640. 

  641. #if CONFIG_AC3_DEMUXER

  642. static int ac3_probe(AVProbeData *p)

  643. {

  644.     return ac3_eac3_probe(p, CODEC_ID_AC3);

  645. }

  646. #endif

  647. 

  648. #if CONFIG_EAC3_DEMUXER

  649. static int eac3_probe(AVProbeData *p)

  650. {

  651.     return ac3_eac3_probe(p, CODEC_ID_EAC3);

  652. }

  653. #endif

  654. 

  655. #if CONFIG_AAC_DEMUXER

  656. static int adts_aac_probe(AVProbeData *p)

  657. {

  658.     int max_frames = 0, first_frames = 0;

  659.     int fsize, frames;

  660.     uint8_t *buf0 = p->buf;

  661.     uint8_t *buf2;

  662.     uint8_t *buf;

  663.     uint8_t *end = buf0 + p->buf_size - 7;

  664. 

  665.     if (ff_id3v2_match(buf0)) {

  666.         buf0 += ff_id3v2_tag_len(buf0);

  667.     }

  668.     buf = buf0;

  669. 

  670.     for(; buf < end; buf= buf2+1) {

  671.         buf2 = buf;

  672. 

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

  674.             uint32_t header = AV_RB16(buf2);

  675.             if((header&0xFFF6) != 0xFFF0)

  676.                 break;

  677.             fsize = (AV_RB32(buf2+3)>>13) & 0x8FFF;

  678.             if(fsize < 7)

  679.                 break;

  680.             buf2 += fsize;

  681.         }

  682.         max_frames = FFMAX(max_frames, frames);

  683.         if(buf == buf0)

  684.             first_frames= frames;

  685.     }

  686.     if   (first_frames>=3) return AVPROBE_SCORE_MAX/2+1;

  687.     else if(max_frames>500)return AVPROBE_SCORE_MAX/2;

  688.     else if(max_frames>=3) return AVPROBE_SCORE_MAX/4;

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

  690.     else                   return 0;

  691. }

  692. 

  693. static int adts_aac_read_header(AVFormatContext *s,

  694.                                 AVFormatParameters *ap)

  695. {

  696.     AVStream *st;

  697. 

  698.     st = av_new_stream(s, 0);

  699.     if (!st)

  700.         return AVERROR(ENOMEM);

  701. 

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

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

  704.     st->need_parsing = AVSTREAM_PARSE_FULL;

  705. 

  706.     ff_id3v1_read(s);

  707.     ff_id3v2_read(s);

  708. 

  709.     return 0;

  710. }

  711. 

  712. #endif

  713. 

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

  715. 

  716. #if CONFIG_AAC_DEMUXER

  717. AVInputFormat aac_demuxer = {

  718.     "aac",

  719.     NULL_IF_CONFIG_SMALL("raw ADTS AAC"),

  720.     0,

  721.     adts_aac_probe,

  722.     adts_aac_read_header,

  723.     ff_raw_read_partial_packet,

  724.     .flags= AVFMT_GENERIC_INDEX,

  725.     .extensions = "aac",

  726.     .value = CODEC_ID_AAC,

  727. };

  728. #endif

  729. 

  730. #if CONFIG_AC3_DEMUXER

  731. AVInputFormat ac3_demuxer = {

  732.     "ac3",

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

  734.     0,

  735.     ac3_probe,

  736.     audio_read_header,

  737.     ff_raw_read_partial_packet,

  738.     .flags= AVFMT_GENERIC_INDEX,

  739.     .extensions = "ac3",

  740.     .value = CODEC_ID_AC3,

  741. };

  742. #endif

  743. 

  744. #if CONFIG_AC3_MUXER

  745. AVOutputFormat ac3_muxer = {

  746.     "ac3",

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

  748.     "audio/x-ac3",

  749.     "ac3",

  750.     0,

  751.     CODEC_ID_AC3,

  752.     CODEC_ID_NONE,

  753.     NULL,

  754.     raw_write_packet,

  755.     .flags= AVFMT_NOTIMESTAMPS,

  756. };

  757. #endif

  758. 

  759. #if CONFIG_DIRAC_DEMUXER

  760. AVInputFormat dirac_demuxer = {

  761.     "dirac",

  762.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  763.     0,

  764.     dirac_probe,

  765.     video_read_header,

  766.     ff_raw_read_partial_packet,

  767.     .flags= AVFMT_GENERIC_INDEX,

  768.     .value = CODEC_ID_DIRAC,

  769. };

  770. #endif

  771. 

  772. #if CONFIG_DIRAC_MUXER

  773. AVOutputFormat dirac_muxer = {

  774.     "dirac",

  775.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  776.     NULL,

  777.     "drc",

  778.     0,

  779.     CODEC_ID_NONE,

  780.     CODEC_ID_DIRAC,

  781.     NULL,

  782.     raw_write_packet,

  783.     .flags= AVFMT_NOTIMESTAMPS,

  784. };

  785. #endif

  786. 

  787. #if CONFIG_DNXHD_DEMUXER

  788. AVInputFormat dnxhd_demuxer = {

  789.     "dnxhd",

  790.     NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),

  791.     0,

  792.     dnxhd_probe,

  793.     video_read_header,

  794.     ff_raw_read_partial_packet,

  795.     .flags= AVFMT_GENERIC_INDEX,

  796.     .value = CODEC_ID_DNXHD,

  797. };

  798. #endif

  799. 

  800. #if CONFIG_DNXHD_MUXER

  801. AVOutputFormat dnxhd_muxer = {

  802.     "dnxhd",

  803.     NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),

  804.     NULL,

  805.     "dnxhd",

  806.     0,

  807.     CODEC_ID_NONE,

  808.     CODEC_ID_DNXHD,

  809.     NULL,

  810.     raw_write_packet,

  811.     .flags= AVFMT_NOTIMESTAMPS,

  812. };

  813. #endif

  814. 

  815. #if CONFIG_DTS_DEMUXER

  816. AVInputFormat dts_demuxer = {

  817.     "dts",

  818.     NULL_IF_CONFIG_SMALL("raw DTS"),

  819.     0,

  820.     dts_probe,

  821.     audio_read_header,

  822.     ff_raw_read_partial_packet,

  823.     .flags= AVFMT_GENERIC_INDEX,

  824.     .extensions = "dts",

  825.     .value = CODEC_ID_DTS,

  826. };

  827. #endif

  828. 

  829. #if CONFIG_DTS_MUXER

  830. AVOutputFormat dts_muxer = {

  831.     "dts",

  832.     NULL_IF_CONFIG_SMALL("raw DTS"),

  833.     "audio/x-dca",

  834.     "dts",

  835.     0,

  836.     CODEC_ID_DTS,

  837.     CODEC_ID_NONE,

  838.     NULL,

  839.     raw_write_packet,

  840.     .flags= AVFMT_NOTIMESTAMPS,

  841. };

  842. #endif

  843. 

  844. #if CONFIG_EAC3_DEMUXER

  845. AVInputFormat eac3_demuxer = {

  846.     "eac3",

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

  848.     0,

  849.     eac3_probe,

  850.     audio_read_header,

  851.     ff_raw_read_partial_packet,

  852.     .flags= AVFMT_GENERIC_INDEX,

  853.     .extensions = "eac3",

  854.     .value = CODEC_ID_EAC3,

  855. };

  856. #endif

  857. 

  858. #if CONFIG_EAC3_MUXER

  859. AVOutputFormat eac3_muxer = {

  860.     "eac3",

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

  862.     "audio/x-eac3",

  863.     "eac3",

  864.     0,

  865.     CODEC_ID_EAC3,

  866.     CODEC_ID_NONE,

  867.     NULL,

  868.     raw_write_packet,

  869.     .flags= AVFMT_NOTIMESTAMPS,

  870. };

  871. #endif

  872. 

  873. #if CONFIG_GSM_DEMUXER

  874. AVInputFormat gsm_demuxer = {

  875.     "gsm",

  876.     NULL_IF_CONFIG_SMALL("raw GSM"),

  877.     0,

  878.     NULL,

  879.     audio_read_header,

  880.     ff_raw_read_partial_packet,

  881.     .flags= AVFMT_GENERIC_INDEX,

  882.     .extensions = "gsm",

  883.     .value = CODEC_ID_GSM,

  884. };

  885. #endif

  886. 

  887. #if CONFIG_H261_DEMUXER

  888. AVInputFormat h261_demuxer = {

  889.     "h261",

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

  891.     0,

  892.     h261_probe,

  893.     video_read_header,

  894.     ff_raw_read_partial_packet,

  895.     .flags= AVFMT_GENERIC_INDEX,

  896.     .extensions = "h261",

  897.     .value = CODEC_ID_H261,

  898. };

  899. #endif

  900. 

  901. #if CONFIG_H261_MUXER

  902. AVOutputFormat h261_muxer = {

  903.     "h261",

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

  905.     "video/x-h261",

  906.     "h261",

  907.     0,

  908.     CODEC_ID_NONE,

  909.     CODEC_ID_H261,

  910.     NULL,

  911.     raw_write_packet,

  912.     .flags= AVFMT_NOTIMESTAMPS,

  913. };

  914. #endif

  915. 

  916. #if CONFIG_H263_DEMUXER

  917. AVInputFormat h263_demuxer = {

  918.     "h263",

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

  920.     0,

  921.     h263_probe,

  922.     video_read_header,

  923.     ff_raw_read_partial_packet,

  924.     .flags= AVFMT_GENERIC_INDEX,

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

  926.     .value = CODEC_ID_H263,

  927. };

  928. #endif

  929. 

  930. #if CONFIG_H263_MUXER

  931. AVOutputFormat h263_muxer = {

  932.     "h263",

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

  934.     "video/x-h263",

  935.     "h263",

  936.     0,

  937.     CODEC_ID_NONE,

  938.     CODEC_ID_H263,

  939.     NULL,

  940.     raw_write_packet,

  941.     .flags= AVFMT_NOTIMESTAMPS,

  942. };

  943. #endif

  944. 

  945. #if CONFIG_H264_DEMUXER

  946. AVInputFormat h264_demuxer = {

  947.     "h264",

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

  949.     0,

  950.     h264_probe,

  951.     video_read_header,

  952.     ff_raw_read_partial_packet,

  953.     .flags= AVFMT_GENERIC_INDEX,

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

  955.     .value = CODEC_ID_H264,

  956. };

  957. #endif

  958. 

  959. #if CONFIG_H264_MUXER

  960. AVOutputFormat h264_muxer = {

  961.     "h264",

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

  963.     NULL,

  964.     "h264",

  965.     0,

  966.     CODEC_ID_NONE,

  967.     CODEC_ID_H264,

  968.     NULL,

  969.     raw_write_packet,

  970.     .flags= AVFMT_NOTIMESTAMPS,

  971. };

  972. #endif

  973. 

  974. #if CONFIG_INGENIENT_DEMUXER

  975. AVInputFormat ingenient_demuxer = {

  976.     "ingenient",

  977.     NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),

  978.     0,

  979.     NULL,

  980.     video_read_header,

  981.     ingenient_read_packet,

  982.     .flags= AVFMT_GENERIC_INDEX,

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

  984.     .value = CODEC_ID_MJPEG,

  985. };

  986. #endif

  987. 

  988. #if CONFIG_M4V_DEMUXER

  989. AVInputFormat m4v_demuxer = {

  990.     "m4v",

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

  992.     0,

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

  994.     video_read_header,

  995.     ff_raw_read_partial_packet,

  996.     .flags= AVFMT_GENERIC_INDEX,

  997.     .extensions = "m4v",

  998.     .value = CODEC_ID_MPEG4,

  999. };

  1000. #endif

  1001. 

  1002. #if CONFIG_M4V_MUXER

  1003. AVOutputFormat m4v_muxer = {

  1004.     "m4v",

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

  1006.     NULL,

  1007.     "m4v",

  1008.     0,

  1009.     CODEC_ID_NONE,

  1010.     CODEC_ID_MPEG4,

  1011.     NULL,

  1012.     raw_write_packet,

  1013.     .flags= AVFMT_NOTIMESTAMPS,

  1014. };

  1015. #endif

  1016. 

  1017. #if CONFIG_MJPEG_DEMUXER

  1018. AVInputFormat mjpeg_demuxer = {

  1019.     "mjpeg",

  1020.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  1021.     0,

  1022.     NULL,

  1023.     video_read_header,

  1024.     ff_raw_read_partial_packet,

  1025.     .flags= AVFMT_GENERIC_INDEX,

  1026.     .extensions = "mjpg,mjpeg",

  1027.     .value = CODEC_ID_MJPEG,

  1028. };

  1029. #endif

  1030. 

  1031. #if CONFIG_MJPEG_MUXER

  1032. AVOutputFormat mjpeg_muxer = {

  1033.     "mjpeg",

  1034.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  1035.     "video/x-mjpeg",

  1036.     "mjpg,mjpeg",

  1037.     0,

  1038.     CODEC_ID_NONE,

  1039.     CODEC_ID_MJPEG,

  1040.     NULL,

  1041.     raw_write_packet,

  1042.     .flags= AVFMT_NOTIMESTAMPS,

  1043. };

  1044. #endif

  1045. 

  1046. #if CONFIG_MLP_DEMUXER

  1047. AVInputFormat mlp_demuxer = {

  1048.     "mlp",

  1049.     NULL_IF_CONFIG_SMALL("raw MLP"),

  1050.     0,

  1051.     NULL,

  1052.     audio_read_header,

  1053.     ff_raw_read_partial_packet,

  1054.     .flags= AVFMT_GENERIC_INDEX,

  1055.     .extensions = "mlp",

  1056.     .value = CODEC_ID_MLP,

  1057. };

  1058. #endif

  1059. 

  1060. #if CONFIG_MLP_MUXER

  1061. AVOutputFormat mlp_muxer = {

  1062.     "mlp",

  1063.     NULL_IF_CONFIG_SMALL("raw MLP"),

  1064.     NULL,

  1065.     "mlp",

  1066.     0,

  1067.     CODEC_ID_MLP,

  1068.     CODEC_ID_NONE,

  1069.     NULL,

  1070.     raw_write_packet,

  1071.     .flags= AVFMT_NOTIMESTAMPS,

  1072. };

  1073. #endif

  1074. 

  1075. #if CONFIG_TRUEHD_DEMUXER

  1076. AVInputFormat truehd_demuxer = {

  1077.     "truehd",

  1078.     NULL_IF_CONFIG_SMALL("raw TrueHD"),

  1079.     0,

  1080.     NULL,

  1081.     audio_read_header,

  1082.     ff_raw_read_partial_packet,

  1083.     .flags= AVFMT_GENERIC_INDEX,

  1084.     .extensions = "thd",

  1085.     .value = CODEC_ID_TRUEHD,

  1086. };

  1087. #endif

  1088. 

  1089. #if CONFIG_TRUEHD_MUXER

  1090. AVOutputFormat truehd_muxer = {

  1091.     "truehd",

  1092.     NULL_IF_CONFIG_SMALL("raw TrueHD"),

  1093.     NULL,

  1094.     "thd",

  1095.     0,

  1096.     CODEC_ID_TRUEHD,

  1097.     CODEC_ID_NONE,

  1098.     NULL,

  1099.     raw_write_packet,

  1100.     .flags= AVFMT_NOTIMESTAMPS,

  1101. };

  1102. #endif

  1103. 

  1104. #if CONFIG_MPEG1VIDEO_MUXER

  1105. AVOutputFormat mpeg1video_muxer = {

  1106.     "mpeg1video",

  1107.     NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),

  1108.     "video/x-mpeg",

  1109.     "mpg,mpeg,m1v",

  1110.     0,

  1111.     CODEC_ID_NONE,

  1112.     CODEC_ID_MPEG1VIDEO,

  1113.     NULL,

  1114.     raw_write_packet,

  1115.     .flags= AVFMT_NOTIMESTAMPS,

  1116. };

  1117. #endif

  1118. 

  1119. #if CONFIG_MPEG2VIDEO_MUXER

  1120. AVOutputFormat mpeg2video_muxer = {

  1121.     "mpeg2video",

  1122.     NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),

  1123.     NULL,

  1124.     "m2v",

  1125.     0,

  1126.     CODEC_ID_NONE,

  1127.     CODEC_ID_MPEG2VIDEO,

  1128.     NULL,

  1129.     raw_write_packet,

  1130.     .flags= AVFMT_NOTIMESTAMPS,

  1131. };

  1132. #endif

  1133. 

  1134. #if CONFIG_MPEGVIDEO_DEMUXER

  1135. AVInputFormat mpegvideo_demuxer = {

  1136.     "mpegvideo",

  1137.     NULL_IF_CONFIG_SMALL("raw MPEG video"),

  1138.     0,

  1139.     mpegvideo_probe,

  1140.     video_read_header,

  1141.     ff_raw_read_partial_packet,

  1142.     .flags= AVFMT_GENERIC_INDEX,

  1143.     .value = CODEC_ID_MPEG1VIDEO,

  1144. };

  1145. #endif

  1146. 

  1147. #if CONFIG_CAVSVIDEO_DEMUXER

  1148. AVInputFormat cavsvideo_demuxer = {

  1149.     "cavsvideo",

  1150.     NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),

  1151.     0,

  1152.     cavsvideo_probe,

  1153.     video_read_header,

  1154.     ff_raw_read_partial_packet,

  1155.     .flags= AVFMT_GENERIC_INDEX,

  1156.     .value = CODEC_ID_CAVS,

  1157. };

  1158. #endif

  1159. 

  1160. #if CONFIG_NULL_MUXER

  1161. AVOutputFormat null_muxer = {

  1162.     "null",

  1163.     NULL_IF_CONFIG_SMALL("raw null video format"),

  1164.     NULL,

  1165.     NULL,

  1166.     0,

  1167. #if HAVE_BIGENDIAN

  1168.     CODEC_ID_PCM_S16BE,

  1169. #else

  1170.     CODEC_ID_PCM_S16LE,

  1171. #endif

  1172.     CODEC_ID_RAWVIDEO,

  1173.     NULL,

  1174.     null_write_packet,

  1175.     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,

  1176. };

  1177. #endif

  1178. 

  1179. #if CONFIG_RAWVIDEO_DEMUXER

  1180. AVInputFormat rawvideo_demuxer = {

  1181.     "rawvideo",

  1182.     NULL_IF_CONFIG_SMALL("raw video format"),

  1183.     0,

  1184.     NULL,

  1185.     raw_read_header,

  1186.     rawvideo_read_packet,

  1187.     .flags= AVFMT_GENERIC_INDEX,

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

  1189.     .value = CODEC_ID_RAWVIDEO,

  1190. };

  1191. #endif

  1192. 

  1193. #if CONFIG_RAWVIDEO_MUXER

  1194. AVOutputFormat rawvideo_muxer = {

  1195.     "rawvideo",

  1196.     NULL_IF_CONFIG_SMALL("raw video format"),

  1197.     NULL,

  1198.     "yuv,rgb",

  1199.     0,

  1200.     CODEC_ID_NONE,

  1201.     CODEC_ID_RAWVIDEO,

  1202.     NULL,

  1203.     raw_write_packet,

  1204.     .flags= AVFMT_NOTIMESTAMPS,

  1205. };

  1206. #endif

  1207. 

  1208. #if CONFIG_ROQ_MUXER

  1209. AVOutputFormat roq_muxer =

  1210. {

  1211.     "RoQ",

  1212.     NULL_IF_CONFIG_SMALL("raw id RoQ format"),

  1213.     NULL,

  1214.     "roq",

  1215.     0,

  1216.     CODEC_ID_ROQ_DPCM,

  1217.     CODEC_ID_ROQ,

  1218.     roq_write_header,

  1219.     raw_write_packet,

  1220. };

  1221. #endif

  1222. 

  1223. #if CONFIG_SHORTEN_DEMUXER

  1224. AVInputFormat shorten_demuxer = {

  1225.     "shn",

  1226.     NULL_IF_CONFIG_SMALL("raw Shorten"),

  1227.     0,

  1228.     NULL,

  1229.     audio_read_header,

  1230.     ff_raw_read_partial_packet,

  1231.     .flags= AVFMT_GENERIC_INDEX,

  1232.     .extensions = "shn",

  1233.     .value = CODEC_ID_SHORTEN,

  1234. };

  1235. #endif

  1236. 

  1237. #if CONFIG_VC1_DEMUXER

  1238. AVInputFormat vc1_demuxer = {

  1239.     "vc1",

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

  1241.     0,

  1242.     NULL /* vc1_probe */,

  1243.     video_read_header,

  1244.     ff_raw_read_partial_packet,

  1245.     .extensions = "vc1",

  1246.     .value = CODEC_ID_VC1,

  1247. };

  1248. #endif

  1249. 

  1250. /* PCM formats */

  1251. 

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

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

  1254.     #name,\

  1255.     NULL_IF_CONFIG_SMALL(long_name),\

  1256.     0,\

  1257.     NULL,\

  1258.     raw_read_header,\

  1259.     raw_read_packet,\

  1260.     NULL,\

  1261.     pcm_read_seek,\

  1262.     .flags= AVFMT_GENERIC_INDEX,\

  1263.     .extensions = ext,\

  1264.     .value = codec,\

  1265. };

  1266. 

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

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

  1269.     #name,\

  1270.     NULL_IF_CONFIG_SMALL(long_name),\

  1271.     NULL,\

  1272.     ext,\

  1273.     0,\

  1274.     codec,\

  1275.     CODEC_ID_NONE,\

  1276.     NULL,\

  1277.     raw_write_packet,\

  1278.     .flags= AVFMT_NOTIMESTAMPS,\

  1279. };

  1280. 

  1281. 

  1282. #if  !CONFIG_MUXERS && CONFIG_DEMUXERS

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

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

  1285. #elif CONFIG_MUXERS && !CONFIG_DEMUXERS

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

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

  1288. #elif CONFIG_MUXERS && CONFIG_DEMUXERS

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

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

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

  1292. #else

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

  1294. #endif

  1295. 

  1296. #if HAVE_BIGENDIAN

  1297. #define BE_DEF(s) s

  1298. #define LE_DEF(s) NULL

  1299. #else

  1300. #define BE_DEF(s) NULL

  1301. #define LE_DEF(s) s

  1302. #endif

  1303. 

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

  1305.        NULL, CODEC_ID_PCM_F64BE)

  1306. 

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

  1308.        NULL, CODEC_ID_PCM_F64LE)

  1309. 

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

  1311.        NULL, CODEC_ID_PCM_F32BE)

  1312. 

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

  1314.        NULL, CODEC_ID_PCM_F32LE)

  1315. 

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

  1317.        NULL, CODEC_ID_PCM_S32BE)

  1318. 

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

  1320.        NULL, CODEC_ID_PCM_S32LE)

  1321. 

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

  1323.        NULL, CODEC_ID_PCM_S24BE)

  1324. 

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

  1326.        NULL, CODEC_ID_PCM_S24LE)

  1327. 

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

  1329.        BE_DEF("sw"), CODEC_ID_PCM_S16BE)

  1330. 

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

  1332.        LE_DEF("sw"), CODEC_ID_PCM_S16LE)

  1333. 

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

  1335.        "sb", CODEC_ID_PCM_S8)

  1336. 

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

  1338.        NULL, CODEC_ID_PCM_U32BE)

  1339. 

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

  1341.        NULL, CODEC_ID_PCM_U32LE)

  1342. 

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

  1344.        NULL, CODEC_ID_PCM_U24BE)

  1345. 

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

  1347.        NULL, CODEC_ID_PCM_U24LE)

  1348. 

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

  1350.        BE_DEF("uw"), CODEC_ID_PCM_U16BE)

  1351. 

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

  1353.        LE_DEF("uw"), CODEC_ID_PCM_U16LE)

  1354. 

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

  1356.        "ub", CODEC_ID_PCM_U8)

  1357. 

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

  1359.        "al", CODEC_ID_PCM_ALAW)

  1360. 

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

  1362.        "ul", CODEC_ID_PCM_MULAW)