encode_audio.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  1. /*
  2. * Copyright (c) 2001 Fabrice Bellard
  3. *
  4. * Permission is hereby granted, free of charge, to any person obtaining a copy
  5. * of this software and associated documentation files (the "Software"), to deal
  6. * in the Software without restriction, including without limitation the rights
  7. * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  8. * copies of the Software, and to permit persons to whom the Software is
  9. * furnished to do so, subject to the following conditions:
  10. *
  11. * The above copyright notice and this permission notice shall be included in
  12. * all copies or substantial portions of the Software.
  13. *
  14. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17. * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19. * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20. * THE SOFTWARE.
  21. */
  22. /**
  23. * @file
  24. * audio encoding with libavcodec API example.
  25. *
  26. * @example encode_audio.c
  27. */
  28. #include <stdint.h>
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31. #include <libavcodec/avcodec.h>
  32. #include <libavutil/channel_layout.h>
  33. #include <libavutil/common.h>
  34. #include <libavutil/frame.h>
  35. #include <libavutil/samplefmt.h>
  36. /* check that a given sample format is supported by the encoder */
  37. static int check_sample_fmt(const AVCodec *codec, enum AVSampleFormat sample_fmt)
  38. {
  39. const enum AVSampleFormat *p = codec->sample_fmts;
  40. while (*p != AV_SAMPLE_FMT_NONE) {
  41. if (*p == sample_fmt)
  42. return 1;
  43. p++;
  44. }
  45. return 0;
  46. }
  47. /* just pick the highest supported samplerate */
  48. static int select_sample_rate(const AVCodec *codec)
  49. {
  50. const int *p;
  51. int best_samplerate = 0;
  52. if (!codec->supported_samplerates)
  53. return 44100;
  54. p = codec->supported_samplerates;
  55. while (*p) {
  56. if (!best_samplerate || abs(44100 - *p) < abs(44100 - best_samplerate))
  57. best_samplerate = *p;
  58. p++;
  59. }
  60. return best_samplerate;
  61. }
  62. /* select layout with the highest channel count */
  63. static int select_channel_layout(const AVCodec *codec, AVChannelLayout *dst)
  64. {
  65. const AVChannelLayout *p, *best_ch_layout;
  66. int best_nb_channels = 0;
  67. if (!codec->ch_layouts)
  68. return av_channel_layout_copy(dst, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO);
  69. p = codec->ch_layouts;
  70. while (p->nb_channels) {
  71. int nb_channels = p->nb_channels;
  72. if (nb_channels > best_nb_channels) {
  73. best_ch_layout = p;
  74. best_nb_channels = nb_channels;
  75. }
  76. p++;
  77. }
  78. return av_channel_layout_copy(dst, best_ch_layout);
  79. }
  80. static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt,
  81. FILE *output)
  82. {
  83. int ret;
  84. /* send the frame for encoding */
  85. ret = avcodec_send_frame(ctx, frame);
  86. if (ret < 0) {
  87. fprintf(stderr, "Error sending the frame to the encoder\n");
  88. exit(1);
  89. }
  90. /* read all the available output packets (in general there may be any
  91. * number of them */
  92. while (ret >= 0) {
  93. ret = avcodec_receive_packet(ctx, pkt);
  94. if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
  95. return;
  96. else if (ret < 0) {
  97. fprintf(stderr, "Error encoding audio frame\n");
  98. exit(1);
  99. }
  100. fwrite(pkt->data, 1, pkt->size, output);
  101. av_packet_unref(pkt);
  102. }
  103. }
  104. int main(int argc, char **argv)
  105. {
  106. const char *filename;
  107. const AVCodec *codec;
  108. AVCodecContext *c= NULL;
  109. AVFrame *frame;
  110. AVPacket *pkt;
  111. int i, j, k, ret;
  112. FILE *f;
  113. uint16_t *samples;
  114. float t, tincr;
  115. if (argc <= 1) {
  116. fprintf(stderr, "Usage: %s <output file>\n", argv[0]);
  117. return 0;
  118. }
  119. filename = argv[1];
  120. /* find the MP2 encoder */
  121. codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
  122. if (!codec) {
  123. fprintf(stderr, "Codec not found\n");
  124. exit(1);
  125. }
  126. c = avcodec_alloc_context3(codec);
  127. if (!c) {
  128. fprintf(stderr, "Could not allocate audio codec context\n");
  129. exit(1);
  130. }
  131. /* put sample parameters */
  132. c->bit_rate = 64000;
  133. /* check that the encoder supports s16 pcm input */
  134. c->sample_fmt = AV_SAMPLE_FMT_S16;
  135. if (!check_sample_fmt(codec, c->sample_fmt)) {
  136. fprintf(stderr, "Encoder does not support sample format %s",
  137. av_get_sample_fmt_name(c->sample_fmt));
  138. exit(1);
  139. }
  140. /* select other audio parameters supported by the encoder */
  141. c->sample_rate = select_sample_rate(codec);
  142. ret = select_channel_layout(codec, &c->ch_layout);
  143. if (ret < 0)
  144. exit(1);
  145. /* open it */
  146. if (avcodec_open2(c, codec, NULL) < 0) {
  147. fprintf(stderr, "Could not open codec\n");
  148. exit(1);
  149. }
  150. f = fopen(filename, "wb");
  151. if (!f) {
  152. fprintf(stderr, "Could not open %s\n", filename);
  153. exit(1);
  154. }
  155. /* packet for holding encoded output */
  156. pkt = av_packet_alloc();
  157. if (!pkt) {
  158. fprintf(stderr, "could not allocate the packet\n");
  159. exit(1);
  160. }
  161. /* frame containing input raw audio */
  162. frame = av_frame_alloc();
  163. if (!frame) {
  164. fprintf(stderr, "Could not allocate audio frame\n");
  165. exit(1);
  166. }
  167. frame->nb_samples = c->frame_size;
  168. frame->format = c->sample_fmt;
  169. ret = av_channel_layout_copy(&frame->ch_layout, &c->ch_layout);
  170. if (ret < 0)
  171. exit(1);
  172. /* allocate the data buffers */
  173. ret = av_frame_get_buffer(frame, 0);
  174. if (ret < 0) {
  175. fprintf(stderr, "Could not allocate audio data buffers\n");
  176. exit(1);
  177. }
  178. /* encode a single tone sound */
  179. t = 0;
  180. tincr = 2 * M_PI * 440.0 / c->sample_rate;
  181. for (i = 0; i < 200; i++) {
  182. /* make sure the frame is writable -- makes a copy if the encoder
  183. * kept a reference internally */
  184. ret = av_frame_make_writable(frame);
  185. if (ret < 0)
  186. exit(1);
  187. samples = (uint16_t*)frame->data[0];
  188. for (j = 0; j < c->frame_size; j++) {
  189. samples[2*j] = (int)(sin(t) * 10000);
  190. for (k = 1; k < c->ch_layout.nb_channels; k++)
  191. samples[2*j + k] = samples[2*j];
  192. t += tincr;
  193. }
  194. encode(c, frame, pkt, f);
  195. }
  196. /* flush the encoder */
  197. encode(c, NULL, pkt, f);
  198. fclose(f);
  199. av_frame_free(&frame);
  200. av_packet_free(&pkt);
  201. avcodec_free_context(&c);
  202. return 0;
  203. }