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.

238 lines
7.8KB

  1. /*
  2. * RIFF demuxing functions and data
  3. * Copyright (c) 2000 Fabrice Bellard
  4. *
  5. * This file is part of Libav.
  6. *
  7. * Libav 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. * Libav 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 Libav; if not, write to the Free Software
  19. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20. */
  21. #include "libavutil/dict.h"
  22. #include "libavutil/error.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. const AVCodecGuid ff_codec_wav_guids[] = {
  31. { AV_CODEC_ID_AC3, { 0x2C, 0x80, 0x6D, 0xE0, 0x46, 0xDB, 0xCF, 0x11, 0xB4, 0xD1, 0x00, 0x80, 0x5F, 0x6C, 0xBB, 0xEA } },
  32. { AV_CODEC_ID_ATRAC3P, { 0xBF, 0xAA, 0x23, 0xE9, 0x58, 0xCB, 0x71, 0x44, 0xA1, 0x19, 0xFF, 0xFA, 0x01, 0xE4, 0xCE, 0x62 } },
  33. { AV_CODEC_ID_EAC3, { 0xAF, 0x87, 0xFB, 0xA7, 0x02, 0x2D, 0xFB, 0x42, 0xA4, 0xD4, 0x05, 0xCD, 0x93, 0x84, 0x3B, 0xDD } },
  34. { AV_CODEC_ID_MP2, { 0x2B, 0x80, 0x6D, 0xE0, 0x46, 0xDB, 0xCF, 0x11, 0xB4, 0xD1, 0x00, 0x80, 0x5F, 0x6C, 0xBB, 0xEA } },
  35. { AV_CODEC_ID_NONE }
  36. };
  37. enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
  38. {
  39. int i;
  40. for (i = 0; guids[i].id != AV_CODEC_ID_NONE; i++)
  41. if (!ff_guidcmp(guids[i].guid, guid))
  42. return guids[i].id;
  43. return AV_CODEC_ID_NONE;
  44. }
  45. /* We could be given one of the three possible structures here:
  46. * WAVEFORMAT, PCMWAVEFORMAT or WAVEFORMATEX. Each structure
  47. * is an expansion of the previous one with the fields added
  48. * at the bottom. PCMWAVEFORMAT adds 'WORD wBitsPerSample' and
  49. * WAVEFORMATEX adds 'WORD cbSize' and basically makes itself
  50. * an openended structure.
  51. */
  52. static void parse_waveformatex(AVIOContext *pb, AVCodecContext *c)
  53. {
  54. ff_asf_guid subformat;
  55. c->bits_per_coded_sample = avio_rl16(pb);
  56. c->channel_layout = avio_rl32(pb); /* dwChannelMask */
  57. ff_get_guid(pb, &subformat);
  58. if (!memcmp(subformat + 4,
  59. (const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) {
  60. c->codec_tag = AV_RL32(subformat);
  61. c->codec_id = ff_wav_codec_get_id(c->codec_tag,
  62. c->bits_per_coded_sample);
  63. } else {
  64. c->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subformat);
  65. if (!c->codec_id)
  66. av_log(c, AV_LOG_WARNING,
  67. "unknown subformat:"FF_PRI_GUID"\n",
  68. FF_ARG_GUID(subformat));
  69. }
  70. }
  71. int ff_get_wav_header(AVIOContext *pb, AVCodecContext *codec, int size)
  72. {
  73. int id;
  74. if (size < 14)
  75. return AVERROR_INVALIDDATA;
  76. id = avio_rl16(pb);
  77. codec->codec_type = AVMEDIA_TYPE_AUDIO;
  78. codec->channels = avio_rl16(pb);
  79. codec->sample_rate = avio_rl32(pb);
  80. codec->bit_rate = avio_rl32(pb) * 8;
  81. codec->block_align = avio_rl16(pb);
  82. if (size == 14) { /* We're dealing with plain vanilla WAVEFORMAT */
  83. codec->bits_per_coded_sample = 8;
  84. } else
  85. codec->bits_per_coded_sample = avio_rl16(pb);
  86. if (id == 0xFFFE) {
  87. codec->codec_tag = 0;
  88. } else {
  89. codec->codec_tag = id;
  90. codec->codec_id = ff_wav_codec_get_id(id,
  91. codec->bits_per_coded_sample);
  92. }
  93. if (size >= 18) { /* We're obviously dealing with WAVEFORMATEX */
  94. int cbSize = avio_rl16(pb); /* cbSize */
  95. size -= 18;
  96. cbSize = FFMIN(size, cbSize);
  97. if (cbSize >= 22 && id == 0xfffe) { /* WAVEFORMATEXTENSIBLE */
  98. parse_waveformatex(pb, codec);
  99. cbSize -= 22;
  100. size -= 22;
  101. }
  102. codec->extradata_size = cbSize;
  103. if (cbSize > 0) {
  104. av_free(codec->extradata);
  105. codec->extradata = av_mallocz(codec->extradata_size +
  106. FF_INPUT_BUFFER_PADDING_SIZE);
  107. if (!codec->extradata)
  108. return AVERROR(ENOMEM);
  109. avio_read(pb, codec->extradata, codec->extradata_size);
  110. size -= cbSize;
  111. }
  112. /* It is possible for the chunk to contain garbage at the end */
  113. if (size > 0)
  114. avio_skip(pb, size);
  115. }
  116. if (codec->sample_rate <= 0) {
  117. av_log(NULL, AV_LOG_ERROR,
  118. "Invalid sample rate: %d\n", codec->sample_rate);
  119. return AVERROR_INVALIDDATA;
  120. }
  121. if (codec->codec_id == AV_CODEC_ID_AAC_LATM) {
  122. /* Channels and sample_rate values are those prior to applying SBR
  123. * and/or PS. */
  124. codec->channels = 0;
  125. codec->sample_rate = 0;
  126. }
  127. /* override bits_per_coded_sample for G.726 */
  128. if (codec->codec_id == AV_CODEC_ID_ADPCM_G726)
  129. codec->bits_per_coded_sample = codec->bit_rate / codec->sample_rate;
  130. return 0;
  131. }
  132. enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
  133. {
  134. enum AVCodecID id;
  135. id = ff_codec_get_id(ff_codec_wav_tags, tag);
  136. if (id <= 0)
  137. return id;
  138. if (id == AV_CODEC_ID_PCM_S16LE)
  139. id = ff_get_pcm_codec_id(bps, 0, 0, ~1);
  140. else if (id == AV_CODEC_ID_PCM_F32LE)
  141. id = ff_get_pcm_codec_id(bps, 1, 0, 0);
  142. if (id == AV_CODEC_ID_ADPCM_IMA_WAV && bps == 8)
  143. id = AV_CODEC_ID_PCM_ZORK;
  144. return id;
  145. }
  146. int ff_get_bmp_header(AVIOContext *pb, AVStream *st)
  147. {
  148. int tag1;
  149. avio_rl32(pb); /* size */
  150. st->codec->width = avio_rl32(pb);
  151. st->codec->height = (int32_t)avio_rl32(pb);
  152. avio_rl16(pb); /* planes */
  153. st->codec->bits_per_coded_sample = avio_rl16(pb); /* depth */
  154. tag1 = avio_rl32(pb);
  155. avio_rl32(pb); /* ImageSize */
  156. avio_rl32(pb); /* XPelsPerMeter */
  157. avio_rl32(pb); /* YPelsPerMeter */
  158. avio_rl32(pb); /* ClrUsed */
  159. avio_rl32(pb); /* ClrImportant */
  160. return tag1;
  161. }
  162. int ff_read_riff_info(AVFormatContext *s, int64_t size)
  163. {
  164. int64_t start, end, cur;
  165. AVIOContext *pb = s->pb;
  166. start = avio_tell(pb);
  167. end = start + size;
  168. while ((cur = avio_tell(pb)) >= 0 &&
  169. cur <= end - 8 /* = tag + size */) {
  170. uint32_t chunk_code;
  171. int64_t chunk_size;
  172. char key[5] = { 0 };
  173. char *value;
  174. chunk_code = avio_rl32(pb);
  175. chunk_size = avio_rl32(pb);
  176. if (chunk_size > end ||
  177. end - chunk_size < cur ||
  178. chunk_size == UINT_MAX) {
  179. av_log(s, AV_LOG_WARNING, "too big INFO subchunk\n");
  180. break;
  181. }
  182. chunk_size += (chunk_size & 1);
  183. if (!chunk_code) {
  184. if (chunk_size)
  185. avio_skip(pb, chunk_size);
  186. else if (pb->eof_reached) {
  187. av_log(s, AV_LOG_WARNING, "truncated file\n");
  188. return AVERROR_EOF;
  189. }
  190. continue;
  191. }
  192. value = av_malloc(chunk_size + 1);
  193. if (!value) {
  194. av_log(s, AV_LOG_ERROR,
  195. "out of memory, unable to read INFO tag\n");
  196. return AVERROR(ENOMEM);
  197. }
  198. AV_WL32(key, chunk_code);
  199. if (avio_read(pb, value, chunk_size) != chunk_size) {
  200. av_free(value);
  201. av_log(s, AV_LOG_WARNING,
  202. "premature end of file while reading INFO tag\n");
  203. break;
  204. }
  205. value[chunk_size] = 0;
  206. av_dict_set(&s->metadata, key, value, AV_DICT_DONT_STRDUP_VAL);
  207. }
  208. return 0;
  209. }