FFmpeg: libavcodec/libfdk-aacenc.c Source File

FFmpeg
libfdk-aacenc.c
Go to the documentation of this file.
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/intreadwrite.h"
25 #include "libavutil/mem.h"
26 #include "libavutil/opt.h"
27 #include "avcodec.h"
28 #include "audio_frame_queue.h"
29 #include "codec_internal.h"
30 #include "encode.h"
31 #include "profiles.h"
32 
33 #ifdef AACENCODER_LIB_VL0
34 #define FDKENC_VER_AT_LEAST(vl0, vl1) \
35  ((AACENCODER_LIB_VL0 > vl0) || \
36  (AACENCODER_LIB_VL0 == vl0 && AACENCODER_LIB_VL1 >= vl1))
37 #else
38  #define FDKENC_VER_AT_LEAST(vl0, vl1) 0
39 #endif
40 
41  typedef struct AACContext {
42   const AVClass *class;
43   HANDLE_AACENCODER handle;
44   int afterburner;
45   int eld_sbr;
46   int eld_v2;
47   int signaling;
48   int latm;
49   int header_period;
50   int vbr;
51   int drc_profile;
52   int drc_target_ref;
53   int comp_profile;
54   int comp_target_ref;
55   int prog_ref;
56   int metadata_mode;
57   AACENC_MetaData metaDataSetup;
58   int delay_sent;
59   int frame_length;
60 
61   AudioFrameQueue afq;
62 } AACContext;
63 
64  static const AVOption aac_enc_options[] = {
65  { "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 },
66  { "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 },
67 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
68  { "eld_v2", "Enable ELDv2 (LD-MPS extension for ELD stereo signals)", offsetof(AACContext, eld_v2), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
69 #endif
70  { "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, .unit = "signaling" },
71  { "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, .unit = "signaling" },
72  { "implicit", "Implicit backwards compatible signaling", 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, .unit = "signaling" },
73  { "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, .unit = "signaling" },
74  { "explicit_hierarchical", "Explicit hierarchical signaling", 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, 0, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, .unit = "signaling" },
75  { "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 },
76  { "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 },
77  { "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 },
78  { "drc_profile", "The desired compression profile for AAC DRC", offsetof(AACContext, drc_profile), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 256, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
79  { "drc_target_ref", "Expected target reference level at decoder side in dB (for clipping prevention/limiter)", offsetof(AACContext, drc_target_ref), AV_OPT_TYPE_INT, { .i64 = 0.0 }, -31.75, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
80  { "comp_profile", "The desired compression profile for AAC DRC", offsetof(AACContext, comp_profile), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 256, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
81  { "comp_target_ref", "Expected target reference level at decoder side in dB (for clipping prevention/limiter)", offsetof(AACContext, comp_target_ref), AV_OPT_TYPE_INT, { .i64 = 0.0 }, -31.75, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
82  { "prog_ref", "The program reference level or dialog level in dB", offsetof(AACContext, prog_ref), AV_OPT_TYPE_INT, { .i64 = 0.0 }, -31.75, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
83  { "frame_length", "The desired frame length", offsetof(AACContext, frame_length), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1024, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
84  FF_AAC_PROFILE_OPTS
85  { NULL }
86 };
87 
88  static const AVClass aac_enc_class = {
89  .class_name = "libfdk_aac",
90  .item_name = av_default_item_name,
91  .option = aac_enc_options,
92  .version = LIBAVUTIL_VERSION_INT,
93 };
94 
95  static const char *aac_get_error(AACENC_ERROR err)
96 {
97  switch (err) {
98  case AACENC_OK:
99  return "No error";
100  case AACENC_INVALID_HANDLE:
101  return "Invalid handle";
102  case AACENC_MEMORY_ERROR:
103  return "Memory allocation error";
104  case AACENC_UNSUPPORTED_PARAMETER:
105  return "Unsupported parameter";
106  case AACENC_INVALID_CONFIG:
107  return "Invalid config";
108  case AACENC_INIT_ERROR:
109  return "Initialization error";
110  case AACENC_INIT_AAC_ERROR:
111  return "AAC library initialization error";
112  case AACENC_INIT_SBR_ERROR:
113  return "SBR library initialization error";
114  case AACENC_INIT_TP_ERROR:
115  return "Transport library initialization error";
116  case AACENC_INIT_META_ERROR:
117  return "Metadata library initialization error";
118  case AACENC_ENCODE_ERROR:
119  return "Encoding error";
120  case AACENC_ENCODE_EOF:
121  return "End of file";
122  default:
123  return "Unknown error";
124  }
125 }
126 
127  static int aac_encode_close(AVCodecContext *avctx)
128 {
129  AACContext *s = avctx->priv_data;
130 
131  if (s->handle)
132  aacEncClose(&s->handle);
133  ff_af_queue_close(&s->afq);
134 
135  return 0;
136 }
137 
138  static void aac_encode_flush(AVCodecContext *avctx)
139 {
140  AACContext *s = avctx->priv_data;
141  AACENC_BufDesc in_buf = { 0 }, out_buf = { 0 };
142  AACENC_InArgs in_args = { 0 };
143  AACENC_OutArgs out_args;
144  int64_t pts, duration;
145  uint8_t dummy_in[1], dummy_out[1];
146  int in_buffer_identifiers[] = { IN_AUDIO_DATA, IN_METADATA_SETUP };
147  int in_buffer_element_sizes[] = { 2, sizeof(AACENC_MetaData) };
148  int in_buffer_sizes[] = { 0, sizeof(s->metaDataSetup) };
149  int out_buffer_identifier = OUT_BITSTREAM_DATA;
150  int out_buffer_size = sizeof(dummy_out), out_buffer_element_size = 1;
151  void* inBuffer[] = { dummy_in, &s->metaDataSetup };
152  void *out_ptr = dummy_out;
153  AACENC_ERROR err;
154 
155  ff_af_queue_remove(&s->afq, s->afq.frame_count, &pts, &duration);
156 
157  in_buf.bufs = (void **)inBuffer;
158  in_buf.numBufs = s->metadata_mode == 0 ? 1 : 2;
159  in_buf.bufferIdentifiers = in_buffer_identifiers;
160  in_buf.bufSizes = in_buffer_sizes;
161  in_buf.bufElSizes = in_buffer_element_sizes;
162 
163  out_buf.numBufs = 1;
164  out_buf.bufs = &out_ptr;
165  out_buf.bufferIdentifiers = &out_buffer_identifier;
166  out_buf.bufSizes = &out_buffer_size;
167  out_buf.bufElSizes = &out_buffer_element_size;
168 
169  err = aacEncEncode(s->handle, &in_buf, &out_buf, &in_args, &out_args);
170  if (err != AACENC_OK) {
171  av_log(avctx, AV_LOG_ERROR, "Unexpected error while flushing: %s\n",
172  aac_get_error(err));
173  }
174 }
175 
176  static av_cold int aac_encode_init(AVCodecContext *avctx)
177 {
178  AACContext *s = avctx->priv_data;
179  int ret = AVERROR(EINVAL);
180  AACENC_InfoStruct info = { 0 };
181  AVCPBProperties *cpb_props;
182  CHANNEL_MODE mode;
183  AACENC_ERROR err;
184  int aot = AV_PROFILE_AAC_LOW + 1;
185  int sce = 0, cpe = 0;
186 
187  if ((err = aacEncOpen(&s->handle, 0, avctx->ch_layout.nb_channels)) != AACENC_OK) {
188  av_log(avctx, AV_LOG_ERROR, "Unable to open the encoder: %s\n",
189  aac_get_error(err));
190  goto error;
191  }
192 
193  if (avctx->profile != AV_PROFILE_UNKNOWN)
194  aot = avctx->profile + 1;
195 
196  if ((err = aacEncoder_SetParam(s->handle, AACENC_AOT, aot)) != AACENC_OK) {
197  av_log(avctx, AV_LOG_ERROR, "Unable to set the AOT %d: %s\n",
198  aot, aac_get_error(err));
199  goto error;
200  }
201 
202  if (aot == AV_PROFILE_AAC_ELD + 1 && s->eld_sbr) {
203  if ((err = aacEncoder_SetParam(s->handle, AACENC_SBR_MODE,
204  1)) != AACENC_OK) {
205  av_log(avctx, AV_LOG_ERROR, "Unable to enable SBR for ELD: %s\n",
206  aac_get_error(err));
207  goto error;
208  }
209  }
210 
211  if (s->frame_length >= 0) {
212  if ((err = aacEncoder_SetParam(s->handle, AACENC_GRANULE_LENGTH,
213  s->frame_length)) != AACENC_OK) {
214  av_log(avctx, AV_LOG_ERROR, "Unable to set granule length: %s\n",
215  aac_get_error(err));
216  goto error;
217  }
218  }
219 
220  if ((err = aacEncoder_SetParam(s->handle, AACENC_SAMPLERATE,
221  avctx->sample_rate)) != AACENC_OK) {
222  av_log(avctx, AV_LOG_ERROR, "Unable to set the sample rate %d: %s\n",
223  avctx->sample_rate, aac_get_error(err));
224  goto error;
225  }
226 
227  switch (avctx->ch_layout.nb_channels) {
228  case 1: mode = MODE_1; sce = 1; cpe = 0; break;
229  case 2:
230 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
231  // (profile + 1) to map from profile range to AOT range
232  if (aot == AV_PROFILE_AAC_ELD + 1 && s->eld_v2) {
233  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
234  128)) != AACENC_OK) {
235  av_log(avctx, AV_LOG_ERROR, "Unable to enable ELDv2: %s\n",
236  aac_get_error(err));
237  goto error;
238  } else {
239  mode = MODE_212;
240  sce = 1;
241  cpe = 0;
242  }
243  } else
244 #endif
245  {
246  mode = MODE_2;
247  sce = 0;
248  cpe = 1;
249  }
250  break;
251  case 3: mode = MODE_1_2; sce = 1; cpe = 1; break;
252  case 4: mode = MODE_1_2_1; sce = 2; cpe = 1; break;
253  case 5: mode = MODE_1_2_2; sce = 1; cpe = 2; break;
254  case 6: mode = MODE_1_2_2_1; sce = 2; cpe = 2; break;
255 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
256  case 7: mode = MODE_6_1; sce = 3; cpe = 2; break;
257 #endif
258 /* The version macro is introduced the same time as the 7.1 support, so this
259  should suffice. */
260 #if FDKENC_VER_AT_LEAST(3, 4) // 3.4.12
261  case 8:
262  sce = 2;
263  cpe = 3;
264  if (!av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_7POINT1)) {
265  mode = MODE_7_1_REAR_SURROUND;
266 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
267  } else if (!av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK)) {
268  mode = MODE_7_1_TOP_FRONT;
269 #endif
270  } else {
271  // MODE_1_2_2_2_1 and MODE_7_1_FRONT_CENTER use the same channel layout
272  mode = MODE_7_1_FRONT_CENTER;
273  }
274  break;
275 #endif
276  default:
277  av_log(avctx, AV_LOG_ERROR,
278  "Unsupported number of channels %d\n", avctx->ch_layout.nb_channels);
279  goto error;
280  }
281 
282  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELMODE,
283  mode)) != AACENC_OK) {
284  av_log(avctx, AV_LOG_ERROR,
285  "Unable to set channel mode %d: %s\n", mode, aac_get_error(err));
286  goto error;
287  }
288 
289  if ((err = aacEncoder_SetParam(s->handle, AACENC_CHANNELORDER,
290  1)) != AACENC_OK) {
291  av_log(avctx, AV_LOG_ERROR,
292  "Unable to set wav channel order %d: %s\n",
293  mode, aac_get_error(err));
294  goto error;
295  }
296 
297  if (avctx->flags & AV_CODEC_FLAG_QSCALE || s->vbr) {
298  int mode = s->vbr ? s->vbr : avctx->global_quality;
299  if (mode < 1 || mode > 5) {
300  av_log(avctx, AV_LOG_WARNING,
301  "VBR quality %d out of range, should be 1-5\n", mode);
302  mode = av_clip(mode, 1, 5);
303  }
304  av_log(avctx, AV_LOG_WARNING,
305  "Note, the VBR setting is unsupported and only works with "
306  "some parameter combinations\n");
307  if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATEMODE,
308  mode)) != AACENC_OK) {
309  av_log(avctx, AV_LOG_ERROR, "Unable to set the VBR bitrate mode %d: %s\n",
310  mode, aac_get_error(err));
311  goto error;
312  }
313  } else {
314  if (avctx->bit_rate <= 0) {
315  if (avctx->profile == AV_PROFILE_AAC_HE_V2) {
316  sce = 1;
317  cpe = 0;
318  }
319  avctx->bit_rate = (96*sce + 128*cpe) * avctx->sample_rate / 44;
320  if (avctx->profile == AV_PROFILE_AAC_HE ||
321  avctx->profile == AV_PROFILE_AAC_HE_V2 ||
322  avctx->profile == AV_PROFILE_MPEG2_AAC_HE ||
323  s->eld_sbr)
324  avctx->bit_rate /= 2;
325  }
326  if ((err = aacEncoder_SetParam(s->handle, AACENC_BITRATE,
327  avctx->bit_rate)) != AACENC_OK) {
328  av_log(avctx, AV_LOG_ERROR, "Unable to set the bitrate %"PRId64": %s\n",
329  avctx->bit_rate, aac_get_error(err));
330  goto error;
331  }
332  }
333 
334  /* Choose bitstream format - if global header is requested, use
335  * raw access units, otherwise use ADTS. */
336  if ((err = aacEncoder_SetParam(s->handle, AACENC_TRANSMUX,
337  avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? TT_MP4_RAW :
338  s->latm ? TT_MP4_LOAS : TT_MP4_ADTS)) != AACENC_OK) {
339  av_log(avctx, AV_LOG_ERROR, "Unable to set the transmux format: %s\n",
340  aac_get_error(err));
341  goto error;
342  }
343 
344  if (s->latm && s->header_period) {
345  if ((err = aacEncoder_SetParam(s->handle, AACENC_HEADER_PERIOD,
346  s->header_period)) != AACENC_OK) {
347  av_log(avctx, AV_LOG_ERROR, "Unable to set header period: %s\n",
348  aac_get_error(err));
349  goto error;
350  }
351  }
352 
353  /* If no signaling mode is chosen, use explicit hierarchical signaling
354  * if using mp4 mode (raw access units, with global header) and
355  * implicit signaling if using ADTS. */
356  if (s->signaling < 0)
357  s->signaling = avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER ? 2 : 0;
358 
359  if ((err = aacEncoder_SetParam(s->handle, AACENC_SIGNALING_MODE,
360  s->signaling)) != AACENC_OK) {
361  av_log(avctx, AV_LOG_ERROR, "Unable to set signaling mode %d: %s\n",
362  s->signaling, aac_get_error(err));
363  goto error;
364  }
365 
366  if ((err = aacEncoder_SetParam(s->handle, AACENC_AFTERBURNER,
367  s->afterburner)) != AACENC_OK) {
368  av_log(avctx, AV_LOG_ERROR, "Unable to set afterburner to %d: %s\n",
369  s->afterburner, aac_get_error(err));
370  goto error;
371  }
372 
373  if (avctx->cutoff > 0) {
374  if (avctx->cutoff < (avctx->sample_rate + 255) >> 8 || avctx->cutoff > 20000) {
375  av_log(avctx, AV_LOG_ERROR, "cutoff valid range is %d-20000\n",
376  (avctx->sample_rate + 255) >> 8);
377  goto error;
378  }
379  if ((err = aacEncoder_SetParam(s->handle, AACENC_BANDWIDTH,
380  avctx->cutoff)) != AACENC_OK) {
381  av_log(avctx, AV_LOG_ERROR, "Unable to set the encoder bandwidth to %d: %s\n",
382  avctx->cutoff, aac_get_error(err));
383  goto error;
384  }
385  }
386 
387  s->metadata_mode = 0;
388  if (s->prog_ref) {
389  s->metadata_mode = 1;
390  s->metaDataSetup.prog_ref_level_present = 1;
391  s->metaDataSetup.prog_ref_level = s->prog_ref << 16;
392  }
393  if (s->drc_profile) {
394  s->metadata_mode = 1;
395  s->metaDataSetup.drc_profile = s->drc_profile;
396  s->metaDataSetup.drc_TargetRefLevel = s->drc_target_ref << 16;
397  if (s->comp_profile) {
398  /* Including the comp_profile means that we need to set the mode to ETSI */
399  s->metadata_mode = 2;
400  s->metaDataSetup.comp_profile = s->comp_profile;
401  s->metaDataSetup.comp_TargetRefLevel = s->comp_target_ref << 16;
402  }
403  }
404 
405  if ((err = aacEncoder_SetParam(s->handle, AACENC_METADATA_MODE, s->metadata_mode)) != AACENC_OK) {
406  av_log(avctx, AV_LOG_ERROR, "Unable to set metadata mode to %d: %s\n",
407  s->metadata_mode, aac_get_error(err));
408  goto error;
409  }
410 
411  if ((err = aacEncEncode(s->handle, NULL, NULL, NULL, NULL)) != AACENC_OK) {
412  av_log(avctx, AV_LOG_ERROR, "Unable to initialize the encoder: %s\n",
413  aac_get_error(err));
414  return AVERROR(EINVAL);
415  }
416 
417  if ((err = aacEncInfo(s->handle, &info)) != AACENC_OK) {
418  av_log(avctx, AV_LOG_ERROR, "Unable to get encoder info: %s\n",
419  aac_get_error(err));
420  goto error;
421  }
422 
423  avctx->frame_size = info.frameLength;
424 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
425  avctx->initial_padding = info.nDelay;
426 #else
427  avctx->initial_padding = info.encoderDelay;
428 #endif
429  ff_af_queue_init(avctx, &s->afq);
430 
431  if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
432  avctx->extradata_size = info.confSize;
433  avctx->extradata = av_mallocz(avctx->extradata_size +
434  AV_INPUT_BUFFER_PADDING_SIZE);
435  if (!avctx->extradata) {
436  ret = AVERROR(ENOMEM);
437  goto error;
438  }
439 
440  memcpy(avctx->extradata, info.confBuf, info.confSize);
441  }
442 
443  cpb_props = ff_encode_add_cpb_side_data(avctx);
444  if (!cpb_props)
445  return AVERROR(ENOMEM);
446  cpb_props->max_bitrate =
447  cpb_props->min_bitrate =
448  cpb_props->avg_bitrate = avctx->bit_rate;
449 
450  return 0;
451 error:
452  aac_encode_close(avctx);
453  return ret;
454 }
455 
456  static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
457  const AVFrame *frame, int *got_packet_ptr)
458 {
459  AACContext *s = avctx->priv_data;
460  AACENC_BufDesc in_buf = { 0 }, out_buf = { 0 };
461  AACENC_InArgs in_args = { 0 };
462  AACENC_OutArgs out_args = { 0 };
463  void* inBuffer[] = { 0, &s->metaDataSetup };
464  int in_buffer_identifiers[] = { IN_AUDIO_DATA, IN_METADATA_SETUP };
465  int in_buffer_element_sizes[] = { 2, sizeof(AACENC_MetaData) };
466  int in_buffer_sizes[] = { 0, sizeof(s->metaDataSetup) };
467  int out_buffer_identifier = OUT_BITSTREAM_DATA;
468  int out_buffer_size, out_buffer_element_size;
469  void *out_ptr;
470  int ret, discard_padding;
471  uint8_t dummy_buf[1];
472  AACENC_ERROR err;
473 
474  /* handle end-of-stream small frame and flushing */
475  if (!frame) {
476  /* Must be a non-null pointer, even if it's a dummy. We could use
477  * the address of anything else on the stack as well. */
478  inBuffer[0] = dummy_buf;
479 
480  in_args.numInSamples = -1;
481  } else {
482  inBuffer[0] = frame->data[0];
483  in_buffer_sizes[0] = 2 * avctx->ch_layout.nb_channels * frame->nb_samples;
484 
485  in_args.numInSamples = avctx->ch_layout.nb_channels * frame->nb_samples;
486 
487  /* add current frame to the queue */
488  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
489  return ret;
490  }
491 
492  if (s->metadata_mode == 0) {
493  in_buf.numBufs = 1;
494  } else {
495  in_buf.numBufs = 2;
496  }
497 
498  in_buf.bufs = (void**)inBuffer;
499  in_buf.bufferIdentifiers = in_buffer_identifiers;
500  in_buf.bufSizes = in_buffer_sizes;
501  in_buf.bufElSizes = in_buffer_element_sizes;
502 
503  /* The maximum packet size is 6144 bits aka 768 bytes per channel. */
504  ret = ff_alloc_packet(avctx, avpkt, FFMAX(8192, 768 * avctx->ch_layout.nb_channels));
505  if (ret < 0)
506  return ret;
507 
508  out_ptr = avpkt->data;
509  out_buffer_size = avpkt->size;
510  out_buffer_element_size = 1;
511  out_buf.numBufs = 1;
512  out_buf.bufs = &out_ptr;
513  out_buf.bufferIdentifiers = &out_buffer_identifier;
514  out_buf.bufSizes = &out_buffer_size;
515  out_buf.bufElSizes = &out_buffer_element_size;
516 
517  if ((err = aacEncEncode(s->handle, &in_buf, &out_buf, &in_args,
518  &out_args)) != AACENC_OK) {
519  if (!frame && err == AACENC_ENCODE_EOF)
520  return 0;
521  av_log(avctx, AV_LOG_ERROR, "Unable to encode frame: %s\n",
522  aac_get_error(err));
523  return AVERROR(EINVAL);
524  }
525 
526  if (!out_args.numOutBytes)
527  return 0;
528 
529  /* Get the next frame pts & duration */
530  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
531  &avpkt->duration);
532 
533  discard_padding = avctx->frame_size - avpkt->duration;
534  // Check if subtraction resulted in an overflow
535  if ((discard_padding < avctx->frame_size) != (avpkt->duration > 0)) {
536  av_log(avctx, AV_LOG_ERROR, "discard padding overflow\n");
537  return AVERROR(EINVAL);
538  }
539  if ((!s->delay_sent && avctx->initial_padding > 0) || discard_padding > 0) {
540  uint8_t *side_data =
541  av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
542  if (!side_data)
543  return AVERROR(ENOMEM);
544  if (!s->delay_sent) {
545  AV_WL32(side_data, avctx->initial_padding);
546  s->delay_sent = 1;
547  }
548  AV_WL32(side_data + 4, discard_padding);
549  }
550 
551  avpkt->size = out_args.numOutBytes;
552  avpkt->flags |= AV_PKT_FLAG_KEY;
553  *got_packet_ptr = 1;
554  return 0;
555 }
556 
557  static const AVProfile profiles[] = {
558  { AV_PROFILE_AAC_LOW, "LC" },
559  { AV_PROFILE_AAC_HE, "HE-AAC" },
560  { AV_PROFILE_AAC_HE_V2, "HE-AACv2" },
561  { AV_PROFILE_AAC_LD, "LD" },
562  { AV_PROFILE_AAC_ELD, "ELD" },
563  { AV_PROFILE_UNKNOWN },
564 };
565 
566  static const FFCodecDefault aac_encode_defaults[] = {
567  { "b", "0" },
568  { NULL }
569 };
570 
571  static const AVChannelLayout aac_ch_layouts[16] = {
572  AV_CHANNEL_LAYOUT_MONO,
573  AV_CHANNEL_LAYOUT_STEREO,
574  AV_CHANNEL_LAYOUT_SURROUND,
575  AV_CHANNEL_LAYOUT_4POINT0,
576  AV_CHANNEL_LAYOUT_5POINT0_BACK,
577  AV_CHANNEL_LAYOUT_5POINT1_BACK,
578 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
579  AV_CHANNEL_LAYOUT_6POINT1_BACK,
580 #endif
581 #if FDKENC_VER_AT_LEAST(3, 4) // 3.4.12
582  AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK,
583  AV_CHANNEL_LAYOUT_7POINT1,
584 #endif
585 #if FDKENC_VER_AT_LEAST(4, 0) // 4.0.0
586  AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK,
587 #endif
588  { 0 },
589 };
590 
591  static const int aac_sample_rates[] = {
592  96000, 88200, 64000, 48000, 44100, 32000,
593  24000, 22050, 16000, 12000, 11025, 8000, 0
594 };
595 
596  const FFCodec ff_libfdk_aac_encoder = {
597  .p.name = "libfdk_aac",
598  CODEC_LONG_NAME("Fraunhofer FDK AAC"),
599  .p.type = AVMEDIA_TYPE_AUDIO,
600  .p.id = AV_CODEC_ID_AAC,
601  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
602  AV_CODEC_CAP_ENCODER_FLUSH |
603  AV_CODEC_CAP_SMALL_LAST_FRAME,
604  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE,
605  .priv_data_size = sizeof(AACContext),
606  .init = aac_encode_init,
607  FF_CODEC_ENCODE_CB(aac_encode_frame),
608  .flush = aac_encode_flush,
609  .close = aac_encode_close,
610  CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_S16),
611  .p.priv_class = &aac_enc_class,
612  .defaults = aac_encode_defaults,
613  .p.profiles = profiles,
614  CODEC_SAMPLERATES_ARRAY(aac_sample_rates),
615  .p.wrapper_name = "libfdk",
616  CODEC_CH_LAYOUTS_ARRAY(aac_ch_layouts),
617 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1051
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
av_clip
#define av_clip
Definition: common.h:100
aac_ch_layouts
static const AVChannelLayout aac_ch_layouts[16]
Definition: libfdk-aacenc.c:571
AACContext::metadata_mode
int metadata_mode
Definition: libfdk-aacenc.c:56
AVERROR
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
aac_enc_class
static const AVClass aac_enc_class
Definition: libfdk-aacenc.c:88
ff_libfdk_aac_encoder
const FFCodec ff_libfdk_aac_encoder
Definition: libfdk-aacenc.c:596
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
ff_af_queue_remove
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
Definition: audio_frame_queue.c:75
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:395
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1024
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:213
int64_t
long long int64_t
Definition: coverity.c:34
ff_af_queue_init
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
Definition: audio_frame_queue.c:28
aac_encode_frame
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: libfdk-aacenc.c:456
mode
Definition: swscale.c:56
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
aac_encode_init
static av_cold int aac_encode_init(AVCodecContext *avctx)
Definition: libfdk-aacenc.c:176
AVPacket::data
uint8_t * data
Definition: packet.h:588
AACContext::signaling
int signaling
Definition: libfdk-aacenc.c:47
AVOption
AVOption.
Definition: opt.h:429
encode.h
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:127
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:606
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:643
AV_CODEC_FLAG_GLOBAL_HEADER
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:318
AVProfile
AVProfile.
Definition: codec.h:164
AACContext::frame_length
int frame_length
Definition: libfdk-aacenc.c:59
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1039
aac_get_error
static const char * aac_get_error(AACENC_ERROR err)
Definition: libfdk-aacenc.c:95
audio_frame_queue.h
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1096
AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK
#define AV_CHANNEL_LAYOUT_7POINT1_TOP_BACK
Definition: channel_layout.h:435
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:488
pts
static int64_t pts
Definition: transcode_aac.c:644
AV_CODEC_CAP_ENCODER_FLUSH
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
Definition: codec.h:151
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:359
ff_af_queue_add
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Definition: audio_frame_queue.c:44
AV_CHANNEL_LAYOUT_SURROUND
#define AV_CHANNEL_LAYOUT_SURROUND
Definition: channel_layout.h:398
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:357
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:106
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
duration
int64_t duration
Definition: movenc.c:65
AV_CHANNEL_LAYOUT_4POINT0
#define AV_CHANNEL_LAYOUT_4POINT0
Definition: channel_layout.h:400
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
AV_CHANNEL_LAYOUT_7POINT1
#define AV_CHANNEL_LAYOUT_7POINT1
Definition: channel_layout.h:417
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1217
AV_PROFILE_MPEG2_AAC_HE
#define AV_PROFILE_MPEG2_AAC_HE
Definition: defs.h:78
frame_size
int frame_size
Definition: mxfenc.c:2487
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
info
MIPS optimizations info
Definition: mips.txt:2
AV_CHANNEL_LAYOUT_5POINT0_BACK
#define AV_CHANNEL_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:406
AACContext::prog_ref
int prog_ref
Definition: libfdk-aacenc.c:55
AACContext::eld_v2
int eld_v2
Definition: libfdk-aacenc.c:46
AudioFrameQueue
Definition: audio_frame_queue.h:32
AACContext::vbr
int vbr
Definition: libfdk-aacenc.c:50
AACContext::header_period
int header_period
Definition: libfdk-aacenc.c:49
AV_PROFILE_AAC_ELD
#define AV_PROFILE_AAC_ELD
Definition: defs.h:75
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:282
AACContext::latm
int latm
Definition: libfdk-aacenc.c:48
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
AACContext::comp_target_ref
int comp_target_ref
Definition: libfdk-aacenc.c:54
if
if(ret)
Definition: filter_design.txt:179
ff_af_queue_close
av_cold void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK
Definition: channel_layout.h:419
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
AACContext::comp_profile
int comp_profile
Definition: libfdk-aacenc.c:53
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:481
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:241
profiles.h
AACContext::metaDataSetup
AACENC_MetaData metaDataSetup
Definition: libfdk-aacenc.c:57
aac_encode_close
static int aac_encode_close(AVCodecContext *avctx)
Definition: libfdk-aacenc.c:127
AACContext::afterburner
int afterburner
Definition: libfdk-aacenc.c:44
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
Definition: opt.h:352
aac_encode_defaults
static const FFCodecDefault aac_encode_defaults[]
Definition: libfdk-aacenc.c:566
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:461
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:550
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:589
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
codec_internal.h
AACContext::afq
AudioFrameQueue afq
Definition: libfdk-aacenc.c:61
AV_PROFILE_AAC_LD
#define AV_PROFILE_AAC_LD
Definition: defs.h:74
AVCPBProperties::min_bitrate
int64_t min_bitrate
Minimum bitrate of the stream, in bits per second.
Definition: defs.h:292
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:594
CODEC_SAMPLEFMTS
#define CODEC_SAMPLEFMTS(...)
Definition: codec_internal.h:386
AVCPBProperties::avg_bitrate
int64_t avg_bitrate
Average bitrate of the stream, in bits per second.
Definition: defs.h:297
aac_encode_flush
static void aac_encode_flush(AVCodecContext *avctx)
Definition: libfdk-aacenc.c:138
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:809
AV_CHANNEL_LAYOUT_6POINT1_BACK
#define AV_CHANNEL_LAYOUT_6POINT1_BACK
Definition: channel_layout.h:413
AACContext::eld_sbr
int eld_sbr
Definition: libfdk-aacenc.c:45
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:581
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
common.h
AVCodecContext::cutoff
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:1064
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:287
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
avcodec.h
ret
ret
Definition: filter_design.txt:187
AACContext::drc_target_ref
int drc_target_ref
Definition: libfdk-aacenc.c:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_PROFILE_AAC_LOW
#define AV_PROFILE_AAC_LOW
Definition: defs.h:69
AVCodecContext
main external API structure.
Definition: avcodec.h:431
channel_layout.h
CODEC_SAMPLERATES_ARRAY
#define CODEC_SAMPLERATES_ARRAY(array)
Definition: codec_internal.h:384
AV_PROFILE_AAC_HE_V2
#define AV_PROFILE_AAC_HE_V2
Definition: defs.h:73
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: packet.c:231
mode
mode
Definition: ebur128.h:83
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1618
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommends skipping the specified number of samples.
Definition: packet.h:153
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:557
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
mem.h
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:394
AV_PROFILE_AAC_HE
#define AV_PROFILE_AAC_HE
Definition: defs.h:72
FF_AAC_PROFILE_OPTS
#define FF_AAC_PROFILE_OPTS
Definition: profiles.h:29
AVPacket
This structure stores compressed data.
Definition: packet.h:565
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
aac_sample_rates
static const int aac_sample_rates[]
Definition: libfdk-aacenc.c:591
AACContext
Definition: libfdk-aacenc.c:41
AV_CHANNEL_LAYOUT_5POINT1_BACK
#define AV_CHANNEL_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:407
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:887
AACContext::handle
HANDLE_AACENCODER handle
Definition: libfdk-aacenc.c:43
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:81
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
AACContext::delay_sent
int delay_sent
Definition: libfdk-aacenc.c:58
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:61
CODEC_CH_LAYOUTS_ARRAY
#define CODEC_CH_LAYOUTS_ARRAY(array)
Definition: codec_internal.h:381
aac_enc_options
static const AVOption aac_enc_options[]
Definition: libfdk-aacenc.c:64
AACContext::drc_profile
int drc_profile
Definition: libfdk-aacenc.c:51
Generated on Wed Nov 19 2025 19:22:06 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /