Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * AAC encoder wrapper
  3.  * Copyright (c) 2012 Martin Storsjo
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * Permission to use, copy, modify, and/or distribute this software for any
  8.  * purpose with or without fee is hereby granted, provided that the above
  9.  * copyright notice and this permission notice appear in all copies.
  10.  *
  11.  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12.  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13.  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14.  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16.  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17.  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18.  */
  19.  
  20. #include <fdk-aac/aacenc_lib.h>
  21.  
  22. #include "libavutil/channel_layout.h"
  23. #include "libavutil/common.h"
  24. #include "libavutil/opt.h"
  25. #include "avcodec.h"
  26. #include "audio_frame_queue.h"
  27. #include "internal.h"
  28.  
  29. typedef struct AACContext {
  30.     const AVClass *class;
  31.     HANDLE_AACENCODER handle;
  32.     int afterburner;
  33.     int eld_sbr;
  34.     int signaling;
  35.     int latm;
  36.     int header_period;
  37.     int vbr;
  38.  
  39.     AudioFrameQueue afq;
  40. } AACContext;
  41.  
  42. static const AVOption aac_enc_options[] = {
  43.     { "afterburner", "Afterburner (improved quality)", offsetof(AACContext, afterburner), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
  44.     { "eld_sbr", "Enable SBR for ELD (for SBR in other configurations, use the -profile parameter)", offsetof(AACContext, eld_sbr), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
  45.     { "signaling", "SBR/PS signaling style", offsetof(AACContext, signaling), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 2, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
  46.     { "default", "Choose signaling implicitly (explicit hierarchical by default, implicit if global header is disabled)", 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
  47.     { "implicit", "Implicit backwards compatible signaling", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
  48.     { "explicit_sbr", "Explicit SBR, implicit PS signaling", 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
  49.     { "explicit_hierarchical", "Explicit hierarchical signaling", 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "signaling" },
  50.     { "latm", "Output LATM/LOAS encapsulated data", offsetof(AACContext, latm), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
  51.     { "header_period", "StreamMuxConfig and PCE repetition period (in frames)", offsetof(AACContext, header_period), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 0xffff, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
  52.     { "vbr", "VBR mode (1-5)", offsetof(AACContext, vbr), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 5, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
  53.     { NULL }
  54. };
  55.  
  56. static const AVClass aac_enc_class = {
  57.     "libfdk_aac", av_default_item_name, aac_enc_options, LIBAVUTIL_VERSION_INT
  58. };
  59.  
  60. static const char *aac_get_error(AACENC_ERROR err)
  61. {
  62.     switch (err) {
  63.     case AACENC_OK:
  64.         return "No error";
  65.     case AACENC_INVALID_HANDLE:
  66.         return "Invalid handle";
  67.     case AACENC_MEMORY_ERROR:
  68.         return "Memory allocation error";
  69.     case AACENC_UNSUPPORTED_PARAMETER:
  70.         return "Unsupported parameter";
  71.     case AACENC_INVALID_CONFIG:
  72.         return "Invalid config";
  73.     case AACENC_INIT_ERROR:
  74.         return "Initialization error";
  75.     case AACENC_INIT_AAC_ERROR:
  76.         return "AAC library initialization error";
  77.     case AACENC_INIT_SBR_ERROR:
  78.         return "SBR library initialization error";
  79.     case AACENC_INIT_TP_ERROR:
  80.         return "Transport library initialization error";
  81.     case AACENC_INIT_META_ERROR:
  82.         return "Metadata library initialization error";
  83.     case AACENC_ENCODE_ERROR:
  84.         return "Encoding error";
  85.     case AACENC_ENCODE_EOF:
  86.         return "End of file";
  87.     default:
  88.         return "Unknown error";
  89.     }
  90. }
  91.  
  92. static int aac_encode_close(AVCodecContext *avctx)
  93. {
  94.     AACContext *s = avctx->priv_data;
  95.  
  96.     if (s->handle)
  97.         aacEncClose(&s->handle);
  98.     av_freep(&avctx->extradata);
  99.     ff_af_queue_close(&s->afq);
  100.  
  101.     return 0;
  102. }
  103.  
  104. static av_cold int aac_encode_init(AVCodecContext *avctx)
  105. {
  106.     AACContext *s = avctx->priv_data;
  107.     int ret = AVERROR(EINVAL);
  108.     AACENC_InfoStruct info = { 0 };
  109.     CHANNEL_MODE mode;
  110.     AACENC_ERROR err;
  111.     int aot = FF_PROFILE_AAC_LOW + 1;
  112.     int sce = 0, cpe = 0;
  113.  
  114.     if ((err = aacEncOpen(&s->handle, 0, avctx->channels)) != AACENC_OK) {
  115.         av_log(avctx, AV_LOG_ERROR, "Unable to open the encoder: %s\n",
  116.                aac_get_error(err));
  117.         goto error;
  118.     }
  119.  
  120.     if (avctx->profile != FF_PROFILE_UNKNOWN)
  121.         aot = avctx->profile + 1;
  122.  
  123.     if ((err = aacEncoder_SetParam(s->handle, AACENC_AOT, aot)) != AACENC_OK) {
  124.         av_log(avctx, AV_LOG_ERROR, "Unable to set the AOT %d: %s\n",
  125.                aot, aac_get_error(err));
  126.         goto error;
  127.     }
  128.  
  129.     if (aot == FF_PROFILE_AAC_ELD + 1 && s->eld_sbr) {
  130.         if ((err = aacEncoder_SetParam(s->handle, AACENC_SBR_MODE,
  131.                                        1)) != AACENC_OK) {
  132.             av_log(avctx, AV_LOG_ERROR, "Unable to enable SBR for ELD: %s\n",
  133.                    aac_get_error(err));
  134.             goto error;
  135.         }
  136.     }
  137.  
  138.     if ((err = aacEncoder_SetParam(s->handle, AACENC_SAMPLERATE,
  139.                                    avctx->sample_rate)) != AACENC_OK) {
  140.         av_log(avctx, AV_LOG_ERROR, "Unable to set the sample rate %d: %s\n",
  141.                avctx->sample_rate, aac_get_error(err));
  142.         goto error;
  143.     }
  144.  
  145.     switch (avctx->channels) {
  146.     case 1: mode = MODE_1;       sce = 1; cpe = 0; break;
  147.     case 2: mode = MODE_2;       sce = 0; cpe = 1; break;
  148.     case 3: mode = MODE_1_2;     sce = 1; cpe = 1; break;
  149.     case 4: mode = MODE_1_2_1;   sce = 2; cpe = 1; break;
  150.     case 5: mode = MODE_1_2_2;   sce = 1; cpe = 2; break;
  151.     case 6: mode = MODE_1_2_2_1; sce = 2; cpe = 2; break;
  152. /* The version macro is introduced the same time as the 7.1 support, so this
  153.    should suffice. */
  154. #ifdef AACENCODER_LIB_VL0
  155.     case 8:
  156.         sce = 2;
  157.         cpe = 3;
  158.         if (avctx->channel_layout == AV_CH_LAYOUT_7POINT1) {
  159.             mode = MODE_7_1_REAR_SURROUND;
  160.         } else {
  161.             // MODE_1_2_2_2_1 and MODE_7_1_FRONT_CENTER use the same channel layout
  162.             mode = MODE_7_1_FRONT_CENTER;
  163.         }
  164.         break;
  165. #endif
  166.     default:
  167.         av_log(avctx, AV_LOG_ERROR,
  168.                "Unsupported number of channels %d\n", avctx->channels);
  169.         goto error;
  170.     }
  171.  
  172.     if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
  173.                                    mode)) != AACENC_OK) {
  174.         av_log(avctx, AV_LOG_ERROR,
  175.                "Unable to set channel mode %d: %s\n", mode, aac_get_error(err));
  176.         goto error;
  177.     }
  178.  
  179.     if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELORDER,
  180.                                    1)) != AACENC_OK) {
  181.         av_log(avctx, AV_LOG_ERROR,
  182.                "Unable to set wav channel order %d: %s\n",
  183.                mode, aac_get_error(err));
  184.         goto error;
  185.     }
  186.  
  187.     if (avctx->flags & AV_CODEC_FLAG_QSCALE || s->vbr) {
  188.         int mode = s->vbr ? s->vbr : avctx->global_quality;
  189.         if (mode <  1 || mode > 5) {
  190.             av_log(avctx, AV_LOG_WARNING,
  191.                    "VBR quality %d out of range, should be 1-5\n", mode);
  192.             mode = av_clip(mode, 1, 5);
  193.         }
  194.         av_log(avctx, AV_LOG_WARNING,
  195.                "Note, the VBR setting is unsupported and only works with "
  196.                "some parameter combinations\n");
  197.         if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATEMODE,
  198.                                        mode)) != AACENC_OK) {
  199.             av_log(avctx, AV_LOG_ERROR, "Unable to set the VBR bitrate mode %d: %s\n",
  200.                    mode, aac_get_error(err));
  201.             goto error;
  202.         }
  203.     } else {
  204.         if (avctx->bit_rate <= 0) {
  205.             if (avctx->profile == FF_PROFILE_AAC_HE_V2) {
  206.                 sce = 1;
  207.                 cpe = 0;
  208.             }
  209.             avctx->bit_rate = (96*sce + 128*cpe) * avctx->sample_rate / 44;
  210.             if (avctx->profile == FF_PROFILE_AAC_HE ||
  211.                 avctx->profile == FF_PROFILE_AAC_HE_V2 ||
  212.                 avctx->profile == FF_PROFILE_MPEG2_AAC_HE ||
  213.                 s->eld_sbr)
  214.                 avctx->bit_rate /= 2;
  215.         }
  216.         if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATE,
  217.                                        avctx->bit_rate)) != AACENC_OK) {
  218.             av_log(avctx, AV_LOG_ERROR, "Unable to set the bitrate %d: %s\n",
  219.                    avctx->bit_rate, aac_get_error(err));
  220.             goto error;
  221.         }
  222.     }
  223.  
  224.     /* Choose bitstream format - if global header is requested, use
  225.      * raw access units, otherwise use ADTS. */
  226.     if ((err = aacEncoder_SetParam(s->handle, AACENC_TRANSMUX,
  227.                                    avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? 0 : s->latm ? 10 : 2)) != AACENC_OK) {
  228.         av_log(avctx, AV_LOG_ERROR, "Unable to set the transmux format: %s\n",
  229.                aac_get_error(err));
  230.         goto error;
  231.     }
  232.  
  233.     if (s->latm && s->header_period) {
  234.         if ((err = aacEncoder_SetParam(s->handle, AACENC_HEADER_PERIOD,
  235.                                        s->header_period)) != AACENC_OK) {
  236.              av_log(avctx, AV_LOG_ERROR, "Unable to set header period: %s\n",
  237.                     aac_get_error(err));
  238.              goto error;
  239.         }
  240.     }
  241.  
  242.     /* If no signaling mode is chosen, use explicit hierarchical signaling
  243.      * if using mp4 mode (raw access units, with global header) and
  244.      * implicit signaling if using ADTS. */
  245.     if (s->signaling < 0)
  246.         s->signaling = avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? 2 : 0;
  247.  
  248.     if ((err = aacEncoder_SetParam(s->handle, AACENC_SIGNALING_MODE,
  249.                                    s->signaling)) != AACENC_OK) {
  250.         av_log(avctx, AV_LOG_ERROR, "Unable to set signaling mode %d: %s\n",
  251.                s->signaling, aac_get_error(err));
  252.         goto error;
  253.     }
  254.  
  255.     if ((err = aacEncoder_SetParam(s->handle, AACENC_AFTERBURNER,
  256.                                    s->afterburner)) != AACENC_OK) {
  257.         av_log(avctx, AV_LOG_ERROR, "Unable to set afterburner to %d: %s\n",
  258.                s->afterburner, aac_get_error(err));
  259.         goto error;
  260.     }
  261.  
  262.     if (avctx->cutoff > 0) {
  263.         if (avctx->cutoff < (avctx->sample_rate + 255) >> 8 || avctx->cutoff > 20000) {
  264.             av_log(avctx, AV_LOG_ERROR, "cutoff valid range is %d-20000\n",
  265.                    (avctx->sample_rate + 255) >> 8);
  266.             goto error;
  267.         }
  268.         if ((err = aacEncoder_SetParam(s->handle, AACENC_BANDWIDTH,
  269.                                        avctx->cutoff)) != AACENC_OK) {
  270.             av_log(avctx, AV_LOG_ERROR, "Unable to set the encoder bandwidth to %d: %s\n",
  271.                    avctx->cutoff, aac_get_error(err));
  272.             goto error;
  273.         }
  274.     }
  275.  
  276.     if ((err = aacEncEncode(s->handle, NULL, NULL, NULL, NULL)) != AACENC_OK) {
  277.         av_log(avctx, AV_LOG_ERROR, "Unable to initialize the encoder: %s\n",
  278.                aac_get_error(err));
  279.         return AVERROR(EINVAL);
  280.     }
  281.  
  282.     if ((err = aacEncInfo(s->handle, &info)) != AACENC_OK) {
  283.         av_log(avctx, AV_LOG_ERROR, "Unable to get encoder info: %s\n",
  284.                aac_get_error(err));
  285.         goto error;
  286.     }
  287.  
  288.     avctx->frame_size = info.frameLength;
  289.     avctx->initial_padding = info.encoderDelay;
  290.     ff_af_queue_init(avctx, &s->afq);
  291.  
  292.     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
  293.         avctx->extradata_size = info.confSize;
  294.         avctx->extradata      = av_mallocz(avctx->extradata_size +
  295.                                            AV_INPUT_BUFFER_PADDING_SIZE);
  296.         if (!avctx->extradata) {
  297.             ret = AVERROR(ENOMEM);
  298.             goto error;
  299.         }
  300.  
  301.         memcpy(avctx->extradata, info.confBuf, info.confSize);
  302.     }
  303.     return 0;
  304. error:
  305.     aac_encode_close(avctx);
  306.     return ret;
  307. }
  308.  
  309. static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
  310.                             const AVFrame *frame, int *got_packet_ptr)
  311. {
  312.     AACContext    *s        = avctx->priv_data;
  313.     AACENC_BufDesc in_buf   = { 0 }, out_buf = { 0 };
  314.     AACENC_InArgs  in_args  = { 0 };
  315.     AACENC_OutArgs out_args = { 0 };
  316.     int in_buffer_identifier = IN_AUDIO_DATA;
  317.     int in_buffer_size, in_buffer_element_size;
  318.     int out_buffer_identifier = OUT_BITSTREAM_DATA;
  319.     int out_buffer_size, out_buffer_element_size;
  320.     void *in_ptr, *out_ptr;
  321.     int ret;
  322.     AACENC_ERROR err;
  323.  
  324.     /* handle end-of-stream small frame and flushing */
  325.     if (!frame) {
  326.         in_args.numInSamples = -1;
  327.     } else {
  328.         in_ptr                   = frame->data[0];
  329.         in_buffer_size           = 2 * avctx->channels * frame->nb_samples;
  330.         in_buffer_element_size   = 2;
  331.  
  332.         in_args.numInSamples     = avctx->channels * frame->nb_samples;
  333.         in_buf.numBufs           = 1;
  334.         in_buf.bufs              = &in_ptr;
  335.         in_buf.bufferIdentifiers = &in_buffer_identifier;
  336.         in_buf.bufSizes          = &in_buffer_size;
  337.         in_buf.bufElSizes        = &in_buffer_element_size;
  338.  
  339.         /* add current frame to the queue */
  340.         if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
  341.             return ret;
  342.     }
  343.  
  344.     /* The maximum packet size is 6144 bits aka 768 bytes per channel. */
  345.     if ((ret = ff_alloc_packet2(avctx, avpkt, FFMAX(8192, 768 * avctx->channels), 0)) < 0)
  346.         return ret;
  347.  
  348.     out_ptr                   = avpkt->data;
  349.     out_buffer_size           = avpkt->size;
  350.     out_buffer_element_size   = 1;
  351.     out_buf.numBufs           = 1;
  352.     out_buf.bufs              = &out_ptr;
  353.     out_buf.bufferIdentifiers = &out_buffer_identifier;
  354.     out_buf.bufSizes          = &out_buffer_size;
  355.     out_buf.bufElSizes        = &out_buffer_element_size;
  356.  
  357.     if ((err = aacEncEncode(s->handle, &in_buf, &out_buf, &in_args,
  358.                             &out_args)) != AACENC_OK) {
  359.         if (!frame && err == AACENC_ENCODE_EOF)
  360.             return 0;
  361.         av_log(avctx, AV_LOG_ERROR, "Unable to encode frame: %s\n",
  362.                aac_get_error(err));
  363.         return AVERROR(EINVAL);
  364.     }
  365.  
  366.     if (!out_args.numOutBytes)
  367.         return 0;
  368.  
  369.     /* Get the next frame pts & duration */
  370.     ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
  371.                        &avpkt->duration);
  372.  
  373.     avpkt->size     = out_args.numOutBytes;
  374.     *got_packet_ptr = 1;
  375.     return 0;
  376. }
  377.  
  378. static const AVProfile profiles[] = {
  379.     { FF_PROFILE_AAC_LOW,   "LC"       },
  380.     { FF_PROFILE_AAC_HE,    "HE-AAC"   },
  381.     { FF_PROFILE_AAC_HE_V2, "HE-AACv2" },
  382.     { FF_PROFILE_AAC_LD,    "LD"       },
  383.     { FF_PROFILE_AAC_ELD,   "ELD"      },
  384.     { FF_PROFILE_UNKNOWN },
  385. };
  386.  
  387. static const AVCodecDefault aac_encode_defaults[] = {
  388.     { "b", "0" },
  389.     { NULL }
  390. };
  391.  
  392. static const uint64_t aac_channel_layout[] = {
  393.     AV_CH_LAYOUT_MONO,
  394.     AV_CH_LAYOUT_STEREO,
  395.     AV_CH_LAYOUT_SURROUND,
  396.     AV_CH_LAYOUT_4POINT0,
  397.     AV_CH_LAYOUT_5POINT0_BACK,
  398.     AV_CH_LAYOUT_5POINT1_BACK,
  399. #ifdef AACENCODER_LIB_VL0
  400.     AV_CH_LAYOUT_7POINT1_WIDE_BACK,
  401.     AV_CH_LAYOUT_7POINT1,
  402. #endif
  403.     0,
  404. };
  405.  
  406. static const int aac_sample_rates[] = {
  407.     96000, 88200, 64000, 48000, 44100, 32000,
  408.     24000, 22050, 16000, 12000, 11025, 8000, 0
  409. };
  410.  
  411. AVCodec ff_libfdk_aac_encoder = {
  412.     .name                  = "libfdk_aac",
  413.     .long_name             = NULL_IF_CONFIG_SMALL("Fraunhofer FDK AAC"),
  414.     .type                  = AVMEDIA_TYPE_AUDIO,
  415.     .id                    = AV_CODEC_ID_AAC,
  416.     .priv_data_size        = sizeof(AACContext),
  417.     .init                  = aac_encode_init,
  418.     .encode2               = aac_encode_frame,
  419.     .close                 = aac_encode_close,
  420.     .capabilities          = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY,
  421.     .sample_fmts           = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
  422.                                                             AV_SAMPLE_FMT_NONE },
  423.     .priv_class            = &aac_enc_class,
  424.     .defaults              = aac_encode_defaults,
  425.     .profiles              = profiles,
  426.     .supported_samplerates = aac_sample_rates,
  427.     .channel_layouts       = aac_channel_layout,
  428. };
  429.