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

1268 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/bitstream.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.             av_set_pts_info(st, 64, 1, st->codec->sample_rate);

  88.             break;

  89.         case CODEC_TYPE_VIDEO:

  90.             if(ap->time_base.num)

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

  92.             else

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

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

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

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

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

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

  99.             break;

  100.         default:

  101.             return -1;

  102.         }

  103.     return 0;

  104. }

  105. 

  106. #define RAW_PACKET_SIZE 1024

  107. 

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

  109. {

  110.     int ret, size, bps;

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

  112. 

  113.     size= RAW_PACKET_SIZE;

  114. 

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

  116. 

  117.     pkt->stream_index = 0;

  118.     if (ret <= 0) {

  119.         return AVERROR(EIO);

  120.     }

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

  122.        packet */

  123.     pkt->size = ret;

  124. 

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

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

  127.     pkt->dts=

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

  129. 

  130.     return ret;

  131. }

  132. 

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

  134. {

  135.     int ret, size;

  136. 

  137.     size = RAW_PACKET_SIZE;

  138. 

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

  140.         return AVERROR(EIO);

  141. 

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

  143.     pkt->stream_index = 0;

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

  145.     if (ret <= 0) {

  146.         av_free_packet(pkt);

  147.         return AVERROR(EIO);

  148.     }

  149.     pkt->size = ret;

  150.     return ret;

  151. }

  152. #endif

  153. 

  154. #if CONFIG_RAWVIDEO_DEMUXER

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

  156. {

  157.     int packet_size, ret, width, height;

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

  159. 

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

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

  162. 

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

  164.     if (packet_size < 0)

  165.         return -1;

  166. 

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

  168.     pkt->pts=

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

  170. 

  171.     pkt->stream_index = 0;

  172.     if (ret != packet_size) {

  173.         return AVERROR(EIO);

  174.     } else {

  175.         return 0;

  176.     }

  177. }

  178. #endif

  179. 

  180. #if CONFIG_INGENIENT_DEMUXER

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

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

  183. {

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

  185. 

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

  187.         return AVERROR(EIO); // FIXME

  188. 

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

  190. 

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

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

  193. 

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

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

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

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

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

  199. 

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

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

  202. 

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

  204.         return AVERROR(EIO);

  205. 

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

  207.     pkt->stream_index = 0;

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

  209.     if (ret <= 0) {

  210.         av_free_packet(pkt);

  211.         return AVERROR(EIO);

  212.     }

  213.     pkt->size = ret;

  214.     return ret;

  215. }

  216. #endif

  217. 

  218. #if CONFIG_DEMUXERS

  219. int pcm_read_seek(AVFormatContext *s,

  220.                   int stream_index, int64_t timestamp, int flags)

  221. {

  222.     AVStream *st;

  223.     int block_align, byte_rate, ret;

  224.     int64_t pos;

  225. 

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

  227. 

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

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

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

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

  232. 

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

  234.         return -1;

  235. 

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

  237.     pos = av_rescale_rnd(timestamp * byte_rate,

  238.                          st->time_base.num,

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

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

  241.     pos *= block_align;

  242. 

  243.     /* recompute exact position */

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

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

  246.         return ret;

  247.     return 0;

  248. }

  249. 

  250. static int audio_read_header(AVFormatContext *s,

  251.                              AVFormatParameters *ap)

  252. {

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

  254.     if (!st)

  255.         return AVERROR(ENOMEM);

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

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

  258.     st->need_parsing = AVSTREAM_PARSE_FULL;

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

  260. 

  261.     if(st->codec->codec_id == CODEC_ID_FLAC) {

  262.         /* skip ID3v2 header if found */

  263.         uint8_t buf[ID3v2_HEADER_SIZE];

  264.         int ret = get_buffer(s->pb, buf, ID3v2_HEADER_SIZE);

  265.         if (ret == ID3v2_HEADER_SIZE && ff_id3v2_match(buf)) {

  266.             int len = ff_id3v2_tag_len(buf);

  267.             url_fseek(s->pb, len - ID3v2_HEADER_SIZE, SEEK_CUR);

  268.         } else {

  269.             url_fseek(s->pb, 0, SEEK_SET);

  270.         }

  271.     }

  272.     return 0;

  273. }

  274. 

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

  276. static int video_read_header(AVFormatContext *s,

  277.                              AVFormatParameters *ap)

  278. {

  279.     AVStream *st;

  280. 

  281.     st = av_new_stream(s, 0);

  282.     if (!st)

  283.         return AVERROR(ENOMEM);

  284. 

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

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

  287.     st->need_parsing = AVSTREAM_PARSE_FULL;

  288. 

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

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

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

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

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

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

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

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

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

  298.     }

  299. 

  300.     return 0;

  301. }

  302. #endif

  303. 

  304. #if CONFIG_MPEGVIDEO_DEMUXER

  305. #define SEQ_START_CODE          0x000001b3

  306. #define GOP_START_CODE          0x000001b8

  307. #define PICTURE_START_CODE      0x00000100

  308. #define SLICE_START_CODE        0x00000101

  309. #define PACK_START_CODE         0x000001ba

  310. #define VIDEO_ID                0x000001e0

  311. #define AUDIO_ID                0x000001c0

  312. 

  313. static int mpegvideo_probe(AVProbeData *p)

  314. {

  315.     uint32_t code= -1;

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

  317.     int i;

  318. 

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

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

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

  322.             switch(code){

  323.             case     SEQ_START_CODE:   seq++; break;

  324.             case PICTURE_START_CODE:   pic++; break;

  325.             case   SLICE_START_CODE: slice++; break;

  326.             case    PACK_START_CODE: pspack++; break;

  327.             }

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

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

  330.         }

  331.     }

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

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

  334.     return 0;

  335. }

  336. 

  337. #define CAVS_SEQ_START_CODE       0x000001b0

  338. #define CAVS_PIC_I_START_CODE     0x000001b3

  339. #define CAVS_UNDEF_START_CODE     0x000001b4

  340. #define CAVS_PIC_PB_START_CODE    0x000001b6

  341. #define CAVS_VIDEO_EDIT_CODE      0x000001b7

  342. #define CAVS_PROFILE_JIZHUN       0x20

  343. 

  344. static int cavsvideo_probe(AVProbeData *p)

  345. {

  346.     uint32_t code= -1;

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

  348.     int i;

  349. 

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

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

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

  353.             if(code < CAVS_SEQ_START_CODE) {

  354.                 /* slices have to be consecutive */

  355.                 if(code < slice_pos)

  356.                     return 0;

  357.                 slice_pos = code;

  358.             } else {

  359.                 slice_pos = 0;

  360.             }

  361.             if (code == CAVS_SEQ_START_CODE) {

  362.                 seq++;

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

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

  365.                     return 0;

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

  367.                        (code == CAVS_PIC_PB_START_CODE)) {

  368.                 pic++;

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

  370.                        (code >  CAVS_VIDEO_EDIT_CODE)) {

  371.                 return 0;

  372.             }

  373.         }

  374.     }

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

  376.         return AVPROBE_SCORE_MAX/2;

  377.     return 0;

  378. }

  379. #endif

  380. 

  381. #if CONFIG_M4V_DEMUXER

  382. #define VISUAL_OBJECT_START_CODE       0x000001b5

  383. #define VOP_START_CODE                 0x000001b6

  384. 

  385. static int mpeg4video_probe(AVProbeData *probe_packet)

  386. {

  387.     uint32_t temp_buffer= -1;

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

  389.     int i;

  390. 

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

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

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

  394.             continue;

  395. 

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

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

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

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

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

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

  402.     }

  403. 

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

  405.         return AVPROBE_SCORE_MAX/2;

  406.     return 0;

  407. }

  408. #endif

  409. 

  410. #if CONFIG_H264_DEMUXER

  411. static int h264_probe(AVProbeData *p)

  412. {

  413.     uint32_t code= -1;

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

  415.     int i;

  416. 

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

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

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

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

  421.             int type   = code & 0x1F;

  422.             static const int8_t ref_zero[32]={

  423.                 2, 0, 0, 0, 0,-1, 1,-1,

  424.                -1, 1, 1, 1, 1,-1, 2, 2,

  425.                 2, 2, 2, 0, 2, 2, 2, 2,

  426.                 2, 2, 2, 2, 2, 2, 2, 2

  427.             };

  428. 

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

  430.                 return 0;

  431. 

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

  433.                 return 0;

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

  435.                 return 0;

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

  437.                 res++;

  438. 

  439.             switch(type){

  440.             case     1:   sli++; break;

  441.             case     5:   idr++; break;

  442.             case     7:

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

  444.                     return 0;

  445.                 sps++;

  446.                 break;

  447.             case     8:   pps++; break;

  448.             }

  449.         }

  450.     }

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

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

  453.     return 0;

  454. }

  455. #endif

  456. 

  457. #if CONFIG_H263_DEMUXER

  458. static int h263_probe(AVProbeData *p)

  459. {

  460.     int code;

  461.     const uint8_t *d;

  462. 

  463.     d = p->buf;

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

  465.     if (code == 0x20) {

  466.         return 50;

  467.     }

  468.     return 0;

  469. }

  470. #endif

  471. 

  472. #if CONFIG_H261_DEMUXER

  473. static int h261_probe(AVProbeData *p)

  474. {

  475.     int code;

  476.     const uint8_t *d;

  477. 

  478.     d = p->buf;

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

  480.     if (code == 0x10) {

  481.         return 50;

  482.     }

  483.     return 0;

  484. }

  485. #endif

  486. 

  487. #if CONFIG_DTS_DEMUXER

  488. #define DCA_MARKER_14B_BE 0x1FFFE800

  489. #define DCA_MARKER_14B_LE 0xFF1F00E8

  490. #define DCA_MARKER_RAW_BE 0x7FFE8001

  491. #define DCA_MARKER_RAW_LE 0xFE7F0180

  492. static int dts_probe(AVProbeData *p)

  493. {

  494.     const uint8_t *buf, *bufp;

  495.     uint32_t state = -1;

  496. 

  497.     buf = p->buf;

  498. 

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

  500.         bufp = buf;

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

  502. 

  503.         /* regular bitstream */

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

  505.             return AVPROBE_SCORE_MAX/2+1;

  506. 

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

  508.         if (state == DCA_MARKER_14B_BE)

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

  510.                 return AVPROBE_SCORE_MAX/2+1;

  511. 

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

  513.         if (state == DCA_MARKER_14B_LE)

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

  515.                 return AVPROBE_SCORE_MAX/2+1;

  516.     }

  517. 

  518.     return 0;

  519. }

  520. #endif

  521. 

  522. #if CONFIG_DIRAC_DEMUXER

  523. static int dirac_probe(AVProbeData *p)

  524. {

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

  526.         return AVPROBE_SCORE_MAX;

  527.     else

  528.         return 0;

  529. }

  530. #endif

  531. 

  532. #if CONFIG_DNXHD_DEMUXER

  533. static int dnxhd_probe(AVProbeData *p)

  534. {

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

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

  537.         return AVPROBE_SCORE_MAX;

  538.     else

  539.         return 0;

  540. }

  541. #endif

  542. 

  543. #if CONFIG_AC3_DEMUXER || CONFIG_EAC3_DEMUXER

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

  545. {

  546.     int max_frames, first_frames = 0, frames;

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

  548.     AC3HeaderInfo hdr;

  549.     GetBitContext gbc;

  550.     enum CodecID codec_id = CODEC_ID_AC3;

  551. 

  552.     max_frames = 0;

  553.     buf = p->buf;

  554.     end = buf + p->buf_size;

  555. 

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

  557.         buf2 = buf;

  558. 

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

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

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

  562.                 break;

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

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

  565.                 break;

  566.             if (hdr.bitstream_id > 10)

  567.                 codec_id = CODEC_ID_EAC3;

  568.             buf2 += hdr.frame_size;

  569.         }

  570.         max_frames = FFMAX(max_frames, frames);

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

  572.             first_frames = frames;

  573.     }

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

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

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

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

  578.     else                   return 0;

  579. }

  580. #endif

  581. 

  582. #if CONFIG_AC3_DEMUXER

  583. static int ac3_probe(AVProbeData *p)

  584. {

  585.     return ac3_eac3_probe(p, CODEC_ID_AC3);

  586. }

  587. #endif

  588. 

  589. #if CONFIG_EAC3_DEMUXER

  590. static int eac3_probe(AVProbeData *p)

  591. {

  592.     return ac3_eac3_probe(p, CODEC_ID_EAC3);

  593. }

  594. #endif

  595. 

  596. #if CONFIG_FLAC_DEMUXER

  597. static int flac_probe(AVProbeData *p)

  598. {

  599.     uint8_t *bufptr = p->buf;

  600.     uint8_t *end    = p->buf + p->buf_size;

  601. 

  602.     if(ff_id3v2_match(bufptr))

  603.         bufptr += ff_id3v2_tag_len(bufptr);

  604. 

  605.     if(bufptr > end-4 || memcmp(bufptr, "fLaC", 4)) return 0;

  606.     else                                            return AVPROBE_SCORE_MAX/2;

  607. }

  608. #endif

  609. 

  610. #if CONFIG_AAC_DEMUXER

  611. static int adts_aac_probe(AVProbeData *p)

  612. {

  613.     int max_frames = 0, first_frames = 0;

  614.     int fsize, frames;

  615.     uint8_t *buf0 = p->buf;

  616.     uint8_t *buf2;

  617.     uint8_t *buf;

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

  619. 

  620.     if (ff_id3v2_match(buf0)) {

  621.         buf0 += ff_id3v2_tag_len(buf0);

  622.     }

  623.     buf = buf0;

  624. 

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

  626.         buf2 = buf;

  627. 

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

  629.             uint32_t header = AV_RB16(buf2);

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

  631.                 break;

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

  633.             if(fsize < 7)

  634.                 break;

  635.             buf2 += fsize;

  636.         }

  637.         max_frames = FFMAX(max_frames, frames);

  638.         if(buf == buf0)

  639.             first_frames= frames;

  640.     }

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

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

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

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

  645.     else                   return 0;

  646. }

  647. #endif

  648. 

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

  650. 

  651. #if CONFIG_AAC_DEMUXER

  652. AVInputFormat aac_demuxer = {

  653.     "aac",

  654.     NULL_IF_CONFIG_SMALL("raw ADTS AAC"),

  655.     0,

  656.     adts_aac_probe,

  657.     audio_read_header,

  658.     raw_read_partial_packet,

  659.     .flags= AVFMT_GENERIC_INDEX,

  660.     .extensions = "aac",

  661.     .value = CODEC_ID_AAC,

  662. };

  663. #endif

  664. 

  665. #if CONFIG_AC3_DEMUXER

  666. AVInputFormat ac3_demuxer = {

  667.     "ac3",

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

  669.     0,

  670.     ac3_probe,

  671.     audio_read_header,

  672.     raw_read_partial_packet,

  673.     .flags= AVFMT_GENERIC_INDEX,

  674.     .extensions = "ac3",

  675.     .value = CODEC_ID_AC3,

  676. };

  677. #endif

  678. 

  679. #if CONFIG_AC3_MUXER

  680. AVOutputFormat ac3_muxer = {

  681.     "ac3",

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

  683.     "audio/x-ac3",

  684.     "ac3",

  685.     0,

  686.     CODEC_ID_AC3,

  687.     CODEC_ID_NONE,

  688.     NULL,

  689.     raw_write_packet,

  690.     .flags= AVFMT_NOTIMESTAMPS,

  691. };

  692. #endif

  693. 

  694. #if CONFIG_DIRAC_DEMUXER

  695. AVInputFormat dirac_demuxer = {

  696.     "dirac",

  697.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  698.     0,

  699.     dirac_probe,

  700.     video_read_header,

  701.     raw_read_partial_packet,

  702.     .flags= AVFMT_GENERIC_INDEX,

  703.     .value = CODEC_ID_DIRAC,

  704. };

  705. #endif

  706. 

  707. #if CONFIG_DIRAC_MUXER

  708. AVOutputFormat dirac_muxer = {

  709.     "dirac",

  710.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  711.     NULL,

  712.     "drc",

  713.     0,

  714.     CODEC_ID_NONE,

  715.     CODEC_ID_DIRAC,

  716.     NULL,

  717.     raw_write_packet,

  718.     .flags= AVFMT_NOTIMESTAMPS,

  719. };

  720. #endif

  721. 

  722. #if CONFIG_DNXHD_DEMUXER

  723. AVInputFormat dnxhd_demuxer = {

  724.     "dnxhd",

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

  726.     0,

  727.     dnxhd_probe,

  728.     video_read_header,

  729.     raw_read_partial_packet,

  730.     .flags= AVFMT_GENERIC_INDEX,

  731.     .value = CODEC_ID_DNXHD,

  732. };

  733. #endif

  734. 

  735. #if CONFIG_DNXHD_MUXER

  736. AVOutputFormat dnxhd_muxer = {

  737.     "dnxhd",

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

  739.     NULL,

  740.     "dnxhd",

  741.     0,

  742.     CODEC_ID_NONE,

  743.     CODEC_ID_DNXHD,

  744.     NULL,

  745.     raw_write_packet,

  746.     .flags= AVFMT_NOTIMESTAMPS,

  747. };

  748. #endif

  749. 

  750. #if CONFIG_DTS_DEMUXER

  751. AVInputFormat dts_demuxer = {

  752.     "dts",

  753.     NULL_IF_CONFIG_SMALL("raw DTS"),

  754.     0,

  755.     dts_probe,

  756.     audio_read_header,

  757.     raw_read_partial_packet,

  758.     .flags= AVFMT_GENERIC_INDEX,

  759.     .extensions = "dts",

  760.     .value = CODEC_ID_DTS,

  761. };

  762. #endif

  763. 

  764. #if CONFIG_DTS_MUXER

  765. AVOutputFormat dts_muxer = {

  766.     "dts",

  767.     NULL_IF_CONFIG_SMALL("raw DTS"),

  768.     "audio/x-dca",

  769.     "dts",

  770.     0,

  771.     CODEC_ID_DTS,

  772.     CODEC_ID_NONE,

  773.     NULL,

  774.     raw_write_packet,

  775.     .flags= AVFMT_NOTIMESTAMPS,

  776. };

  777. #endif

  778. 

  779. #if CONFIG_EAC3_DEMUXER

  780. AVInputFormat eac3_demuxer = {

  781.     "eac3",

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

  783.     0,

  784.     eac3_probe,

  785.     audio_read_header,

  786.     raw_read_partial_packet,

  787.     .flags= AVFMT_GENERIC_INDEX,

  788.     .extensions = "eac3",

  789.     .value = CODEC_ID_EAC3,

  790. };

  791. #endif

  792. 

  793. #if CONFIG_EAC3_MUXER

  794. AVOutputFormat eac3_muxer = {

  795.     "eac3",

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

  797.     "audio/x-eac3",

  798.     "eac3",

  799.     0,

  800.     CODEC_ID_EAC3,

  801.     CODEC_ID_NONE,

  802.     NULL,

  803.     raw_write_packet,

  804.     .flags= AVFMT_NOTIMESTAMPS,

  805. };

  806. #endif

  807. 

  808. #if CONFIG_FLAC_DEMUXER

  809. AVInputFormat flac_demuxer = {

  810.     "flac",

  811.     NULL_IF_CONFIG_SMALL("raw FLAC"),

  812.     0,

  813.     flac_probe,

  814.     audio_read_header,

  815.     raw_read_partial_packet,

  816.     .flags= AVFMT_GENERIC_INDEX,

  817.     .extensions = "flac",

  818.     .value = CODEC_ID_FLAC,

  819. };

  820. #endif

  821. 

  822. #if CONFIG_GSM_DEMUXER

  823. AVInputFormat gsm_demuxer = {

  824.     "gsm",

  825.     NULL_IF_CONFIG_SMALL("raw GSM"),

  826.     0,

  827.     NULL,

  828.     audio_read_header,

  829.     raw_read_partial_packet,

  830.     .flags= AVFMT_GENERIC_INDEX,

  831.     .extensions = "gsm",

  832.     .value = CODEC_ID_GSM,

  833. };

  834. #endif

  835. 

  836. #if CONFIG_H261_DEMUXER

  837. AVInputFormat h261_demuxer = {

  838.     "h261",

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

  840.     0,

  841.     h261_probe,

  842.     video_read_header,

  843.     raw_read_partial_packet,

  844.     .flags= AVFMT_GENERIC_INDEX,

  845.     .extensions = "h261",

  846.     .value = CODEC_ID_H261,

  847. };

  848. #endif

  849. 

  850. #if CONFIG_H261_MUXER

  851. AVOutputFormat h261_muxer = {

  852.     "h261",

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

  854.     "video/x-h261",

  855.     "h261",

  856.     0,

  857.     CODEC_ID_NONE,

  858.     CODEC_ID_H261,

  859.     NULL,

  860.     raw_write_packet,

  861.     .flags= AVFMT_NOTIMESTAMPS,

  862. };

  863. #endif

  864. 

  865. #if CONFIG_H263_DEMUXER

  866. AVInputFormat h263_demuxer = {

  867.     "h263",

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

  869.     0,

  870.     h263_probe,

  871.     video_read_header,

  872.     raw_read_partial_packet,

  873.     .flags= AVFMT_GENERIC_INDEX,

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

  875.     .value = CODEC_ID_H263,

  876. };

  877. #endif

  878. 

  879. #if CONFIG_H263_MUXER

  880. AVOutputFormat h263_muxer = {

  881.     "h263",

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

  883.     "video/x-h263",

  884.     "h263",

  885.     0,

  886.     CODEC_ID_NONE,

  887.     CODEC_ID_H263,

  888.     NULL,

  889.     raw_write_packet,

  890.     .flags= AVFMT_NOTIMESTAMPS,

  891. };

  892. #endif

  893. 

  894. #if CONFIG_H264_DEMUXER

  895. AVInputFormat h264_demuxer = {

  896.     "h264",

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

  898.     0,

  899.     h264_probe,

  900.     video_read_header,

  901.     raw_read_partial_packet,

  902.     .flags= AVFMT_GENERIC_INDEX,

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

  904.     .value = CODEC_ID_H264,

  905. };

  906. #endif

  907. 

  908. #if CONFIG_H264_MUXER

  909. AVOutputFormat h264_muxer = {

  910.     "h264",

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

  912.     NULL,

  913.     "h264",

  914.     0,

  915.     CODEC_ID_NONE,

  916.     CODEC_ID_H264,

  917.     NULL,

  918.     raw_write_packet,

  919.     .flags= AVFMT_NOTIMESTAMPS,

  920. };

  921. #endif

  922. 

  923. #if CONFIG_INGENIENT_DEMUXER

  924. AVInputFormat ingenient_demuxer = {

  925.     "ingenient",

  926.     NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),

  927.     0,

  928.     NULL,

  929.     video_read_header,

  930.     ingenient_read_packet,

  931.     .flags= AVFMT_GENERIC_INDEX,

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

  933.     .value = CODEC_ID_MJPEG,

  934. };

  935. #endif

  936. 

  937. #if CONFIG_M4V_DEMUXER

  938. AVInputFormat m4v_demuxer = {

  939.     "m4v",

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

  941.     0,

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

  943.     video_read_header,

  944.     raw_read_partial_packet,

  945.     .flags= AVFMT_GENERIC_INDEX,

  946.     .extensions = "m4v",

  947.     .value = CODEC_ID_MPEG4,

  948. };

  949. #endif

  950. 

  951. #if CONFIG_M4V_MUXER

  952. AVOutputFormat m4v_muxer = {

  953.     "m4v",

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

  955.     NULL,

  956.     "m4v",

  957.     0,

  958.     CODEC_ID_NONE,

  959.     CODEC_ID_MPEG4,

  960.     NULL,

  961.     raw_write_packet,

  962.     .flags= AVFMT_NOTIMESTAMPS,

  963. };

  964. #endif

  965. 

  966. #if CONFIG_MJPEG_DEMUXER

  967. AVInputFormat mjpeg_demuxer = {

  968.     "mjpeg",

  969.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  970.     0,

  971.     NULL,

  972.     video_read_header,

  973.     raw_read_partial_packet,

  974.     .flags= AVFMT_GENERIC_INDEX,

  975.     .extensions = "mjpg,mjpeg",

  976.     .value = CODEC_ID_MJPEG,

  977. };

  978. #endif

  979. 

  980. #if CONFIG_MJPEG_MUXER

  981. AVOutputFormat mjpeg_muxer = {

  982.     "mjpeg",

  983.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  984.     "video/x-mjpeg",

  985.     "mjpg,mjpeg",

  986.     0,

  987.     CODEC_ID_NONE,

  988.     CODEC_ID_MJPEG,

  989.     NULL,

  990.     raw_write_packet,

  991.     .flags= AVFMT_NOTIMESTAMPS,

  992. };

  993. #endif

  994. 

  995. #if CONFIG_MLP_DEMUXER

  996. AVInputFormat mlp_demuxer = {

  997.     "mlp",

  998.     NULL_IF_CONFIG_SMALL("raw MLP"),

  999.     0,

  1000.     NULL,

  1001.     audio_read_header,

  1002.     raw_read_partial_packet,

  1003.     .flags= AVFMT_GENERIC_INDEX,

  1004.     .extensions = "mlp",

  1005.     .value = CODEC_ID_MLP,

  1006. };

  1007. #endif

  1008. 

  1009. #if CONFIG_MPEG1VIDEO_MUXER

  1010. AVOutputFormat mpeg1video_muxer = {

  1011.     "mpeg1video",

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

  1013.     "video/x-mpeg",

  1014.     "mpg,mpeg,m1v",

  1015.     0,

  1016.     CODEC_ID_NONE,

  1017.     CODEC_ID_MPEG1VIDEO,

  1018.     NULL,

  1019.     raw_write_packet,

  1020.     .flags= AVFMT_NOTIMESTAMPS,

  1021. };

  1022. #endif

  1023. 

  1024. #if CONFIG_MPEG2VIDEO_MUXER

  1025. AVOutputFormat mpeg2video_muxer = {

  1026.     "mpeg2video",

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

  1028.     NULL,

  1029.     "m2v",

  1030.     0,

  1031.     CODEC_ID_NONE,

  1032.     CODEC_ID_MPEG2VIDEO,

  1033.     NULL,

  1034.     raw_write_packet,

  1035.     .flags= AVFMT_NOTIMESTAMPS,

  1036. };

  1037. #endif

  1038. 

  1039. #if CONFIG_MPEGVIDEO_DEMUXER

  1040. AVInputFormat mpegvideo_demuxer = {

  1041.     "mpegvideo",

  1042.     NULL_IF_CONFIG_SMALL("raw MPEG video"),

  1043.     0,

  1044.     mpegvideo_probe,

  1045.     video_read_header,

  1046.     raw_read_partial_packet,

  1047.     .flags= AVFMT_GENERIC_INDEX,

  1048.     .value = CODEC_ID_MPEG1VIDEO,

  1049. };

  1050. #endif

  1051. 

  1052. #if CONFIG_CAVSVIDEO_DEMUXER

  1053. AVInputFormat cavsvideo_demuxer = {

  1054.     "cavsvideo",

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

  1056.     0,

  1057.     cavsvideo_probe,

  1058.     video_read_header,

  1059.     raw_read_partial_packet,

  1060.     .flags= AVFMT_GENERIC_INDEX,

  1061.     .value = CODEC_ID_CAVS,

  1062. };

  1063. #endif

  1064. 

  1065. #if CONFIG_NULL_MUXER

  1066. AVOutputFormat null_muxer = {

  1067.     "null",

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

  1069.     NULL,

  1070.     NULL,

  1071.     0,

  1072. #ifdef WORDS_BIGENDIAN

  1073.     CODEC_ID_PCM_S16BE,

  1074. #else

  1075.     CODEC_ID_PCM_S16LE,

  1076. #endif

  1077.     CODEC_ID_RAWVIDEO,

  1078.     NULL,

  1079.     null_write_packet,

  1080.     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,

  1081. };

  1082. #endif

  1083. 

  1084. #if CONFIG_RAWVIDEO_DEMUXER

  1085. AVInputFormat rawvideo_demuxer = {

  1086.     "rawvideo",

  1087.     NULL_IF_CONFIG_SMALL("raw video format"),

  1088.     0,

  1089.     NULL,

  1090.     raw_read_header,

  1091.     rawvideo_read_packet,

  1092.     .flags= AVFMT_GENERIC_INDEX,

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

  1094.     .value = CODEC_ID_RAWVIDEO,

  1095. };

  1096. #endif

  1097. 

  1098. #if CONFIG_RAWVIDEO_MUXER

  1099. AVOutputFormat rawvideo_muxer = {

  1100.     "rawvideo",

  1101.     NULL_IF_CONFIG_SMALL("raw video format"),

  1102.     NULL,

  1103.     "yuv,rgb",

  1104.     0,

  1105.     CODEC_ID_NONE,

  1106.     CODEC_ID_RAWVIDEO,

  1107.     NULL,

  1108.     raw_write_packet,

  1109.     .flags= AVFMT_NOTIMESTAMPS,

  1110. };

  1111. #endif

  1112. 

  1113. #if CONFIG_ROQ_MUXER

  1114. AVOutputFormat roq_muxer =

  1115. {

  1116.     "RoQ",

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

  1118.     NULL,

  1119.     "roq",

  1120.     0,

  1121.     CODEC_ID_ROQ_DPCM,

  1122.     CODEC_ID_ROQ,

  1123.     roq_write_header,

  1124.     raw_write_packet,

  1125. };

  1126. #endif

  1127. 

  1128. #if CONFIG_SHORTEN_DEMUXER

  1129. AVInputFormat shorten_demuxer = {

  1130.     "shn",

  1131.     NULL_IF_CONFIG_SMALL("raw Shorten"),

  1132.     0,

  1133.     NULL,

  1134.     audio_read_header,

  1135.     raw_read_partial_packet,

  1136.     .flags= AVFMT_GENERIC_INDEX,

  1137.     .extensions = "shn",

  1138.     .value = CODEC_ID_SHORTEN,

  1139. };

  1140. #endif

  1141. 

  1142. #if CONFIG_VC1_DEMUXER

  1143. AVInputFormat vc1_demuxer = {

  1144.     "vc1",

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

  1146.     0,

  1147.     NULL /* vc1_probe */,

  1148.     video_read_header,

  1149.     raw_read_partial_packet,

  1150.     .extensions = "vc1",

  1151.     .value = CODEC_ID_VC1,

  1152. };

  1153. #endif

  1154. 

  1155. /* PCM formats */

  1156. 

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

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

  1159.     #name,\

  1160.     NULL_IF_CONFIG_SMALL(long_name),\

  1161.     0,\

  1162.     NULL,\

  1163.     raw_read_header,\

  1164.     raw_read_packet,\

  1165.     NULL,\

  1166.     pcm_read_seek,\

  1167.     .flags= AVFMT_GENERIC_INDEX,\

  1168.     .extensions = ext,\

  1169.     .value = codec,\

  1170. };

  1171. 

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

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

  1174.     #name,\

  1175.     NULL_IF_CONFIG_SMALL(long_name),\

  1176.     NULL,\

  1177.     ext,\

  1178.     0,\

  1179.     codec,\

  1180.     CODEC_ID_NONE,\

  1181.     NULL,\

  1182.     raw_write_packet,\

  1183.     .flags= AVFMT_NOTIMESTAMPS,\

  1184. };

  1185. 

  1186. 

  1187. #if  !CONFIG_MUXERS && CONFIG_DEMUXERS

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

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

  1190. #elif CONFIG_MUXERS && !CONFIG_DEMUXERS

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

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

  1193. #elif CONFIG_MUXERS && CONFIG_DEMUXERS

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

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

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

  1197. #else

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

  1199. #endif

  1200. 

  1201. #ifdef WORDS_BIGENDIAN

  1202. #define BE_DEF(s) s

  1203. #define LE_DEF(s) NULL

  1204. #else

  1205. #define BE_DEF(s) NULL

  1206. #define LE_DEF(s) s

  1207. #endif

  1208. 

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

  1210.        NULL, CODEC_ID_PCM_F64BE)

  1211. 

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

  1213.        NULL, CODEC_ID_PCM_F64LE)

  1214. 

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

  1216.        NULL, CODEC_ID_PCM_F32BE)

  1217. 

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

  1219.        NULL, CODEC_ID_PCM_F32LE)

  1220. 

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

  1222.        NULL, CODEC_ID_PCM_S32BE)

  1223. 

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

  1225.        NULL, CODEC_ID_PCM_S32LE)

  1226. 

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

  1228.        NULL, CODEC_ID_PCM_S24BE)

  1229. 

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

  1231.        NULL, CODEC_ID_PCM_S24LE)

  1232. 

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

  1234.        BE_DEF("sw"), CODEC_ID_PCM_S16BE)

  1235. 

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

  1237.        LE_DEF("sw"), CODEC_ID_PCM_S16LE)

  1238. 

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

  1240.        "sb", CODEC_ID_PCM_S8)

  1241. 

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

  1243.        NULL, CODEC_ID_PCM_U32BE)

  1244. 

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

  1246.        NULL, CODEC_ID_PCM_U32LE)

  1247. 

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

  1249.        NULL, CODEC_ID_PCM_U24BE)

  1250. 

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

  1252.        NULL, CODEC_ID_PCM_U24LE)

  1253. 

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

  1255.        BE_DEF("uw"), CODEC_ID_PCM_U16BE)

  1256. 

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

  1258.        LE_DEF("uw"), CODEC_ID_PCM_U16LE)

  1259. 

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

  1261.        "ub", CODEC_ID_PCM_U8)

  1262. 

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

  1264.        "al", CODEC_ID_PCM_ALAW)

  1265. 

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

  1267.        "ul", CODEC_ID_PCM_MULAW)