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.

297 lines
7.8KB

  1. /*
  2. * Creative Voice File demuxer.
  3. * Copyright (c) 2006 Aurelien Jacobs <aurel@gnuage.org>
  4. *
  5. * This library is free software; you can redistribute it and/or
  6. * modify it under the terms of the GNU Lesser General Public
  7. * License as published by the Free Software Foundation; either
  8. * version 2 of the License, or (at your option) any later version.
  9. *
  10. * This library is distributed in the hope that it will be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13. * Lesser General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU Lesser General Public
  16. * License along with this library; if not, write to the Free Software
  17. * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18. */
  19. #include "avformat.h"
  20. #include "avi.h" /* for CodecTag */
  21. #include "voc.h"
  22. typedef enum voc_type {
  23. VOC_TYPE_EOF = 0x00,
  24. VOC_TYPE_VOICE_DATA = 0x01,
  25. VOC_TYPE_VOICE_DATA_CONT = 0x02,
  26. VOC_TYPE_SILENCE = 0x03,
  27. VOC_TYPE_MARKER = 0x04,
  28. VOC_TYPE_ASCII = 0x05,
  29. VOC_TYPE_REPETITION_START = 0x06,
  30. VOC_TYPE_REPETITION_END = 0x07,
  31. VOC_TYPE_EXTENDED = 0x08,
  32. VOC_TYPE_NEW_VOICE_DATA = 0x09,
  33. } voc_type_t;
  34. static const int voc_max_pkt_size = 2048;
  35. static const unsigned char voc_magic[] = "Creative Voice File\x1A";
  36. static const CodecTag voc_codec_tags[] = {
  37. {CODEC_ID_PCM_U8, 0x00},
  38. {CODEC_ID_ADPCM_SBPRO_4, 0x01},
  39. {CODEC_ID_ADPCM_SBPRO_3, 0x02},
  40. {CODEC_ID_ADPCM_SBPRO_2, 0x03},
  41. {CODEC_ID_PCM_S16LE, 0x04},
  42. {CODEC_ID_PCM_ALAW, 0x06},
  43. {CODEC_ID_PCM_MULAW, 0x07},
  44. {CODEC_ID_ADPCM_CT, 0x0200},
  45. {0, 0},
  46. };
  47. #ifdef CONFIG_DEMUXERS
  48. static int voc_probe(AVProbeData *p)
  49. {
  50. int version, check;
  51. if (p->buf_size < 26)
  52. return 0;
  53. if (memcmp(p->buf, voc_magic, sizeof(voc_magic) - 1))
  54. return 0;
  55. version = p->buf[22] | (p->buf[23] << 8);
  56. check = p->buf[24] | (p->buf[25] << 8);
  57. if (~version + 0x1234 != check)
  58. return 10;
  59. return AVPROBE_SCORE_MAX;
  60. }
  61. static int voc_read_header(AVFormatContext *s, AVFormatParameters *ap)
  62. {
  63. voc_dec_context_t *voc = s->priv_data;
  64. ByteIOContext *pb = &s->pb;
  65. int header_size;
  66. AVStream *st;
  67. url_fskip(pb, 20);
  68. header_size = get_le16(pb) - 22;
  69. if (header_size != 4) {
  70. av_log(s, AV_LOG_ERROR, "unkown header size: %d\n", header_size);
  71. return AVERROR_NOTSUPP;
  72. }
  73. url_fskip(pb, header_size);
  74. st = av_new_stream(s, 0);
  75. if (!st)
  76. return AVERROR_NOMEM;
  77. st->codec->codec_type = CODEC_TYPE_AUDIO;
  78. voc->remaining_size = 0;
  79. return 0;
  80. }
  81. static int voc_get_bps(int codec_id)
  82. {
  83. switch (codec_id) {
  84. case CODEC_ID_PCM_S16LE:
  85. return 16;
  86. case CODEC_ID_ADPCM_CT:
  87. return 4;
  88. default:
  89. return 8;
  90. }
  91. }
  92. int
  93. voc_get_packet(AVFormatContext *s, AVPacket *pkt, AVStream *st, int max_size)
  94. {
  95. voc_dec_context_t *voc = s->priv_data;
  96. AVCodecContext *dec = st->codec;
  97. ByteIOContext *pb = &s->pb;
  98. voc_type_t type;
  99. int size;
  100. int sample_rate = 0;
  101. int channels = 1;
  102. while (!voc->remaining_size) {
  103. type = get_byte(pb);
  104. if (type == VOC_TYPE_EOF)
  105. return AVERROR_IO;
  106. voc->remaining_size = get_le24(pb);
  107. max_size -= 4;
  108. switch (type) {
  109. case VOC_TYPE_VOICE_DATA:
  110. dec->sample_rate = 1000000 / (256 - get_byte(pb));
  111. if (sample_rate)
  112. dec->sample_rate = sample_rate;
  113. dec->channels = channels;
  114. dec->codec_id = codec_get_id(voc_codec_tags, get_byte(pb));
  115. dec->bits_per_sample = voc_get_bps(dec->codec_id);
  116. voc->remaining_size -= 2;
  117. max_size -= 2;
  118. channels = 1;
  119. break;
  120. case VOC_TYPE_VOICE_DATA_CONT:
  121. break;
  122. case VOC_TYPE_EXTENDED:
  123. sample_rate = get_le16(pb);
  124. get_byte(pb);
  125. channels = get_byte(pb) + 1;
  126. sample_rate = 256000000 / (channels * (65536 - sample_rate));
  127. voc->remaining_size = 0;
  128. max_size -= 4;
  129. break;
  130. case VOC_TYPE_NEW_VOICE_DATA:
  131. dec->sample_rate = get_le32(pb);
  132. dec->bits_per_sample = get_byte(pb);
  133. dec->channels = get_byte(pb);
  134. dec->codec_id = codec_get_id(voc_codec_tags, get_le16(pb));
  135. url_fskip(pb, 4);
  136. voc->remaining_size -= 12;
  137. max_size -= 12;
  138. break;
  139. default:
  140. url_fskip(pb, voc->remaining_size);
  141. max_size -= voc->remaining_size;
  142. voc->remaining_size = 0;
  143. break;
  144. }
  145. }
  146. dec->bit_rate = dec->sample_rate * dec->bits_per_sample;
  147. if (max_size <= 0)
  148. max_size = voc_max_pkt_size;
  149. size = FFMIN(voc->remaining_size, max_size);
  150. voc->remaining_size -= size;
  151. return av_get_packet(pb, pkt, size);
  152. }
  153. static int voc_read_packet(AVFormatContext *s, AVPacket *pkt)
  154. {
  155. return voc_get_packet(s, pkt, s->streams[0], 0);
  156. }
  157. static int voc_read_close(AVFormatContext *s)
  158. {
  159. return 0;
  160. }
  161. static AVInputFormat voc_iformat = {
  162. "voc",
  163. "Creative Voice File format",
  164. sizeof(voc_dec_context_t),
  165. voc_probe,
  166. voc_read_header,
  167. voc_read_packet,
  168. voc_read_close,
  169. };
  170. #endif /* CONFIG_DEMUXERS */
  171. #ifdef CONFIG_MUXERS
  172. typedef struct voc_enc_context {
  173. int param_written;
  174. } voc_enc_context_t;
  175. static int voc_write_header(AVFormatContext *s)
  176. {
  177. ByteIOContext *pb = &s->pb;
  178. const int header_size = 26;
  179. const int version = 0x0114;
  180. if (s->nb_streams != 1
  181. || s->streams[0]->codec->codec_type != CODEC_TYPE_AUDIO)
  182. return AVERROR_NOTSUPP;
  183. put_buffer(pb, voc_magic, sizeof(voc_magic) - 1);
  184. put_le16(pb, header_size);
  185. put_le16(pb, version);
  186. put_le16(pb, ~version + 0x1234);
  187. return 0;
  188. }
  189. static int voc_write_packet(AVFormatContext *s, AVPacket *pkt)
  190. {
  191. voc_enc_context_t *voc = s->priv_data;
  192. AVCodecContext *enc = s->streams[0]->codec;
  193. ByteIOContext *pb = &s->pb;
  194. if (!voc->param_written) {
  195. int format = codec_get_tag(voc_codec_tags, enc->codec_id);
  196. if (format > 0xFF) {
  197. put_byte(pb, VOC_TYPE_NEW_VOICE_DATA);
  198. put_le24(pb, pkt->size + 12);
  199. put_le32(pb, enc->sample_rate);
  200. put_byte(pb, enc->bits_per_sample);
  201. put_byte(pb, enc->channels);
  202. put_le16(pb, format);
  203. put_le32(pb, 0);
  204. } else {
  205. if (s->streams[0]->codec->channels > 1) {
  206. put_byte(pb, VOC_TYPE_EXTENDED);
  207. put_le24(pb, 4);
  208. put_le16(pb, 65536-256000000/(enc->sample_rate*enc->channels));
  209. put_byte(pb, format);
  210. put_byte(pb, enc->channels - 1);
  211. }
  212. put_byte(pb, VOC_TYPE_VOICE_DATA);
  213. put_le24(pb, pkt->size + 2);
  214. put_byte(pb, 256 - 1000000 / enc->sample_rate);
  215. put_byte(pb, format);
  216. }
  217. voc->param_written = 1;
  218. } else {
  219. put_byte(pb, VOC_TYPE_VOICE_DATA_CONT);
  220. put_le24(pb, pkt->size);
  221. }
  222. put_buffer(pb, pkt->data, pkt->size);
  223. return 0;
  224. }
  225. static int voc_write_trailer(AVFormatContext *s)
  226. {
  227. put_byte(&s->pb, 0);
  228. return 0;
  229. }
  230. static AVOutputFormat voc_oformat = {
  231. "voc",
  232. "Creative Voice File format",
  233. "audio/x-voc",
  234. "voc",
  235. sizeof(voc_enc_context_t),
  236. CODEC_ID_PCM_U8,
  237. CODEC_ID_NONE,
  238. voc_write_header,
  239. voc_write_packet,
  240. voc_write_trailer,
  241. };
  242. #endif /* CONFIG_MUXERS */
  243. int voc_init(void)
  244. {
  245. #ifdef CONFIG_DEMUXERS
  246. av_register_input_format(&voc_iformat);
  247. #endif /* CONFIG_DEMUXERS */
  248. #ifdef CONFIG_MUXERS
  249. av_register_output_format(&voc_oformat);
  250. #endif /* CONFIG_MUXERS */
  251. return 0;
  252. }