FFmpeg: libavcodec/indeo2.c Source File

FFmpeg

[フレーム]

libavcodec

indeo2.c

Go to the documentation of this file.

1 /*

2 * Intel Indeo 2 codec

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * Intel Indeo 2 decoder.

25 */

27 #define BITSTREAM_READER_LE

28 #include "libavutil/attributes.h"

29 #include "avcodec.h"

30 #include "get_bits.h"

31 #include "indeo2data.h"

32 #include "internal.h"

33 #include "mathops.h"

35 typedef struct Ir2Context{

36 AVCodecContext *avctx;

37 AVFrame *picture;

38 GetBitContext gb;

39 int decode_delta;

40 } Ir2Context;

42 #define CODE_VLC_BITS 14

43 static VLC ir2_vlc;

45 /* Indeo 2 codes are in range 0x01..0x7F and 0x81..0x90 */

46 static inline int ir2_get_code(GetBitContext *gb)

47 {

48 return get_vlc2(gb, ir2_vlc.table, CODE_VLC_BITS, 1) + 1;

49 }

51 static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst,

52 int pitch, const uint8_t *table)

53 {

54 int i;

55 int j;

56 int out = 0;

57 int c;

58 int t;

60 if (width & 1)

61 return AVERROR_INVALIDDATA;

63 /* first line contain absolute values, other lines contain deltas */

64 while (out < width) {

65 c = ir2_get_code(&ctx->gb);

66 if (c >= 0x80) { /* we have a run */

67 c -= 0x7F;

68 if (out + c*2 > width)

69 return AVERROR_INVALIDDATA;

70 for (i = 0; i < c * 2; i++)

71 dst[out++] = 0x80;

72 } else { /* copy two values from table */

73 dst[out++] = table[c * 2];

74 dst[out++] = table[(c * 2) + 1];

75 }

76 }

77 dst += pitch;

79 for (j = 1; j < height; j++) {

80 out = 0;

81 while (out < width) {

82 c = ir2_get_code(&ctx->gb);

83 if (c >= 0x80) { /* we have a skip */

84 c -= 0x7F;

85 if (out + c*2 > width)

86 return AVERROR_INVALIDDATA;

87 for (i = 0; i < c * 2; i++) {

88 dst[out] = dst[out - pitch];

89 out++;

90 }

91 } else { /* add two deltas from table */

92 t = dst[out - pitch] + (table[c * 2] - 128);

93 t = av_clip_uint8(t);

94 dst[out] = t;

95 out++;

96 t = dst[out - pitch] + (table[(c * 2) + 1] - 128);

97 t = av_clip_uint8(t);

98 dst[out] = t;

99 out++;

100 }

101 }

102 dst += pitch;

103 }

104 return 0;

105 }

106

107 static int ir2_decode_plane_inter(Ir2Context *ctx, int width, int height, uint8_t *dst,

108 int pitch, const uint8_t *table)

109 {

110 int j;

111 int out = 0;

112 int c;

113 int t;

114

115 if (width & 1)

116 return AVERROR_INVALIDDATA;

117

118 for (j = 0; j < height; j++) {

119 out = 0;

120 while (out < width) {

121 c = ir2_get_code(&ctx->gb);

122 if (c >= 0x80) { /* we have a skip */

123 c -= 0x7F;

124 out += c * 2;

125 } else { /* add two deltas from table */

126 t = dst[out] + (((table[c * 2] - 128)*3) >> 2);

127 t = av_clip_uint8(t);

128 dst[out] = t;

129 out++;

130 t = dst[out] + (((table[(c * 2) + 1] - 128)*3) >> 2);

131 t = av_clip_uint8(t);

132 dst[out] = t;

133 out++;

134 }

135 }

136 dst += pitch;

137 }

138 return 0;

139 }

140

141 static int ir2_decode_frame(AVCodecContext *avctx,

142 void *data, int *got_frame,

143 AVPacket *avpkt)

144 {

145 Ir2Context * const s = avctx->priv_data;

146 const uint8_t *buf = avpkt->data;

147 int buf_size = avpkt->size;

148 AVFrame *picture = data;

149 AVFrame * const p = s->picture;

150 int start, ret;

151

152 if ((ret = ff_reget_buffer(avctx, p)) < 0)

153 return ret;

154

155 start = 48; /* hardcoded for now */

156

157 if (start >= buf_size) {

158 av_log(s->avctx, AV_LOG_ERROR, "input buffer size too small (%d)\n", buf_size);

159 return AVERROR_INVALIDDATA;

160 }

161

162 s->decode_delta = buf[18];

163

164 /* decide whether frame uses deltas or not */

165 #ifndef BITSTREAM_READER_LE

166 for (i = 0; i < buf_size; i++)

167 buf[i] = ff_reverse[buf[i]];

168 #endif

169

170 init_get_bits(&s->gb, buf + start, (buf_size - start) * 8);

171

172 if (s->decode_delta) { /* intraframe */

173 if ((ret = ir2_decode_plane(s, avctx->width, avctx->height,

174 p->data[0], p->linesize[0],

175 ir2_luma_table)) < 0)

176 return ret;

177

178 /* swapped U and V */

179 if ((ret = ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,

180 p->data[2], p->linesize[2],

181 ir2_luma_table)) < 0)

182 return ret;

183 if ((ret = ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,

184 p->data[1], p->linesize[1],

185 ir2_luma_table)) < 0)

186 return ret;

187 } else { /* interframe */

188 if ((ret = ir2_decode_plane_inter(s, avctx->width, avctx->height,

189 p->data[0], p->linesize[0],

190 ir2_luma_table)) < 0)

191 return ret;

192 /* swapped U and V */

193 if ((ret = ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,

194 p->data[2], p->linesize[2],

195 ir2_luma_table)) < 0)

196 return ret;

197 if ((ret = ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,

198 p->data[1], p->linesize[1],

199 ir2_luma_table)) < 0)

200 return ret;

201 }

202

203 if ((ret = av_frame_ref(picture, p)) < 0)

204 return ret;

205

206 *got_frame = 1;

207

208 return buf_size;

209 }

210

211 static av_cold int ir2_decode_init(AVCodecContext *avctx)

212 {

213 Ir2Context * const ic = avctx->priv_data;

214 static VLC_TYPE vlc_tables[1 << CODE_VLC_BITS][2];

215

216 ic->avctx = avctx;

217

218 avctx->pix_fmt= AV_PIX_FMT_YUV410P;

219

220 ic->picture = av_frame_alloc();

221 if (!ic->picture)

222 return AVERROR(ENOMEM);

223

224 ir2_vlc.table = vlc_tables;

225 ir2_vlc.table_allocated = 1 << CODE_VLC_BITS;

226 #ifdef BITSTREAM_READER_LE

227 init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,

228 &ir2_codes[0][1], 4, 2,

229 &ir2_codes[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

230 #else

231 init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,

232 &ir2_codes[0][1], 4, 2,

233 &ir2_codes[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC);

234 #endif

235

236 return 0;

237 }

238

239 static av_cold int ir2_decode_end(AVCodecContext *avctx)

240 {

241 Ir2Context * const ic = avctx->priv_data;

242

243 av_frame_free(&ic->picture);

244

245 return 0;

246 }

247

248 AVCodec ff_indeo2_decoder = {

249 .name = "indeo2",

250 .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 2"),

251 .type = AVMEDIA_TYPE_VIDEO,

252 .id = AV_CODEC_ID_INDEO2,

253 .priv_data_size = sizeof(Ir2Context),

254 .init = ir2_decode_init,

255 .close = ir2_decode_end,

256 .decode = ir2_decode_frame,

257 .capabilities = CODEC_CAP_DR1,

258 };

Generated on Sun Jul 20 2014 23:05:49 for FFmpeg by doxygen 1.8.2