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/channel_layout.h"

24 #include "libavutil/intreadwrite.h"

25 #include "libavutil/opt.h"

26 #include "libavutil/log.h"

27 #include "libavutil/reverse.h"

28 #include "avcodec.h"

29 #include "codec_internal.h"

30 #include "decode.h"

32 #define AES3_HEADER_LEN 4

34 typedef struct S302Context {

35 AVClass *class;

36 int non_pcm_mode;

37 } S302Context;

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

40 int buf_size)

41 {

42 uint32_t h;

43 int frame_size, channels, bits;

45 if (buf_size <= AES3_HEADER_LEN) {

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

47 return AVERROR_INVALIDDATA;

48 }

50 /*

51 * AES3 header :

52 * size: 16

53 * number channels 2

54 * channel_id 8

55 * bits per samples 2

56 * alignments 4

57 */

59 h = AV_RB32(buf);

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

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

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

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

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

66 return AVERROR_INVALIDDATA;

67 }

69 /* Set output properties */

70 avctx->bits_per_raw_sample = bits;

71 if (bits > 16)

72 avctx->sample_fmt = AV_SAMPLE_FMT_S32;

73 else

74 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

76 av_channel_layout_uninit(&avctx->ch_layout);

77 switch(channels) {

78 case 2:

79 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;

80 break;

81 case 4:

82 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_QUAD;

83 break;

84 case 6:

85 avctx->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1_BACK;

86 break;

87 case 8:

88 av_channel_layout_from_mask(&avctx->ch_layout,

89 AV_CH_LAYOUT_5POINT1_BACK | AV_CH_LAYOUT_STEREO_DOWNMIX);

90 break;

91 default:

92 avctx->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC;

93 avctx->ch_layout.nb_channels = channels;

94 break;

95 }

97 return frame_size;

98 }

100 static int s302m_decode_frame(AVCodecContext *avctx, AVFrame *frame,

101 int *got_frame_ptr, AVPacket *avpkt)

102 {

103 S302Context *s = avctx->priv_data;

104 const uint8_t *buf = avpkt->data;

105 int buf_size = avpkt->size;

106 int block_size, ret, channels;

107 int i;

108 int non_pcm_data_type = -1;

109

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

111 if (frame_size < 0)

112 return frame_size;

113

114 buf_size -= AES3_HEADER_LEN;

115 buf += AES3_HEADER_LEN;

116

117 /* get output buffer */

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

119 channels = avctx->ch_layout.nb_channels;

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

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

122 return ret;

123

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

125 32 * 48000 / frame->nb_samples;

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

127

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

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

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

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

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

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

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

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

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

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

138 buf += 7;

139 }

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

141 if (channels == 2)

142 for (i=0; i<frame->nb_samples * 2 - 6; i+=2) {

143 if (o[i] || o[i+1] || o[i+2] || o[i+3])

144 break;

145 if (o[i+4] == 0x96F87200U && o[i+5] == 0xA54E1F00) {

146 non_pcm_data_type = (o[i+6] >> 16) & 0x1F;

147 break;

148 }

149 }

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

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

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

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

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

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

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

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

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

159 buf += 6;

160 }

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

162 if (channels == 2)

163 for (i=0; i<frame->nb_samples * 2 - 6; i+=2) {

164 if (o[i] || o[i+1] || o[i+2] || o[i+3])

165 break;

166 if (o[i+4] == 0x6F872000U && o[i+5] == 0x54E1F000) {

167 non_pcm_data_type = (o[i+6] >> 16) & 0x1F;

168 break;

169 }

170 }

171 } else {

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

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

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

175 ff_reverse[buf[0]];

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

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

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

179 buf += 5;

180 }

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

182 if (channels == 2)

183 for (i=0; i<frame->nb_samples * 2 - 6; i+=2) {

184 if (o[i] || o[i+1] || o[i+2] || o[i+3])

185 break;

186 if (o[i+4] == 0xF872U && o[i+5] == 0x4E1F) {

187 non_pcm_data_type = (o[i+6] & 0x1F);

188 break;

189 }

190 }

191 }

192

193 if (non_pcm_data_type != -1) {

194 if (s->non_pcm_mode == 3) {

195 av_log(avctx, AV_LOG_ERROR,

196 "S302 non PCM mode with data type %d not supported\n",

197 non_pcm_data_type);

198 return AVERROR_PATCHWELCOME;

199 }

200 if (s->non_pcm_mode & 1) {

201 return avpkt->size;

202 }

203 }

204

205 avctx->sample_rate = 48000;

206

207 *got_frame_ptr = 1;

208

209 return avpkt->size;

210 }

211

212 #define FLAGS AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_DECODING_PARAM

213 static const AVOption s302m_options[] = {

214 {"non_pcm_mode", "Chooses what to do with NON-PCM", offsetof(S302Context, non_pcm_mode), AV_OPT_TYPE_INT, {.i64 = 3}, 0, 3, FLAGS, .unit = "non_pcm_mode"},

215 {"copy" , "Pass NON-PCM through unchanged" , 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 3, FLAGS, .unit = "non_pcm_mode"},

216 {"drop" , "Drop NON-PCM" , 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 3, FLAGS, .unit = "non_pcm_mode"},

217 {"decode_copy" , "Decode if possible else passthrough", 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 3, FLAGS, .unit = "non_pcm_mode"},

218 {"decode_drop" , "Decode if possible else drop" , 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 3, FLAGS, .unit = "non_pcm_mode"},

219 {NULL}

220 };

221

222 static const AVClass s302m_class = {

223 .class_name = "SMPTE 302M Decoder",

224 .item_name = av_default_item_name,

225 .option = s302m_options,

226 .version = LIBAVUTIL_VERSION_INT,

227 };

228

229 const FFCodec ff_s302m_decoder = {

230 .p.name = "s302m",

231 CODEC_LONG_NAME("SMPTE 302M"),

232 .p.type = AVMEDIA_TYPE_AUDIO,

233 .p.id = AV_CODEC_ID_S302M,

234 .p.priv_class = &s302m_class,

235 .priv_data_size = sizeof(S302Context),

236 FF_CODEC_DECODE_CB(s302m_decode_frame),

237 .p.capabilities = AV_CODEC_CAP_CHANNEL_CONF |

238 AV_CODEC_CAP_DR1,

239 };

opt.h

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

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

AVPacket::data

uint8_t * data

Definition: packet.h:558

AVOption

AVOption.

Definition: opt.h:429

ff_reverse

const uint8_t ff_reverse[256]

Definition: reverse.c:23

FFCodec

Definition: codec_internal.h:127

AES3_HEADER_LEN

#define AES3_HEADER_LEN

Definition: s302m.c:32

reverse.h

AVChannelLayout::order

enum AVChannelOrder order

Channel order used in this layout.

Definition: channel_layout.h:324

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

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

s302m_class

static const AVClass s302m_class

Definition: s302m.c:222

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

AV_CODEC_ID_S302M

@ AV_CODEC_ID_S302M

Definition: codec_id.h:363

FLAGS

#define FLAGS

Definition: s302m.c:212

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:198

frame_size

int frame_size

Definition: mxfenc.c:2474

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

AV_CHANNEL_ORDER_UNSPEC

@ AV_CHANNEL_ORDER_UNSPEC

Only the channel count is specified, without any further information about the channel order.

Definition: channel_layout.h:119

av_channel_layout_from_mask

int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)

Initialize a native channel layout from a bitmask indicating which channels are present.

Definition: channel_layout.c:252

AV_CH_LAYOUT_STEREO_DOWNMIX

#define AV_CH_LAYOUT_STEREO_DOWNMIX

Definition: channel_layout.h:255

bits

uint8_t bits

Definition: vp3data.h:128

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1553

channels

Definition: aptx.h:31

decode.h

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

if(ret)

Definition: filter_design.txt:179

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

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

S302Context

Definition: s302m.c:34

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

ff_s302m_decoder

const FFCodec ff_s302m_decoder

Definition: s302m.c:229

AV_CODEC_CAP_CHANNEL_CONF

#define AV_CODEC_CAP_CHANNEL_CONF

Codec should fill in channel configuration and samplerate instead of container.

Definition: codec.h:91

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1720

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:559

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:319

codec_internal.h

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1031

s302m_decode_frame

static int s302m_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)

Definition: s302m.c:100

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:96

S302Context::non_pcm_mode

int non_pcm_mode

Definition: s302m.c:36

AV_CH_LAYOUT_5POINT1_BACK

#define AV_CH_LAYOUT_5POINT1_BACK

Definition: channel_layout.h:230

log.h

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AV_CHANNEL_LAYOUT_QUAD

#define AV_CHANNEL_LAYOUT_QUAD

Definition: channel_layout.h:403

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

avcodec.h

ret

Definition: filter_design.txt:187

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

AVCodecContext

main external API structure.

Definition: avcodec.h:431

channel_layout.h

s302m_options

static const AVOption s302m_options[]

Definition: s302m.c:213

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259