## ffmpeg / libavcodec / ac3enc_float.c @ 26f548bb

History | View | Annotate | Download (3.16 KB)

1 | 6fd96d1a | Justin Ruggles | ```
/*
``` |
---|---|---|---|

2 | ```
* The simplest AC-3 encoder
``` |
||

3 | ```
* Copyright (c) 2000 Fabrice Bellard
``` |
||

4 | ```
* Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
``` |
||

5 | ```
* Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
``` |
||

6 | ```
*
``` |
||

7 | 2912e87a | Mans Rullgard | ```
* This file is part of Libav.
``` |

8 | 6fd96d1a | Justin Ruggles | ```
*
``` |

9 | 2912e87a | Mans Rullgard | ```
* Libav is free software; you can redistribute it and/or
``` |

10 | 6fd96d1a | Justin Ruggles | ```
* modify it under the terms of the GNU Lesser General Public
``` |

11 | ```
* License as published by the Free Software Foundation; either
``` |
||

12 | ```
* version 2.1 of the License, or (at your option) any later version.
``` |
||

13 | ```
*
``` |
||

14 | 2912e87a | Mans Rullgard | ```
* Libav is distributed in the hope that it will be useful,
``` |

15 | 6fd96d1a | Justin Ruggles | ```
* but WITHOUT ANY WARRANTY; without even the implied warranty of
``` |

16 | ```
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
``` |
||

17 | ```
* Lesser General Public License for more details.
``` |
||

18 | ```
*
``` |
||

19 | ```
* You should have received a copy of the GNU Lesser General Public
``` |
||

20 | 2912e87a | Mans Rullgard | ```
* License along with Libav; if not, write to the Free Software
``` |

21 | 6fd96d1a | Justin Ruggles | ```
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
``` |

22 | ```
*/
``` |
||

23 | |||

24 | ```
/**
``` |
||

25 | ```
* @file
``` |
||

26 | ```
* floating-point AC-3 encoder.
``` |
||

27 | ```
*/
``` |
||

28 | |||

29 | #define CONFIG_AC3ENC_FLOAT 1 |
||

30 | #include "ac3enc.c" |
||

31 | |||

32 | |||

33 | ```
/**
``` |
||

34 | ```
* Finalize MDCT and free allocated memory.
``` |
||

35 | ```
*/
``` |
||

36 | static av_cold void mdct_end(AC3MDCTContext *mdct) |
||

37 | { |
||

38 | ff_mdct_end(&mdct->fft); |
||

39 | av_freep(&mdct->window); |
||

40 | } |
||

41 | |||

42 | |||

43 | ```
/**
``` |
||

44 | ```
* Initialize MDCT tables.
``` |
||

45 | ```
* @param nbits log2(MDCT size)
``` |
||

46 | ```
*/
``` |
||

47 | static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct, |
||

48 | ```
int nbits)
``` |
||

49 | { |
||

50 | ```
float *window;
``` |
||

51 | 3b924294 | Justin Ruggles | ```
int i, n, n2;
``` |

52 | 6fd96d1a | Justin Ruggles | |

53 | ```
n = 1 << nbits;
``` |
||

54 | ```
n2 = n >> 1;
``` |
||

55 | |||

56 | 3b924294 | Justin Ruggles | ```
window = av_malloc(n * sizeof(*window));
``` |

57 | 6fd96d1a | Justin Ruggles | ```
if (!window) {
``` |

58 | ```
av_log(avctx, AV_LOG_ERROR, "Cannot allocate memory.\n");
``` |
||

59 | ```
return AVERROR(ENOMEM);
``` |
||

60 | } |
||

61 | ff_kbd_window_init(window, 5.0, n2); |
||

62 | 3b924294 | Justin Ruggles | for (i = 0; i < n2; i++) |

63 | ```
window[n-1-i] = window[i];
``` |
||

64 | 6fd96d1a | Justin Ruggles | mdct->window = window; |

65 | |||

66 | return ff_mdct_init(&mdct->fft, nbits, 0, -2.0 / n); |
||

67 | } |
||

68 | |||

69 | |||

70 | ```
/**
``` |
||

71 | ```
* Calculate a 512-point MDCT
``` |
||

72 | ```
* @param out 256 output frequency coefficients
``` |
||

73 | ```
* @param in 512 windowed input audio samples
``` |
||

74 | ```
*/
``` |
||

75 | static void mdct512(AC3MDCTContext *mdct, float *out, float *in) |
||

76 | { |
||

77 | 26f548bb | Mans Rullgard | mdct->fft.mdct_calc(&mdct->fft, out, in); |

78 | 6fd96d1a | Justin Ruggles | } |

79 | |||

80 | |||

81 | ```
/**
``` |
||

82 | ```
* Apply KBD window to input samples prior to MDCT.
``` |
||

83 | ```
*/
``` |
||

84 | 3b924294 | Justin Ruggles | static void apply_window(DSPContext *dsp, float *output, const float *input, |

85 | 6fd96d1a | Justin Ruggles | const float *window, int n) |

86 | { |
||

87 | 3b924294 | Justin Ruggles | dsp->vector_fmul(output, input, window, n); |

88 | 6fd96d1a | Justin Ruggles | } |

89 | |||

90 | |||

91 | ```
/**
``` |
||

92 | ```
* Normalize the input samples to use the maximum available precision.
``` |
||

93 | ```
*/
``` |
||

94 | static int normalize_samples(AC3EncodeContext *s) |
||

95 | { |
||

96 | ```
/* Normalization is not needed for floating-point samples, so just return 0 */
``` |
||

97 | return 0; |
||

98 | } |
||

99 | |||

100 | |||

101 | ac05f903 | Justin Ruggles | ```
/**
``` |

102 | ```
* Scale MDCT coefficients from float to 24-bit fixed-point.
``` |
||

103 | ```
*/
``` |
||

104 | static void scale_coefficients(AC3EncodeContext *s) |
||

105 | { |
||

106 | 0f999cfd | Justin Ruggles | s->ac3dsp.float_to_fixed24(s->fixed_coef_buffer, s->mdct_coef_buffer, |

107 | AC3_MAX_COEFS * AC3_MAX_BLOCKS * s->channels); |
||

108 | ac05f903 | Justin Ruggles | } |

109 | |||

110 | |||

111 | d36beb3f | Diego Elio PettenÃ² | AVCodec ff_ac3_encoder = { |

112 | 6fd96d1a | Justin Ruggles | ```
"ac3",
``` |

113 | AVMEDIA_TYPE_AUDIO, |
||

114 | CODEC_ID_AC3, |
||

115 | ```
sizeof(AC3EncodeContext),
``` |
||

116 | ac3_encode_init, |
||

117 | ac3_encode_frame, |
||

118 | ac3_encode_close, |
||

119 | ```
NULL,
``` |
||

120 | .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE}, |
||

121 | ```
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
``` |
||

122 | .channel_layouts = ac3_channel_layouts, |
||

123 | }; |