FFmpeg: libavcodec/s302m.c Source File

FFmpeg

[フレーム]

libavcodec

s302m.c

Go to the documentation of this file.

1 /*

2 * SMPTE 302M decoder

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

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

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #include "libavutil/intreadwrite.h"

24 #include "libavutil/log.h"

25 #include "avcodec.h"

26 #include "internal.h"

27 #include "mathops.h"

29 #define AES3_HEADER_LEN 4

31 static int s302m_parse_frame_header(AVCodecContext *avctx, const uint8_t *buf,

32 int buf_size)

33 {

34 uint32_t h;

35 int frame_size, channels, bits;

37 if (buf_size <= AES3_HEADER_LEN) {

38 av_log(avctx, AV_LOG_ERROR, "frame is too short\n");

39 return AVERROR_INVALIDDATA;

40 }

42 /*

43 * AES3 header :

44 * size: 16

45 * number channels 2

46 * channel_id 8

47 * bits per samples 2

48 * alignments 4

49 */

51 h = AV_RB32(buf);

52 frame_size = (h >> 16) & 0xffff;

53 channels = ((h >> 14) & 0x0003) * 2 + 2;

54 bits = ((h >> 4) & 0x0003) * 4 + 16;

56 if (AES3_HEADER_LEN + frame_size != buf_size || bits > 24) {

57 av_log(avctx, AV_LOG_ERROR, "frame has invalid header\n");

58 return AVERROR_INVALIDDATA;

59 }

61 /* Set output properties */

62 avctx->bits_per_raw_sample = bits;

63 if (bits > 16)

64 avctx->sample_fmt = AV_SAMPLE_FMT_S32;

65 else

66 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

68 avctx->channels = channels;

69 switch(channels) {

70 case 2:

71 avctx->channel_layout = AV_CH_LAYOUT_STEREO;

72 break;

73 case 4:

74 avctx->channel_layout = AV_CH_LAYOUT_QUAD;

75 break;

76 case 6:

77 avctx->channel_layout = AV_CH_LAYOUT_5POINT1_BACK;

78 break;

79 case 8:

80 avctx->channel_layout = AV_CH_LAYOUT_5POINT1_BACK | AV_CH_LAYOUT_STEREO_DOWNMIX;

81 }

82 avctx->sample_rate = 48000;

83 avctx->bit_rate = 48000 * avctx->channels * (avctx->bits_per_raw_sample + 4) +

84 32 * (48000 / (buf_size * 8 /

85 (avctx->channels *

86 (avctx->bits_per_raw_sample + 4))));

88 return frame_size;

89 }

91 static int s302m_decode_frame(AVCodecContext *avctx, void *data,

92 int *got_frame_ptr, AVPacket *avpkt)

93 {

94 AVFrame *frame = data;

95 const uint8_t *buf = avpkt->data;

96 int buf_size = avpkt->size;

97 int block_size, ret;

99 int frame_size = s302m_parse_frame_header(avctx, buf, buf_size);

100 if (frame_size < 0)

101 return frame_size;

102

103 buf_size -= AES3_HEADER_LEN;

104 buf += AES3_HEADER_LEN;

105

106 /* get output buffer */

107 block_size = (avctx->bits_per_raw_sample + 4) / 4;

108 frame->nb_samples = 2 * (buf_size / block_size) / avctx->channels;

109 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

110 return ret;

111

112 buf_size = (frame->nb_samples * avctx->channels / 2) * block_size;

113

114 if (avctx->bits_per_raw_sample == 24) {

115 uint32_t *o = (uint32_t *)frame->data[0];

116 for (; buf_size > 6; buf_size -= 7) {

117 *o++ = (ff_reverse[buf[2]] << 24) |

118 (ff_reverse[buf[1]] << 16) |

119 (ff_reverse[buf[0]] << 8);

120 *o++ = (ff_reverse[buf[6] & 0xf0] << 28) |

121 (ff_reverse[buf[5]] << 20) |

122 (ff_reverse[buf[4]] << 12) |

123 (ff_reverse[buf[3] & 0x0f] << 4);

124 buf += 7;

125 }

126 } else if (avctx->bits_per_raw_sample == 20) {

127 uint32_t *o = (uint32_t *)frame->data[0];

128 for (; buf_size > 5; buf_size -= 6) {

129 *o++ = (ff_reverse[buf[2] & 0xf0] << 28) |

130 (ff_reverse[buf[1]] << 20) |

131 (ff_reverse[buf[0]] << 12);

132 *o++ = (ff_reverse[buf[5] & 0xf0] << 28) |

133 (ff_reverse[buf[4]] << 20) |

134 (ff_reverse[buf[3]] << 12);

135 buf += 6;

136 }

137 } else {

138 uint16_t *o = (uint16_t *)frame->data[0];

139 for (; buf_size > 4; buf_size -= 5) {

140 *o++ = (ff_reverse[buf[1]] << 8) |

141 ff_reverse[buf[0]];

142 *o++ = (ff_reverse[buf[4] & 0xf0] << 12) |

143 (ff_reverse[buf[3]] << 4) |

144 (ff_reverse[buf[2]] >> 4);

145 buf += 5;

146 }

147 }

148

149 *got_frame_ptr = 1;

150

151 return avpkt->size;

152 }

153

154 AVCodec ff_s302m_decoder = {

155 .name = "s302m",

156 .long_name = NULL_IF_CONFIG_SMALL("SMPTE 302M"),

157 .type = AVMEDIA_TYPE_AUDIO,

158 .id = AV_CODEC_ID_S302M,

159 .decode = s302m_decode_frame,

160 .capabilities = CODEC_CAP_DR1,

161 };

Generated on Sun Mar 8 2015 02:34:59 for FFmpeg by doxygen 1.8.2