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

1279 lines
30KB
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. 

  31. /* simple formats */

  32. 

  33. #if CONFIG_ROQ_MUXER

  34. static int roq_write_header(struct AVFormatContext *s)

  35. {

  36.     static const uint8_t header[] = {

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

  38.     };

  39. 

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

  41.     put_flush_packet(s->pb);

  42. 

  43.     return 0;

  44. }

  45. #endif

  46. 

  47. #if CONFIG_NULL_MUXER

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

  49. {

  50.     return 0;

  51. }

  52. #endif

  53. 

  54. #if CONFIG_MUXERS

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

  56. {

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

  58.     put_flush_packet(s->pb);

  59.     return 0;

  60. }

  61. #endif

  62. 

  63. #if CONFIG_DEMUXERS

  64. /* raw input */

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

  66. {

  67.     AVStream *st;

  68.     int id;

  69. 

  70.     st = av_new_stream(s, 0);

  71.     if (!st)

  72.         return AVERROR(ENOMEM);

  73. 

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

  75.         if (id == CODEC_ID_RAWVIDEO) {

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

  77.         } else {

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

  79.         }

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

  81. 

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

  83.         case CODEC_TYPE_AUDIO:

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

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

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

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

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

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

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

  91.             break;

  92.         case CODEC_TYPE_VIDEO:

  93.             if(ap->time_base.num)

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

  95.             else

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

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

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

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

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

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

  102.             break;

  103.         default:

  104.             return -1;

  105.         }

  106.     return 0;

  107. }

  108. 

  109. #define RAW_PACKET_SIZE 1024

  110. #define RAW_SAMPLES     1024

  111. 

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

  113. {

  114.     int ret, size, bps;

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

  116. 

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

  118. 

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

  120. 

  121.     pkt->stream_index = 0;

  122.     if (ret <= 0) {

  123.         return AVERROR(EIO);

  124.     }

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

  126.        packet */

  127.     pkt->size = ret;

  128. 

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

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

  131.     pkt->dts=

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

  133. 

  134.     return ret;

  135. }

  136. 

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

  138. {

  139.     int ret, size;

  140. 

  141.     size = RAW_PACKET_SIZE;

  142. 

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

  144.         return AVERROR(EIO);

  145. 

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

  147.     pkt->stream_index = 0;

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

  149.     if (ret <= 0) {

  150.         av_free_packet(pkt);

  151.         return AVERROR(EIO);

  152.     }

  153.     pkt->size = ret;

  154.     return ret;

  155. }

  156. #endif

  157. 

  158. #if CONFIG_RAWVIDEO_DEMUXER

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

  160. {

  161.     int packet_size, ret, width, height;

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

  163. 

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

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

  166. 

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

  168.     if (packet_size < 0)

  169.         return -1;

  170. 

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

  172.     pkt->pts=

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

  174. 

  175.     pkt->stream_index = 0;

  176.     if (ret != packet_size) {

  177.         return AVERROR(EIO);

  178.     } else {

  179.         return 0;

  180.     }

  181. }

  182. #endif

  183. 

  184. #if CONFIG_INGENIENT_DEMUXER

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

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

  187. {

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

  189. 

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

  191.         return AVERROR(EIO); // FIXME

  192. 

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

  194. 

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

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

  197. 

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

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

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

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

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

  203. 

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

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

  206. 

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

  208.         return AVERROR(EIO);

  209. 

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

  211.     pkt->stream_index = 0;

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

  213.     if (ret <= 0) {

  214.         av_free_packet(pkt);

  215.         return AVERROR(EIO);

  216.     }

  217.     pkt->size = ret;

  218.     return ret;

  219. }

  220. #endif

  221. 

  222. #if CONFIG_DEMUXERS

  223. int pcm_read_seek(AVFormatContext *s,

  224.                   int stream_index, int64_t timestamp, int flags)

  225. {

  226.     AVStream *st;

  227.     int block_align, byte_rate, ret;

  228.     int64_t pos;

  229. 

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

  231. 

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

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

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

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

  236. 

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

  238.         return -1;

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

  240. 

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

  242.     pos = av_rescale_rnd(timestamp * byte_rate,

  243.                          st->time_base.num,

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

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

  246.     pos *= block_align;

  247. 

  248.     /* recompute exact position */

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

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

  251.         return ret;

  252.     return 0;

  253. }

  254. 

  255. static int audio_read_header(AVFormatContext *s,

  256.                              AVFormatParameters *ap)

  257. {

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

  259.     if (!st)

  260.         return AVERROR(ENOMEM);

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

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

  263.     st->need_parsing = AVSTREAM_PARSE_FULL;

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

  265. 

  266.     return 0;

  267. }

  268. 

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

  270. static int video_read_header(AVFormatContext *s,

  271.                              AVFormatParameters *ap)

  272. {

  273.     AVStream *st;

  274. 

  275.     st = av_new_stream(s, 0);

  276.     if (!st)

  277.         return AVERROR(ENOMEM);

  278. 

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

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

  281.     st->need_parsing = AVSTREAM_PARSE_FULL;

  282. 

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

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

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

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

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

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

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

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

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

  292.     }

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

  294. 

  295.     return 0;

  296. }

  297. #endif

  298. 

  299. #if CONFIG_MPEGVIDEO_DEMUXER

  300. #define SEQ_START_CODE          0x000001b3

  301. #define GOP_START_CODE          0x000001b8

  302. #define PICTURE_START_CODE      0x00000100

  303. #define SLICE_START_CODE        0x00000101

  304. #define PACK_START_CODE         0x000001ba

  305. #define VIDEO_ID                0x000001e0

  306. #define AUDIO_ID                0x000001c0

  307. 

  308. static int mpegvideo_probe(AVProbeData *p)

  309. {

  310.     uint32_t code= -1;

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

  312.     int i;

  313. 

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

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

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

  317.             switch(code){

  318.             case     SEQ_START_CODE:   seq++; break;

  319.             case PICTURE_START_CODE:   pic++; break;

  320.             case   SLICE_START_CODE: slice++; break;

  321.             case    PACK_START_CODE: pspack++; break;

  322.             }

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

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

  325.         }

  326.     }

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

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

  329.     return 0;

  330. }

  331. 

  332. #define CAVS_SEQ_START_CODE       0x000001b0

  333. #define CAVS_PIC_I_START_CODE     0x000001b3

  334. #define CAVS_UNDEF_START_CODE     0x000001b4

  335. #define CAVS_PIC_PB_START_CODE    0x000001b6

  336. #define CAVS_VIDEO_EDIT_CODE      0x000001b7

  337. #define CAVS_PROFILE_JIZHUN       0x20

  338. 

  339. static int cavsvideo_probe(AVProbeData *p)

  340. {

  341.     uint32_t code= -1;

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

  343.     int i;

  344. 

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

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

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

  348.             if(code < CAVS_SEQ_START_CODE) {

  349.                 /* slices have to be consecutive */

  350.                 if(code < slice_pos)

  351.                     return 0;

  352.                 slice_pos = code;

  353.             } else {

  354.                 slice_pos = 0;

  355.             }

  356.             if (code == CAVS_SEQ_START_CODE) {

  357.                 seq++;

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

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

  360.                     return 0;

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

  362.                        (code == CAVS_PIC_PB_START_CODE)) {

  363.                 pic++;

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

  365.                        (code >  CAVS_VIDEO_EDIT_CODE)) {

  366.                 return 0;

  367.             }

  368.         }

  369.     }

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

  371.         return AVPROBE_SCORE_MAX/2;

  372.     return 0;

  373. }

  374. #endif

  375. 

  376. #if CONFIG_M4V_DEMUXER

  377. #define VISUAL_OBJECT_START_CODE       0x000001b5

  378. #define VOP_START_CODE                 0x000001b6

  379. 

  380. static int mpeg4video_probe(AVProbeData *probe_packet)

  381. {

  382.     uint32_t temp_buffer= -1;

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

  384.     int i;

  385. 

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

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

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

  389.             continue;

  390. 

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

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

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

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

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

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

  397.     }

  398. 

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

  400.         return AVPROBE_SCORE_MAX/2;

  401.     return 0;

  402. }

  403. #endif

  404. 

  405. #if CONFIG_H264_DEMUXER

  406. static int h264_probe(AVProbeData *p)

  407. {

  408.     uint32_t code= -1;

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

  410.     int i;

  411. 

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

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

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

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

  416.             int type   = code & 0x1F;

  417.             static const int8_t ref_zero[32]={

  418.                 2, 0, 0, 0, 0,-1, 1,-1,

  419.                -1, 1, 1, 1, 1,-1, 2, 2,

  420.                 2, 2, 2, 0, 2, 2, 2, 2,

  421.                 2, 2, 2, 2, 2, 2, 2, 2

  422.             };

  423. 

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

  425.                 return 0;

  426. 

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

  428.                 return 0;

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

  430.                 return 0;

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

  432.                 res++;

  433. 

  434.             switch(type){

  435.             case     1:   sli++; break;

  436.             case     5:   idr++; break;

  437.             case     7:

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

  439.                     return 0;

  440.                 sps++;

  441.                 break;

  442.             case     8:   pps++; break;

  443.             }

  444.         }

  445.     }

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

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

  448.     return 0;

  449. }

  450. #endif

  451. 

  452. #if CONFIG_H263_DEMUXER

  453. static int h263_probe(AVProbeData *p)

  454. {

  455.     int code;

  456.     const uint8_t *d;

  457. 

  458.     d = p->buf;

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

  460.     if (code == 0x20) {

  461.         return 50;

  462.     }

  463.     return 0;

  464. }

  465. #endif

  466. 

  467. #if CONFIG_H261_DEMUXER

  468. static int h261_probe(AVProbeData *p)

  469. {

  470.     int code;

  471.     const uint8_t *d;

  472. 

  473.     d = p->buf;

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

  475.     if (code == 0x10) {

  476.         return 50;

  477.     }

  478.     return 0;

  479. }

  480. #endif

  481. 

  482. #if CONFIG_DTS_DEMUXER

  483. #define DCA_MARKER_14B_BE 0x1FFFE800

  484. #define DCA_MARKER_14B_LE 0xFF1F00E8

  485. #define DCA_MARKER_RAW_BE 0x7FFE8001

  486. #define DCA_MARKER_RAW_LE 0xFE7F0180

  487. static int dts_probe(AVProbeData *p)

  488. {

  489.     const uint8_t *buf, *bufp;

  490.     uint32_t state = -1;

  491. 

  492.     buf = p->buf;

  493. 

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

  495.         bufp = buf;

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

  497. 

  498.         /* regular bitstream */

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

  500.             return AVPROBE_SCORE_MAX/2+1;

  501. 

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

  503.         if (state == DCA_MARKER_14B_BE)

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

  505.                 return AVPROBE_SCORE_MAX/2+1;

  506. 

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

  508.         if (state == DCA_MARKER_14B_LE)

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

  510.                 return AVPROBE_SCORE_MAX/2+1;

  511.     }

  512. 

  513.     return 0;

  514. }

  515. #endif

  516. 

  517. #if CONFIG_DIRAC_DEMUXER

  518. static int dirac_probe(AVProbeData *p)

  519. {

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

  521.         return AVPROBE_SCORE_MAX;

  522.     else

  523.         return 0;

  524. }

  525. #endif

  526. 

  527. #if CONFIG_DNXHD_DEMUXER

  528. static int dnxhd_probe(AVProbeData *p)

  529. {

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

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

  532.         return AVPROBE_SCORE_MAX;

  533.     else

  534.         return 0;

  535. }

  536. #endif

  537. 

  538. #if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER

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

  540. {

  541.     int max_frames, first_frames = 0, frames;

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

  543.     AC3HeaderInfo hdr;

  544.     GetBitContext gbc;

  545.     enum CodecID codec_id = CODEC_ID_AC3;

  546. 

  547.     max_frames = 0;

  548.     buf = p->buf;

  549.     end = buf + p->buf_size;

  550. 

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

  552.         buf2 = buf;

  553. 

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

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

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

  557.                 break;

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

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

  560.                 break;

  561.             if (hdr.bitstream_id > 10)

  562.                 codec_id = CODEC_ID_EAC3;

  563.             buf2 += hdr.frame_size;

  564.         }

  565.         max_frames = FFMAX(max_frames, frames);

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

  567.             first_frames = frames;

  568.     }

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

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

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

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

  573.     else                   return 0;

  574. }

  575. #endif

  576. 

  577. #if CONFIG_AC3_DEMUXER

  578. static int ac3_probe(AVProbeData *p)

  579. {

  580.     return ac3_eac3_probe(p, CODEC_ID_AC3);

  581. }

  582. #endif

  583. 

  584. #if CONFIG_EAC3_DEMUXER

  585. static int eac3_probe(AVProbeData *p)

  586. {

  587.     return ac3_eac3_probe(p, CODEC_ID_EAC3);

  588. }

  589. #endif

  590. 

  591. #if CONFIG_AAC_DEMUXER

  592. static int adts_aac_probe(AVProbeData *p)

  593. {

  594.     int max_frames = 0, first_frames = 0;

  595.     int fsize, frames;

  596.     uint8_t *buf0 = p->buf;

  597.     uint8_t *buf2;

  598.     uint8_t *buf;

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

  600. 

  601.     if (ff_id3v2_match(buf0)) {

  602.         buf0 += ff_id3v2_tag_len(buf0);

  603.     }

  604.     buf = buf0;

  605. 

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

  607.         buf2 = buf;

  608. 

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

  610.             uint32_t header = AV_RB16(buf2);

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

  612.                 break;

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

  614.             if(fsize < 7)

  615.                 break;

  616.             buf2 += fsize;

  617.         }

  618.         max_frames = FFMAX(max_frames, frames);

  619.         if(buf == buf0)

  620.             first_frames= frames;

  621.     }

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

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

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

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

  626.     else                   return 0;

  627. }

  628. #endif

  629. 

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

  631. 

  632. #if CONFIG_AAC_DEMUXER

  633. AVInputFormat aac_demuxer = {

  634.     "aac",

  635.     NULL_IF_CONFIG_SMALL("raw ADTS AAC"),

  636.     0,

  637.     adts_aac_probe,

  638.     audio_read_header,

  639.     ff_raw_read_partial_packet,

  640.     .flags= AVFMT_GENERIC_INDEX,

  641.     .extensions = "aac",

  642.     .value = CODEC_ID_AAC,

  643. };

  644. #endif

  645. 

  646. #if CONFIG_AC3_DEMUXER

  647. AVInputFormat ac3_demuxer = {

  648.     "ac3",

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

  650.     0,

  651.     ac3_probe,

  652.     audio_read_header,

  653.     ff_raw_read_partial_packet,

  654.     .flags= AVFMT_GENERIC_INDEX,

  655.     .extensions = "ac3",

  656.     .value = CODEC_ID_AC3,

  657. };

  658. #endif

  659. 

  660. #if CONFIG_AC3_MUXER

  661. AVOutputFormat ac3_muxer = {

  662.     "ac3",

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

  664.     "audio/x-ac3",

  665.     "ac3",

  666.     0,

  667.     CODEC_ID_AC3,

  668.     CODEC_ID_NONE,

  669.     NULL,

  670.     raw_write_packet,

  671.     .flags= AVFMT_NOTIMESTAMPS,

  672. };

  673. #endif

  674. 

  675. #if CONFIG_DIRAC_DEMUXER

  676. AVInputFormat dirac_demuxer = {

  677.     "dirac",

  678.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  679.     0,

  680.     dirac_probe,

  681.     video_read_header,

  682.     ff_raw_read_partial_packet,

  683.     .flags= AVFMT_GENERIC_INDEX,

  684.     .value = CODEC_ID_DIRAC,

  685. };

  686. #endif

  687. 

  688. #if CONFIG_DIRAC_MUXER

  689. AVOutputFormat dirac_muxer = {

  690.     "dirac",

  691.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  692.     NULL,

  693.     "drc",

  694.     0,

  695.     CODEC_ID_NONE,

  696.     CODEC_ID_DIRAC,

  697.     NULL,

  698.     raw_write_packet,

  699.     .flags= AVFMT_NOTIMESTAMPS,

  700. };

  701. #endif

  702. 

  703. #if CONFIG_DNXHD_DEMUXER

  704. AVInputFormat dnxhd_demuxer = {

  705.     "dnxhd",

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

  707.     0,

  708.     dnxhd_probe,

  709.     video_read_header,

  710.     ff_raw_read_partial_packet,

  711.     .flags= AVFMT_GENERIC_INDEX,

  712.     .value = CODEC_ID_DNXHD,

  713. };

  714. #endif

  715. 

  716. #if CONFIG_DNXHD_MUXER

  717. AVOutputFormat dnxhd_muxer = {

  718.     "dnxhd",

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

  720.     NULL,

  721.     "dnxhd",

  722.     0,

  723.     CODEC_ID_NONE,

  724.     CODEC_ID_DNXHD,

  725.     NULL,

  726.     raw_write_packet,

  727.     .flags= AVFMT_NOTIMESTAMPS,

  728. };

  729. #endif

  730. 

  731. #if CONFIG_DTS_DEMUXER

  732. AVInputFormat dts_demuxer = {

  733.     "dts",

  734.     NULL_IF_CONFIG_SMALL("raw DTS"),

  735.     0,

  736.     dts_probe,

  737.     audio_read_header,

  738.     ff_raw_read_partial_packet,

  739.     .flags= AVFMT_GENERIC_INDEX,

  740.     .extensions = "dts",

  741.     .value = CODEC_ID_DTS,

  742. };

  743. #endif

  744. 

  745. #if CONFIG_DTS_MUXER

  746. AVOutputFormat dts_muxer = {

  747.     "dts",

  748.     NULL_IF_CONFIG_SMALL("raw DTS"),

  749.     "audio/x-dca",

  750.     "dts",

  751.     0,

  752.     CODEC_ID_DTS,

  753.     CODEC_ID_NONE,

  754.     NULL,

  755.     raw_write_packet,

  756.     .flags= AVFMT_NOTIMESTAMPS,

  757. };

  758. #endif

  759. 

  760. #if CONFIG_EAC3_DEMUXER

  761. AVInputFormat eac3_demuxer = {

  762.     "eac3",

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

  764.     0,

  765.     eac3_probe,

  766.     audio_read_header,

  767.     ff_raw_read_partial_packet,

  768.     .flags= AVFMT_GENERIC_INDEX,

  769.     .extensions = "eac3",

  770.     .value = CODEC_ID_EAC3,

  771. };

  772. #endif

  773. 

  774. #if CONFIG_EAC3_MUXER

  775. AVOutputFormat eac3_muxer = {

  776.     "eac3",

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

  778.     "audio/x-eac3",

  779.     "eac3",

  780.     0,

  781.     CODEC_ID_EAC3,

  782.     CODEC_ID_NONE,

  783.     NULL,

  784.     raw_write_packet,

  785.     .flags= AVFMT_NOTIMESTAMPS,

  786. };

  787. #endif

  788. 

  789. #if CONFIG_GSM_DEMUXER

  790. AVInputFormat gsm_demuxer = {

  791.     "gsm",

  792.     NULL_IF_CONFIG_SMALL("raw GSM"),

  793.     0,

  794.     NULL,

  795.     audio_read_header,

  796.     ff_raw_read_partial_packet,

  797.     .flags= AVFMT_GENERIC_INDEX,

  798.     .extensions = "gsm",

  799.     .value = CODEC_ID_GSM,

  800. };

  801. #endif

  802. 

  803. #if CONFIG_H261_DEMUXER

  804. AVInputFormat h261_demuxer = {

  805.     "h261",

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

  807.     0,

  808.     h261_probe,

  809.     video_read_header,

  810.     ff_raw_read_partial_packet,

  811.     .flags= AVFMT_GENERIC_INDEX,

  812.     .extensions = "h261",

  813.     .value = CODEC_ID_H261,

  814. };

  815. #endif

  816. 

  817. #if CONFIG_H261_MUXER

  818. AVOutputFormat h261_muxer = {

  819.     "h261",

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

  821.     "video/x-h261",

  822.     "h261",

  823.     0,

  824.     CODEC_ID_NONE,

  825.     CODEC_ID_H261,

  826.     NULL,

  827.     raw_write_packet,

  828.     .flags= AVFMT_NOTIMESTAMPS,

  829. };

  830. #endif

  831. 

  832. #if CONFIG_H263_DEMUXER

  833. AVInputFormat h263_demuxer = {

  834.     "h263",

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

  836.     0,

  837.     h263_probe,

  838.     video_read_header,

  839.     ff_raw_read_partial_packet,

  840.     .flags= AVFMT_GENERIC_INDEX,

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

  842.     .value = CODEC_ID_H263,

  843. };

  844. #endif

  845. 

  846. #if CONFIG_H263_MUXER

  847. AVOutputFormat h263_muxer = {

  848.     "h263",

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

  850.     "video/x-h263",

  851.     "h263",

  852.     0,

  853.     CODEC_ID_NONE,

  854.     CODEC_ID_H263,

  855.     NULL,

  856.     raw_write_packet,

  857.     .flags= AVFMT_NOTIMESTAMPS,

  858. };

  859. #endif

  860. 

  861. #if CONFIG_H264_DEMUXER

  862. AVInputFormat h264_demuxer = {

  863.     "h264",

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

  865.     0,

  866.     h264_probe,

  867.     video_read_header,

  868.     ff_raw_read_partial_packet,

  869.     .flags= AVFMT_GENERIC_INDEX,

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

  871.     .value = CODEC_ID_H264,

  872. };

  873. #endif

  874. 

  875. #if CONFIG_H264_MUXER

  876. AVOutputFormat h264_muxer = {

  877.     "h264",

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

  879.     NULL,

  880.     "h264",

  881.     0,

  882.     CODEC_ID_NONE,

  883.     CODEC_ID_H264,

  884.     NULL,

  885.     raw_write_packet,

  886.     .flags= AVFMT_NOTIMESTAMPS,

  887. };

  888. #endif

  889. 

  890. #if CONFIG_INGENIENT_DEMUXER

  891. AVInputFormat ingenient_demuxer = {

  892.     "ingenient",

  893.     NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),

  894.     0,

  895.     NULL,

  896.     video_read_header,

  897.     ingenient_read_packet,

  898.     .flags= AVFMT_GENERIC_INDEX,

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

  900.     .value = CODEC_ID_MJPEG,

  901. };

  902. #endif

  903. 

  904. #if CONFIG_M4V_DEMUXER

  905. AVInputFormat m4v_demuxer = {

  906.     "m4v",

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

  908.     0,

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

  910.     video_read_header,

  911.     ff_raw_read_partial_packet,

  912.     .flags= AVFMT_GENERIC_INDEX,

  913.     .extensions = "m4v",

  914.     .value = CODEC_ID_MPEG4,

  915. };

  916. #endif

  917. 

  918. #if CONFIG_M4V_MUXER

  919. AVOutputFormat m4v_muxer = {

  920.     "m4v",

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

  922.     NULL,

  923.     "m4v",

  924.     0,

  925.     CODEC_ID_NONE,

  926.     CODEC_ID_MPEG4,

  927.     NULL,

  928.     raw_write_packet,

  929.     .flags= AVFMT_NOTIMESTAMPS,

  930. };

  931. #endif

  932. 

  933. #if CONFIG_MJPEG_DEMUXER

  934. AVInputFormat mjpeg_demuxer = {

  935.     "mjpeg",

  936.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  937.     0,

  938.     NULL,

  939.     video_read_header,

  940.     ff_raw_read_partial_packet,

  941.     .flags= AVFMT_GENERIC_INDEX,

  942.     .extensions = "mjpg,mjpeg",

  943.     .value = CODEC_ID_MJPEG,

  944. };

  945. #endif

  946. 

  947. #if CONFIG_MJPEG_MUXER

  948. AVOutputFormat mjpeg_muxer = {

  949.     "mjpeg",

  950.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  951.     "video/x-mjpeg",

  952.     "mjpg,mjpeg",

  953.     0,

  954.     CODEC_ID_NONE,

  955.     CODEC_ID_MJPEG,

  956.     NULL,

  957.     raw_write_packet,

  958.     .flags= AVFMT_NOTIMESTAMPS,

  959. };

  960. #endif

  961. 

  962. #if CONFIG_MLP_DEMUXER

  963. AVInputFormat mlp_demuxer = {

  964.     "mlp",

  965.     NULL_IF_CONFIG_SMALL("raw MLP"),

  966.     0,

  967.     NULL,

  968.     audio_read_header,

  969.     ff_raw_read_partial_packet,

  970.     .flags= AVFMT_GENERIC_INDEX,

  971.     .extensions = "mlp",

  972.     .value = CODEC_ID_MLP,

  973. };

  974. #endif

  975. 

  976. #if CONFIG_MLP_MUXER

  977. AVOutputFormat mlp_muxer = {

  978.     "mlp",

  979.     NULL_IF_CONFIG_SMALL("raw MLP"),

  980.     NULL,

  981.     "mlp",

  982.     0,

  983.     CODEC_ID_MLP,

  984.     CODEC_ID_NONE,

  985.     NULL,

  986.     raw_write_packet,

  987.     .flags= AVFMT_NOTIMESTAMPS,

  988. };

  989. #endif

  990. 

  991. #if CONFIG_TRUEHD_DEMUXER

  992. AVInputFormat truehd_demuxer = {

  993.     "truehd",

  994.     NULL_IF_CONFIG_SMALL("raw TrueHD"),

  995.     0,

  996.     NULL,

  997.     audio_read_header,

  998.     ff_raw_read_partial_packet,

  999.     .flags= AVFMT_GENERIC_INDEX,

  1000.     .extensions = "thd",

  1001.     .value = CODEC_ID_TRUEHD,

  1002. };

  1003. #endif

  1004. 

  1005. #if CONFIG_TRUEHD_MUXER

  1006. AVOutputFormat truehd_muxer = {

  1007.     "truehd",

  1008.     NULL_IF_CONFIG_SMALL("raw TrueHD"),

  1009.     NULL,

  1010.     "thd",

  1011.     0,

  1012.     CODEC_ID_TRUEHD,

  1013.     CODEC_ID_NONE,

  1014.     NULL,

  1015.     raw_write_packet,

  1016.     .flags= AVFMT_NOTIMESTAMPS,

  1017. };

  1018. #endif

  1019. 

  1020. #if CONFIG_MPEG1VIDEO_MUXER

  1021. AVOutputFormat mpeg1video_muxer = {

  1022.     "mpeg1video",

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

  1024.     "video/x-mpeg",

  1025.     "mpg,mpeg,m1v",

  1026.     0,

  1027.     CODEC_ID_NONE,

  1028.     CODEC_ID_MPEG1VIDEO,

  1029.     NULL,

  1030.     raw_write_packet,

  1031.     .flags= AVFMT_NOTIMESTAMPS,

  1032. };

  1033. #endif

  1034. 

  1035. #if CONFIG_MPEG2VIDEO_MUXER

  1036. AVOutputFormat mpeg2video_muxer = {

  1037.     "mpeg2video",

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

  1039.     NULL,

  1040.     "m2v",

  1041.     0,

  1042.     CODEC_ID_NONE,

  1043.     CODEC_ID_MPEG2VIDEO,

  1044.     NULL,

  1045.     raw_write_packet,

  1046.     .flags= AVFMT_NOTIMESTAMPS,

  1047. };

  1048. #endif

  1049. 

  1050. #if CONFIG_MPEGVIDEO_DEMUXER

  1051. AVInputFormat mpegvideo_demuxer = {

  1052.     "mpegvideo",

  1053.     NULL_IF_CONFIG_SMALL("raw MPEG video"),

  1054.     0,

  1055.     mpegvideo_probe,

  1056.     video_read_header,

  1057.     ff_raw_read_partial_packet,

  1058.     .flags= AVFMT_GENERIC_INDEX,

  1059.     .value = CODEC_ID_MPEG1VIDEO,

  1060. };

  1061. #endif

  1062. 

  1063. #if CONFIG_CAVSVIDEO_DEMUXER

  1064. AVInputFormat cavsvideo_demuxer = {

  1065.     "cavsvideo",

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

  1067.     0,

  1068.     cavsvideo_probe,

  1069.     video_read_header,

  1070.     ff_raw_read_partial_packet,

  1071.     .flags= AVFMT_GENERIC_INDEX,

  1072.     .value = CODEC_ID_CAVS,

  1073. };

  1074. #endif

  1075. 

  1076. #if CONFIG_NULL_MUXER

  1077. AVOutputFormat null_muxer = {

  1078.     "null",

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

  1080.     NULL,

  1081.     NULL,

  1082.     0,

  1083. #ifdef WORDS_BIGENDIAN

  1084.     CODEC_ID_PCM_S16BE,

  1085. #else

  1086.     CODEC_ID_PCM_S16LE,

  1087. #endif

  1088.     CODEC_ID_RAWVIDEO,

  1089.     NULL,

  1090.     null_write_packet,

  1091.     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,

  1092. };

  1093. #endif

  1094. 

  1095. #if CONFIG_RAWVIDEO_DEMUXER

  1096. AVInputFormat rawvideo_demuxer = {

  1097.     "rawvideo",

  1098.     NULL_IF_CONFIG_SMALL("raw video format"),

  1099.     0,

  1100.     NULL,

  1101.     raw_read_header,

  1102.     rawvideo_read_packet,

  1103.     .flags= AVFMT_GENERIC_INDEX,

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

  1105.     .value = CODEC_ID_RAWVIDEO,

  1106. };

  1107. #endif

  1108. 

  1109. #if CONFIG_RAWVIDEO_MUXER

  1110. AVOutputFormat rawvideo_muxer = {

  1111.     "rawvideo",

  1112.     NULL_IF_CONFIG_SMALL("raw video format"),

  1113.     NULL,

  1114.     "yuv,rgb",

  1115.     0,

  1116.     CODEC_ID_NONE,

  1117.     CODEC_ID_RAWVIDEO,

  1118.     NULL,

  1119.     raw_write_packet,

  1120.     .flags= AVFMT_NOTIMESTAMPS,

  1121. };

  1122. #endif

  1123. 

  1124. #if CONFIG_ROQ_MUXER

  1125. AVOutputFormat roq_muxer =

  1126. {

  1127.     "RoQ",

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

  1129.     NULL,

  1130.     "roq",

  1131.     0,

  1132.     CODEC_ID_ROQ_DPCM,

  1133.     CODEC_ID_ROQ,

  1134.     roq_write_header,

  1135.     raw_write_packet,

  1136. };

  1137. #endif

  1138. 

  1139. #if CONFIG_SHORTEN_DEMUXER

  1140. AVInputFormat shorten_demuxer = {

  1141.     "shn",

  1142.     NULL_IF_CONFIG_SMALL("raw Shorten"),

  1143.     0,

  1144.     NULL,

  1145.     audio_read_header,

  1146.     ff_raw_read_partial_packet,

  1147.     .flags= AVFMT_GENERIC_INDEX,

  1148.     .extensions = "shn",

  1149.     .value = CODEC_ID_SHORTEN,

  1150. };

  1151. #endif

  1152. 

  1153. #if CONFIG_VC1_DEMUXER

  1154. AVInputFormat vc1_demuxer = {

  1155.     "vc1",

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

  1157.     0,

  1158.     NULL /* vc1_probe */,

  1159.     video_read_header,

  1160.     ff_raw_read_partial_packet,

  1161.     .extensions = "vc1",

  1162.     .value = CODEC_ID_VC1,

  1163. };

  1164. #endif

  1165. 

  1166. /* PCM formats */

  1167. 

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

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

  1170.     #name,\

  1171.     NULL_IF_CONFIG_SMALL(long_name),\

  1172.     0,\

  1173.     NULL,\

  1174.     raw_read_header,\

  1175.     raw_read_packet,\

  1176.     NULL,\

  1177.     pcm_read_seek,\

  1178.     .flags= AVFMT_GENERIC_INDEX,\

  1179.     .extensions = ext,\

  1180.     .value = codec,\

  1181. };

  1182. 

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

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

  1185.     #name,\

  1186.     NULL_IF_CONFIG_SMALL(long_name),\

  1187.     NULL,\

  1188.     ext,\

  1189.     0,\

  1190.     codec,\

  1191.     CODEC_ID_NONE,\

  1192.     NULL,\

  1193.     raw_write_packet,\

  1194.     .flags= AVFMT_NOTIMESTAMPS,\

  1195. };

  1196. 

  1197. 

  1198. #if  !CONFIG_MUXERS && CONFIG_DEMUXERS

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

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

  1201. #elif CONFIG_MUXERS && !CONFIG_DEMUXERS

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

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

  1204. #elif CONFIG_MUXERS && CONFIG_DEMUXERS

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

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

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

  1208. #else

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

  1210. #endif

  1211. 

  1212. #ifdef WORDS_BIGENDIAN

  1213. #define BE_DEF(s) s

  1214. #define LE_DEF(s) NULL

  1215. #else

  1216. #define BE_DEF(s) NULL

  1217. #define LE_DEF(s) s

  1218. #endif

  1219. 

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

  1221.        NULL, CODEC_ID_PCM_F64BE)

  1222. 

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

  1224.        NULL, CODEC_ID_PCM_F64LE)

  1225. 

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

  1227.        NULL, CODEC_ID_PCM_F32BE)

  1228. 

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

  1230.        NULL, CODEC_ID_PCM_F32LE)

  1231. 

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

  1233.        NULL, CODEC_ID_PCM_S32BE)

  1234. 

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

  1236.        NULL, CODEC_ID_PCM_S32LE)

  1237. 

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

  1239.        NULL, CODEC_ID_PCM_S24BE)

  1240. 

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

  1242.        NULL, CODEC_ID_PCM_S24LE)

  1243. 

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

  1245.        BE_DEF("sw"), CODEC_ID_PCM_S16BE)

  1246. 

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

  1248.        LE_DEF("sw"), CODEC_ID_PCM_S16LE)

  1249. 

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

  1251.        "sb", CODEC_ID_PCM_S8)

  1252. 

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

  1254.        NULL, CODEC_ID_PCM_U32BE)

  1255. 

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

  1257.        NULL, CODEC_ID_PCM_U32LE)

  1258. 

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

  1260.        NULL, CODEC_ID_PCM_U24BE)

  1261. 

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

  1263.        NULL, CODEC_ID_PCM_U24LE)

  1264. 

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

  1266.        BE_DEF("uw"), CODEC_ID_PCM_U16BE)

  1267. 

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

  1269.        LE_DEF("uw"), CODEC_ID_PCM_U16LE)

  1270. 

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

  1272.        "ub", CODEC_ID_PCM_U8)

  1273. 

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

  1275.        "al", CODEC_ID_PCM_ALAW)

  1276. 

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

  1278.        "ul", CODEC_ID_PCM_MULAW)