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

487 lines
11KB
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 "avformat.h"

  24. #include "raw.h"

  25. 

  26. /* simple formats */

  27. 

  28. #if CONFIG_MUXERS

  29. int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)

  30. {

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

  32.     put_flush_packet(s->pb);

  33.     return 0;

  34. }

  35. #endif

  36. 

  37. #if CONFIG_DEMUXERS

  38. /* raw input */

  39. int ff_raw_read_header(AVFormatContext *s, AVFormatParameters *ap)

  40. {

  41.     AVStream *st;

  42.     enum CodecID id;

  43. 

  44.     st = av_new_stream(s, 0);

  45.     if (!st)

  46.         return AVERROR(ENOMEM);

  47. 

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

  49.         if (id == CODEC_ID_RAWVIDEO) {

  50.             st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

  51.         } else {

  52.             st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

  53.         }

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

  55. 

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

  57.         case AVMEDIA_TYPE_AUDIO:

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

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

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

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

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

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

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

  65.             break;

  66.         case AVMEDIA_TYPE_VIDEO:

  67.             if(ap->time_base.num)

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

  69.             else

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

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

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

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

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

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

  76.             break;

  77.         default:

  78.             return -1;

  79.         }

  80.     return 0;

  81. }

  82. 

  83. #define RAW_PACKET_SIZE 1024

  84. 

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

  86. {

  87.     int ret, size;

  88. 

  89.     size = RAW_PACKET_SIZE;

  90. 

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

  92.         return AVERROR(ENOMEM);

  93. 

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

  95.     pkt->stream_index = 0;

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

  97.     if (ret < 0) {

  98.         av_free_packet(pkt);

  99.         return ret;

  100.     }

  101.     pkt->size = ret;

  102.     return ret;

  103. }

  104. 

  105. int ff_raw_audio_read_header(AVFormatContext *s,

  106.                              AVFormatParameters *ap)

  107. {

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

  109.     if (!st)

  110.         return AVERROR(ENOMEM);

  111.     st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

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

  113.     st->need_parsing = AVSTREAM_PARSE_FULL;

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

  115. 

  116.     return 0;

  117. }

  118. 

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

  120. int ff_raw_video_read_header(AVFormatContext *s,

  121.                              AVFormatParameters *ap)

  122. {

  123.     AVStream *st;

  124. 

  125.     st = av_new_stream(s, 0);

  126.     if (!st)

  127.         return AVERROR(ENOMEM);

  128. 

  129.     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

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

  131.     st->need_parsing = AVSTREAM_PARSE_FULL;

  132. 

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

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

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

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

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

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

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

  140.                 st->codec->codec_id == CODEC_ID_DNXHD ||

  141.                 st->codec->codec_id == CODEC_ID_VC1   ||

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

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

  144.     }

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

  146. 

  147.     return 0;

  148. }

  149. #endif

  150. 

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

  152. 

  153. #if CONFIG_AC3_MUXER

  154. AVOutputFormat ac3_muxer = {

  155.     "ac3",

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

  157.     "audio/x-ac3",

  158.     "ac3",

  159.     0,

  160.     CODEC_ID_AC3,

  161.     CODEC_ID_NONE,

  162.     NULL,

  163.     ff_raw_write_packet,

  164.     .flags= AVFMT_NOTIMESTAMPS,

  165. };

  166. #endif

  167. 

  168. #if CONFIG_DIRAC_MUXER

  169. AVOutputFormat dirac_muxer = {

  170.     "dirac",

  171.     NULL_IF_CONFIG_SMALL("raw Dirac"),

  172.     NULL,

  173.     "drc",

  174.     0,

  175.     CODEC_ID_NONE,

  176.     CODEC_ID_DIRAC,

  177.     NULL,

  178.     ff_raw_write_packet,

  179.     .flags= AVFMT_NOTIMESTAMPS,

  180. };

  181. #endif

  182. 

  183. #if CONFIG_DNXHD_MUXER

  184. AVOutputFormat dnxhd_muxer = {

  185.     "dnxhd",

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

  187.     NULL,

  188.     "dnxhd",

  189.     0,

  190.     CODEC_ID_NONE,

  191.     CODEC_ID_DNXHD,

  192.     NULL,

  193.     ff_raw_write_packet,

  194.     .flags= AVFMT_NOTIMESTAMPS,

  195. };

  196. #endif

  197. 

  198. #if CONFIG_DTS_MUXER

  199. AVOutputFormat dts_muxer = {

  200.     "dts",

  201.     NULL_IF_CONFIG_SMALL("raw DTS"),

  202.     "audio/x-dca",

  203.     "dts",

  204.     0,

  205.     CODEC_ID_DTS,

  206.     CODEC_ID_NONE,

  207.     NULL,

  208.     ff_raw_write_packet,

  209.     .flags= AVFMT_NOTIMESTAMPS,

  210. };

  211. #endif

  212. 

  213. #if CONFIG_EAC3_MUXER

  214. AVOutputFormat eac3_muxer = {

  215.     "eac3",

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

  217.     "audio/x-eac3",

  218.     "eac3",

  219.     0,

  220.     CODEC_ID_EAC3,

  221.     CODEC_ID_NONE,

  222.     NULL,

  223.     ff_raw_write_packet,

  224.     .flags= AVFMT_NOTIMESTAMPS,

  225. };

  226. #endif

  227. 

  228. #if CONFIG_GSM_DEMUXER

  229. AVInputFormat gsm_demuxer = {

  230.     "gsm",

  231.     NULL_IF_CONFIG_SMALL("raw GSM"),

  232.     0,

  233.     NULL,

  234.     ff_raw_audio_read_header,

  235.     ff_raw_read_partial_packet,

  236.     .flags= AVFMT_GENERIC_INDEX,

  237.     .extensions = "gsm",

  238.     .value = CODEC_ID_GSM,

  239. };

  240. #endif

  241. 

  242. #if CONFIG_H261_MUXER

  243. AVOutputFormat h261_muxer = {

  244.     "h261",

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

  246.     "video/x-h261",

  247.     "h261",

  248.     0,

  249.     CODEC_ID_NONE,

  250.     CODEC_ID_H261,

  251.     NULL,

  252.     ff_raw_write_packet,

  253.     .flags= AVFMT_NOTIMESTAMPS,

  254. };

  255. #endif

  256. 

  257. #if CONFIG_H263_MUXER

  258. AVOutputFormat h263_muxer = {

  259.     "h263",

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

  261.     "video/x-h263",

  262.     "h263",

  263.     0,

  264.     CODEC_ID_NONE,

  265.     CODEC_ID_H263,

  266.     NULL,

  267.     ff_raw_write_packet,

  268.     .flags= AVFMT_NOTIMESTAMPS,

  269. };

  270. #endif

  271. 

  272. #if CONFIG_H264_MUXER

  273. AVOutputFormat h264_muxer = {

  274.     "h264",

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

  276.     NULL,

  277.     "h264",

  278.     0,

  279.     CODEC_ID_NONE,

  280.     CODEC_ID_H264,

  281.     NULL,

  282.     ff_raw_write_packet,

  283.     .flags= AVFMT_NOTIMESTAMPS,

  284. };

  285. #endif

  286. 

  287. #if CONFIG_CAVSVIDEO_MUXER

  288. AVOutputFormat cavsvideo_muxer = {

  289.     "cavsvideo",

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

  291.     NULL,

  292.     "cavs",

  293.     0,

  294.     CODEC_ID_NONE,

  295.     CODEC_ID_CAVS,

  296.     NULL,

  297.     ff_raw_write_packet,

  298.     .flags= AVFMT_NOTIMESTAMPS,

  299. };

  300. #endif

  301. 

  302. #if CONFIG_M4V_MUXER

  303. AVOutputFormat m4v_muxer = {

  304.     "m4v",

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

  306.     NULL,

  307.     "m4v",

  308.     0,

  309.     CODEC_ID_NONE,

  310.     CODEC_ID_MPEG4,

  311.     NULL,

  312.     ff_raw_write_packet,

  313.     .flags= AVFMT_NOTIMESTAMPS,

  314. };

  315. #endif

  316. 

  317. #if CONFIG_MJPEG_DEMUXER

  318. AVInputFormat mjpeg_demuxer = {

  319.     "mjpeg",

  320.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  321.     0,

  322.     NULL,

  323.     ff_raw_video_read_header,

  324.     ff_raw_read_partial_packet,

  325.     .flags= AVFMT_GENERIC_INDEX,

  326.     .extensions = "mjpg,mjpeg",

  327.     .value = CODEC_ID_MJPEG,

  328. };

  329. #endif

  330. 

  331. #if CONFIG_MJPEG_MUXER

  332. AVOutputFormat mjpeg_muxer = {

  333.     "mjpeg",

  334.     NULL_IF_CONFIG_SMALL("raw MJPEG video"),

  335.     "video/x-mjpeg",

  336.     "mjpg,mjpeg",

  337.     0,

  338.     CODEC_ID_NONE,

  339.     CODEC_ID_MJPEG,

  340.     NULL,

  341.     ff_raw_write_packet,

  342.     .flags= AVFMT_NOTIMESTAMPS,

  343. };

  344. #endif

  345. 

  346. #if CONFIG_MLP_DEMUXER

  347. AVInputFormat mlp_demuxer = {

  348.     "mlp",

  349.     NULL_IF_CONFIG_SMALL("raw MLP"),

  350.     0,

  351.     NULL,

  352.     ff_raw_audio_read_header,

  353.     ff_raw_read_partial_packet,

  354.     .flags= AVFMT_GENERIC_INDEX,

  355.     .extensions = "mlp",

  356.     .value = CODEC_ID_MLP,

  357. };

  358. #endif

  359. 

  360. #if CONFIG_MLP_MUXER

  361. AVOutputFormat mlp_muxer = {

  362.     "mlp",

  363.     NULL_IF_CONFIG_SMALL("raw MLP"),

  364.     NULL,

  365.     "mlp",

  366.     0,

  367.     CODEC_ID_MLP,

  368.     CODEC_ID_NONE,

  369.     NULL,

  370.     ff_raw_write_packet,

  371.     .flags= AVFMT_NOTIMESTAMPS,

  372. };

  373. #endif

  374. 

  375. #if CONFIG_SRT_MUXER

  376. AVOutputFormat srt_muxer = {

  377.     .name           = "srt",

  378.     .long_name      = NULL_IF_CONFIG_SMALL("SubRip subtitle format"),

  379.     .mime_type      = "application/x-subrip",

  380.     .extensions     = "srt",

  381.     .write_packet   = ff_raw_write_packet,

  382.     .flags          = AVFMT_NOTIMESTAMPS,

  383.     .subtitle_codec = CODEC_ID_SRT,

  384. };

  385. #endif

  386. 

  387. #if CONFIG_TRUEHD_DEMUXER

  388. AVInputFormat truehd_demuxer = {

  389.     "truehd",

  390.     NULL_IF_CONFIG_SMALL("raw TrueHD"),

  391.     0,

  392.     NULL,

  393.     ff_raw_audio_read_header,

  394.     ff_raw_read_partial_packet,

  395.     .flags= AVFMT_GENERIC_INDEX,

  396.     .extensions = "thd",

  397.     .value = CODEC_ID_TRUEHD,

  398. };

  399. #endif

  400. 

  401. #if CONFIG_TRUEHD_MUXER

  402. AVOutputFormat truehd_muxer = {

  403.     "truehd",

  404.     NULL_IF_CONFIG_SMALL("raw TrueHD"),

  405.     NULL,

  406.     "thd",

  407.     0,

  408.     CODEC_ID_TRUEHD,

  409.     CODEC_ID_NONE,

  410.     NULL,

  411.     ff_raw_write_packet,

  412.     .flags= AVFMT_NOTIMESTAMPS,

  413. };

  414. #endif

  415. 

  416. #if CONFIG_MPEG1VIDEO_MUXER

  417. AVOutputFormat mpeg1video_muxer = {

  418.     "mpeg1video",

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

  420.     "video/x-mpeg",

  421.     "mpg,mpeg,m1v",

  422.     0,

  423.     CODEC_ID_NONE,

  424.     CODEC_ID_MPEG1VIDEO,

  425.     NULL,

  426.     ff_raw_write_packet,

  427.     .flags= AVFMT_NOTIMESTAMPS,

  428. };

  429. #endif

  430. 

  431. #if CONFIG_MPEG2VIDEO_MUXER

  432. AVOutputFormat mpeg2video_muxer = {

  433.     "mpeg2video",

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

  435.     NULL,

  436.     "m2v",

  437.     0,

  438.     CODEC_ID_NONE,

  439.     CODEC_ID_MPEG2VIDEO,

  440.     NULL,

  441.     ff_raw_write_packet,

  442.     .flags= AVFMT_NOTIMESTAMPS,

  443. };

  444. #endif

  445. 

  446. #if CONFIG_RAWVIDEO_MUXER

  447. AVOutputFormat rawvideo_muxer = {

  448.     "rawvideo",

  449.     NULL_IF_CONFIG_SMALL("raw video format"),

  450.     NULL,

  451.     "yuv,rgb",

  452.     0,

  453.     CODEC_ID_NONE,

  454.     CODEC_ID_RAWVIDEO,

  455.     NULL,

  456.     ff_raw_write_packet,

  457.     .flags= AVFMT_NOTIMESTAMPS,

  458. };

  459. #endif

  460. 

  461. #if CONFIG_SHORTEN_DEMUXER

  462. AVInputFormat shorten_demuxer = {

  463.     "shn",

  464.     NULL_IF_CONFIG_SMALL("raw Shorten"),

  465.     0,

  466.     NULL,

  467.     ff_raw_audio_read_header,

  468.     ff_raw_read_partial_packet,

  469.     .flags= AVFMT_GENERIC_INDEX,

  470.     .extensions = "shn",

  471.     .value = CODEC_ID_SHORTEN,

  472. };

  473. #endif

  474. 

  475. #if CONFIG_VC1_DEMUXER

  476. AVInputFormat vc1_demuxer = {

  477.     "vc1",

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

  479.     0,

  480.     NULL /* vc1_probe */,

  481.     ff_raw_video_read_header,

  482.     ff_raw_read_partial_packet,

  483.     .extensions = "vc1",

  484.     .value = CODEC_ID_VC1,

  485. };

  486. #endif