Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * RIFF muxing functions
  3.  * Copyright (c) 2000 Fabrice Bellard
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include "libavutil/dict.h"
  23. #include "libavutil/log.h"
  24. #include "libavutil/mathematics.h"
  25. #include "libavcodec/avcodec.h"
  26. #include "libavcodec/bytestream.h"
  27. #include "avformat.h"
  28. #include "avio_internal.h"
  29. #include "riff.h"
  30.  
  31. int64_t ff_start_tag(AVIOContext *pb, const char *tag)
  32. {
  33.     ffio_wfourcc(pb, tag);
  34.     avio_wl32(pb, -1);
  35.     return avio_tell(pb);
  36. }
  37.  
  38. void ff_end_tag(AVIOContext *pb, int64_t start)
  39. {
  40.     int64_t pos;
  41.  
  42.     av_assert0((start&1) == 0);
  43.  
  44.     pos = avio_tell(pb);
  45.     if (pos & 1)
  46.         avio_w8(pb, 0);
  47.     avio_seek(pb, start - 4, SEEK_SET);
  48.     avio_wl32(pb, (uint32_t)(pos - start));
  49.     avio_seek(pb, FFALIGN(pos, 2), SEEK_SET);
  50. }
  51.  
  52. /* WAVEFORMATEX header */
  53. /* returns the size or -1 on error */
  54. int ff_put_wav_header(AVIOContext *pb, AVCodecContext *enc, int flags)
  55. {
  56.     int bps, blkalign, bytespersec, frame_size;
  57.     int hdrsize;
  58.     int64_t hdrstart = avio_tell(pb);
  59.     int waveformatextensible;
  60.     uint8_t temp[256];
  61.     uint8_t *riff_extradata       = temp;
  62.     uint8_t *riff_extradata_start = temp;
  63.  
  64.     if (!enc->codec_tag || enc->codec_tag > 0xffff)
  65.         return -1;
  66.  
  67.     /* We use the known constant frame size for the codec if known, otherwise
  68.      * fall back on using AVCodecContext.frame_size, which is not as reliable
  69.      * for indicating packet duration. */
  70.     frame_size = av_get_audio_frame_duration(enc, enc->block_align);
  71.  
  72.     waveformatextensible = (enc->channels > 2 && enc->channel_layout) ||
  73.                            enc->sample_rate > 48000 ||
  74.                            enc->codec_id == AV_CODEC_ID_EAC3 ||
  75.                            av_get_bits_per_sample(enc->codec_id) > 16;
  76.  
  77.     if (waveformatextensible)
  78.         avio_wl16(pb, 0xfffe);
  79.     else
  80.         avio_wl16(pb, enc->codec_tag);
  81.  
  82.     avio_wl16(pb, enc->channels);
  83.     avio_wl32(pb, enc->sample_rate);
  84.     if (enc->codec_id == AV_CODEC_ID_ATRAC3 ||
  85.         enc->codec_id == AV_CODEC_ID_G723_1 ||
  86.         enc->codec_id == AV_CODEC_ID_MP2    ||
  87.         enc->codec_id == AV_CODEC_ID_MP3    ||
  88.         enc->codec_id == AV_CODEC_ID_GSM_MS) {
  89.         bps = 0;
  90.     } else {
  91.         if (!(bps = av_get_bits_per_sample(enc->codec_id))) {
  92.             if (enc->bits_per_coded_sample)
  93.                 bps = enc->bits_per_coded_sample;
  94.             else
  95.                 bps = 16;  // default to 16
  96.         }
  97.     }
  98.     if (bps != enc->bits_per_coded_sample && enc->bits_per_coded_sample) {
  99.         av_log(enc, AV_LOG_WARNING,
  100.                "requested bits_per_coded_sample (%d) "
  101.                "and actually stored (%d) differ\n",
  102.                enc->bits_per_coded_sample, bps);
  103.     }
  104.  
  105.     if (enc->codec_id == AV_CODEC_ID_MP2) {
  106.         blkalign = (144 * enc->bit_rate - 1)/enc->sample_rate + 1;
  107.     } else if (enc->codec_id == AV_CODEC_ID_MP3) {
  108.         blkalign = 576 * (enc->sample_rate <= (24000 + 32000)/2 ? 1 : 2);
  109.     } else if (enc->codec_id == AV_CODEC_ID_AC3) {
  110.         blkalign = 3840;                /* maximum bytes per frame */
  111.     } else if (enc->codec_id == AV_CODEC_ID_AAC) {
  112.         blkalign = 768 * enc->channels; /* maximum bytes per frame */
  113.     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
  114.         blkalign = 24;
  115.     } else if (enc->block_align != 0) { /* specified by the codec */
  116.         blkalign = enc->block_align;
  117.     } else
  118.         blkalign = bps * enc->channels / av_gcd(8, bps);
  119.     if (enc->codec_id == AV_CODEC_ID_PCM_U8 ||
  120.         enc->codec_id == AV_CODEC_ID_PCM_S24LE ||
  121.         enc->codec_id == AV_CODEC_ID_PCM_S32LE ||
  122.         enc->codec_id == AV_CODEC_ID_PCM_F32LE ||
  123.         enc->codec_id == AV_CODEC_ID_PCM_F64LE ||
  124.         enc->codec_id == AV_CODEC_ID_PCM_S16LE) {
  125.         bytespersec = enc->sample_rate * blkalign;
  126.     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
  127.         bytespersec = 800;
  128.     } else {
  129.         bytespersec = enc->bit_rate / 8;
  130.     }
  131.     avio_wl32(pb, bytespersec); /* bytes per second */
  132.     avio_wl16(pb, blkalign);    /* block align */
  133.     avio_wl16(pb, bps);         /* bits per sample */
  134.     if (enc->codec_id == AV_CODEC_ID_MP3) {
  135.         bytestream_put_le16(&riff_extradata, 1);    /* wID */
  136.         bytestream_put_le32(&riff_extradata, 2);    /* fdwFlags */
  137.         bytestream_put_le16(&riff_extradata, 1152); /* nBlockSize */
  138.         bytestream_put_le16(&riff_extradata, 1);    /* nFramesPerBlock */
  139.         bytestream_put_le16(&riff_extradata, 1393); /* nCodecDelay */
  140.     } else if (enc->codec_id == AV_CODEC_ID_MP2) {
  141.         /* fwHeadLayer */
  142.         bytestream_put_le16(&riff_extradata, 2);
  143.         /* dwHeadBitrate */
  144.         bytestream_put_le32(&riff_extradata, enc->bit_rate);
  145.         /* fwHeadMode */
  146.         bytestream_put_le16(&riff_extradata, enc->channels == 2 ? 1 : 8);
  147.         /* fwHeadModeExt */
  148.         bytestream_put_le16(&riff_extradata, 0);
  149.         /* wHeadEmphasis */
  150.         bytestream_put_le16(&riff_extradata, 1);
  151.         /* fwHeadFlags */
  152.         bytestream_put_le16(&riff_extradata, 16);
  153.         /* dwPTSLow */
  154.         bytestream_put_le32(&riff_extradata, 0);
  155.         /* dwPTSHigh */
  156.         bytestream_put_le32(&riff_extradata, 0);
  157.     } else if (enc->codec_id == AV_CODEC_ID_G723_1) {
  158.         bytestream_put_le32(&riff_extradata, 0x9ace0002); /* extradata needed for msacm g723.1 codec */
  159.         bytestream_put_le32(&riff_extradata, 0xaea2f732);
  160.         bytestream_put_le16(&riff_extradata, 0xacde);
  161.     } else if (enc->codec_id == AV_CODEC_ID_GSM_MS ||
  162.                enc->codec_id == AV_CODEC_ID_ADPCM_IMA_WAV) {
  163.         /* wSamplesPerBlock */
  164.         bytestream_put_le16(&riff_extradata, frame_size);
  165.     } else if (enc->extradata_size) {
  166.         riff_extradata_start = enc->extradata;
  167.         riff_extradata       = enc->extradata + enc->extradata_size;
  168.     }
  169.     /* write WAVEFORMATEXTENSIBLE extensions */
  170.     if (waveformatextensible) {
  171.         int write_channel_mask = enc->strict_std_compliance < FF_COMPLIANCE_NORMAL ||
  172.                                  enc->channel_layout < 0x40000;
  173.         /* 22 is WAVEFORMATEXTENSIBLE size */
  174.         avio_wl16(pb, riff_extradata - riff_extradata_start + 22);
  175.         /* ValidBitsPerSample || SamplesPerBlock || Reserved */
  176.         avio_wl16(pb, bps);
  177.         /* dwChannelMask */
  178.         avio_wl32(pb, write_channel_mask ? enc->channel_layout : 0);
  179.         /* GUID + next 3 */
  180.         if (enc->codec_id == AV_CODEC_ID_EAC3) {
  181.             ff_put_guid(pb, ff_get_codec_guid(enc->codec_id, ff_codec_wav_guids));
  182.         } else {
  183.         avio_wl32(pb, enc->codec_tag);
  184.         avio_wl32(pb, 0x00100000);
  185.         avio_wl32(pb, 0xAA000080);
  186.         avio_wl32(pb, 0x719B3800);
  187.         }
  188.     } else if ((flags & FF_PUT_WAV_HEADER_FORCE_WAVEFORMATEX) ||
  189.                enc->codec_tag != 0x0001 /* PCM */ ||
  190.                riff_extradata - riff_extradata_start) {
  191.         /* WAVEFORMATEX */
  192.         avio_wl16(pb, riff_extradata - riff_extradata_start); /* cbSize */
  193.     } /* else PCMWAVEFORMAT */
  194.     avio_write(pb, riff_extradata_start, riff_extradata - riff_extradata_start);
  195.     hdrsize = avio_tell(pb) - hdrstart;
  196.     if (hdrsize & 1) {
  197.         hdrsize++;
  198.         avio_w8(pb, 0);
  199.     }
  200.  
  201.     return hdrsize;
  202. }
  203.  
  204. /* BITMAPINFOHEADER header */
  205. void ff_put_bmp_header(AVIOContext *pb, AVCodecContext *enc,
  206.                        const AVCodecTag *tags, int for_asf, int ignore_extradata)
  207. {
  208.     int keep_height = enc->extradata_size >= 9 &&
  209.                       !memcmp(enc->extradata + enc->extradata_size - 9, "BottomUp", 9);
  210.     int extradata_size = enc->extradata_size - 9*keep_height;
  211.  
  212.     /* size */
  213.     avio_wl32(pb, 40 + (ignore_extradata ? 0 :extradata_size));
  214.     avio_wl32(pb, enc->width);
  215.     //We always store RGB TopDown
  216.     avio_wl32(pb, enc->codec_tag || keep_height ? enc->height : -enc->height);
  217.     /* planes */
  218.     avio_wl16(pb, 1);
  219.     /* depth */
  220.     avio_wl16(pb, enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24);
  221.     /* compression type */
  222.     avio_wl32(pb, enc->codec_tag);
  223.     avio_wl32(pb, (enc->width * enc->height * (enc->bits_per_coded_sample ? enc->bits_per_coded_sample : 24)+7) / 8);
  224.     avio_wl32(pb, 0);
  225.     avio_wl32(pb, 0);
  226.     avio_wl32(pb, 0);
  227.     avio_wl32(pb, 0);
  228.  
  229.     if (!ignore_extradata) {
  230.         avio_write(pb, enc->extradata, extradata_size);
  231.  
  232.         if (!for_asf && extradata_size & 1)
  233.             avio_w8(pb, 0);
  234.     }
  235. }
  236.  
  237. void ff_parse_specific_params(AVStream *st, int *au_rate,
  238.                               int *au_ssize, int *au_scale)
  239. {
  240.     AVCodecContext *codec = st->codec;
  241.     int gcd;
  242.     int audio_frame_size;
  243.  
  244.     /* We use the known constant frame size for the codec if known, otherwise
  245.      * fall back on using AVCodecContext.frame_size, which is not as reliable
  246.      * for indicating packet duration. */
  247.     audio_frame_size = av_get_audio_frame_duration(codec, 0);
  248.     if (!audio_frame_size)
  249.         audio_frame_size = codec->frame_size;
  250.  
  251.     *au_ssize = codec->block_align;
  252.     if (audio_frame_size && codec->sample_rate) {
  253.         *au_scale = audio_frame_size;
  254.         *au_rate  = codec->sample_rate;
  255.     } else if (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
  256.                codec->codec_type == AVMEDIA_TYPE_DATA ||
  257.                codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
  258.         *au_scale = st->time_base.num;
  259.         *au_rate  = st->time_base.den;
  260.     } else {
  261.         *au_scale = codec->block_align ? codec->block_align * 8 : 8;
  262.         *au_rate  = codec->bit_rate ? codec->bit_rate :
  263.                     8 * codec->sample_rate;
  264.     }
  265.     gcd        = av_gcd(*au_scale, *au_rate);
  266.     *au_scale /= gcd;
  267.     *au_rate  /= gcd;
  268. }
  269.  
  270. void ff_riff_write_info_tag(AVIOContext *pb, const char *tag, const char *str)
  271. {
  272.     size_t len = strlen(str);
  273.     if (len > 0 && len < UINT32_MAX) {
  274.         len++;
  275.         ffio_wfourcc(pb, tag);
  276.         avio_wl32(pb, len);
  277.         avio_put_str(pb, str);
  278.         if (len & 1)
  279.             avio_w8(pb, 0);
  280.     }
  281. }
  282.  
  283. static const char riff_tags[][5] = {
  284.     "IARL", "IART", "ICMS", "ICMT", "ICOP", "ICRD", "ICRP", "IDIM", "IDPI",
  285.     "IENG", "IGNR", "IKEY", "ILGT", "ILNG", "IMED", "INAM", "IPLT", "IPRD",
  286.     "IPRT", "ITRK", "ISBJ", "ISFT", "ISHP", "ISMP", "ISRC", "ISRF", "ITCH",
  287.     { 0 }
  288. };
  289.  
  290. static int riff_has_valid_tags(AVFormatContext *s)
  291. {
  292.     int i;
  293.  
  294.     for (i = 0; *riff_tags[i]; i++)
  295.         if (av_dict_get(s->metadata, riff_tags[i], NULL, AV_DICT_MATCH_CASE))
  296.             return 1;
  297.  
  298.     return 0;
  299. }
  300.  
  301. void ff_riff_write_info(AVFormatContext *s)
  302. {
  303.     AVIOContext *pb = s->pb;
  304.     int i;
  305.     int64_t list_pos;
  306.     AVDictionaryEntry *t = NULL;
  307.  
  308.     ff_metadata_conv(&s->metadata, ff_riff_info_conv, NULL);
  309.  
  310.     /* writing empty LIST is not nice and may cause problems */
  311.     if (!riff_has_valid_tags(s))
  312.         return;
  313.  
  314.     list_pos = ff_start_tag(pb, "LIST");
  315.     ffio_wfourcc(pb, "INFO");
  316.     for (i = 0; *riff_tags[i]; i++)
  317.         if ((t = av_dict_get(s->metadata, riff_tags[i],
  318.                              NULL, AV_DICT_MATCH_CASE)))
  319.             ff_riff_write_info_tag(s->pb, t->key, t->value);
  320.     ff_end_tag(pb, list_pos);
  321. }
  322.  
  323. void ff_put_guid(AVIOContext *s, const ff_asf_guid *g)
  324. {
  325.     av_assert0(sizeof(*g) == 16);
  326.     avio_write(s, *g, sizeof(*g));
  327. }
  328.  
  329. const ff_asf_guid *ff_get_codec_guid(enum AVCodecID id, const AVCodecGuid *av_guid)
  330. {
  331.     int i;
  332.     for (i = 0; av_guid[i].id != AV_CODEC_ID_NONE; i++) {
  333.         if (id == av_guid[i].id)
  334.             return &(av_guid[i].guid);
  335.     }
  336.     return NULL;
  337. }
  338.