FFmpeg: libavcodec/escape130.c Source File

FFmpeg

[フレーム]

libavcodec

escape130.c

Go to the documentation of this file.

1 /*

2 * Escape 130 Video Decoder

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 #include "avcodec.h"

24 #define BITSTREAM_READER_LE

25 #include "get_bits.h"

26 #include "internal.h"

29 typedef struct Escape130Context {

30 AVFrame frame;

31 uint8_t *bases;

32 } Escape130Context;

34 /**

35 * Initialize the decoder

36 * @param avctx decoder context

37 * @return 0 success, negative on error

38 */

39 static av_cold int escape130_decode_init(AVCodecContext *avctx)

40 {

41 Escape130Context *s = avctx->priv_data;

42 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

44 if((avctx->width&1) || (avctx->height&1)){

45 av_log(avctx, AV_LOG_ERROR, "Dimensions are not a multiple of the block size\n");

46 return AVERROR(EINVAL);

47 }

49 s->bases= av_malloc(avctx->width * avctx->height /4);

51 return 0;

52 }

54 static av_cold int escape130_decode_close(AVCodecContext *avctx)

55 {

56 Escape130Context *s = avctx->priv_data;

58 if (s->frame.data[0])

59 avctx->release_buffer(avctx, &s->frame);

61 av_freep(&s->bases);

63 return 0;

64 }

66 static unsigned decode_skip_count(GetBitContext* gb) {

67 unsigned value;

68 // This function reads a maximum of 27 bits,

69 // which is within the padding space

70 if (get_bits_left(gb) < 1+3)

71 return -1;

73 value = get_bits1(gb);

74 if (value)

75 return 0;

77 value = get_bits(gb, 3);

78 if (value)

79 return value;

81 value = get_bits(gb, 8);

82 if (value)

83 return value + 7;

85 value = get_bits(gb, 15);

86 if (value)

87 return value + 262;

89 return -1;

90 }

92 /**

93 * Decode a single frame

94 * @param avctx decoder context

95 * @param data decoded frame

96 * @param got_frame have decoded frame

97 * @param buf input buffer

98 * @param buf_size input buffer size

99 * @return 0 success, -1 on error

100 */

101 static int escape130_decode_frame(AVCodecContext *avctx,

102 void *data, int *got_frame,

103 AVPacket *avpkt)

104 {

105 const uint8_t *buf = avpkt->data;

106 int buf_size = avpkt->size;

107 Escape130Context *s = avctx->priv_data;

108

109 GetBitContext gb;

110 unsigned i;

111

112 uint8_t *old_y, *old_cb, *old_cr,

113 *new_y, *new_cb, *new_cr;

114 unsigned old_y_stride, old_cb_stride, old_cr_stride,

115 new_y_stride, new_cb_stride, new_cr_stride;

116 unsigned total_blocks = avctx->width * avctx->height / 4,

117 block_index, row_index = 0;

118 unsigned y[4] = {0}, cb = 16, cr = 16;

119 unsigned skip = -1;

120 unsigned y_base = 0;

121 uint8_t *yb= s->bases;

122

123 AVFrame new_frame = { { 0 } };

124

125 init_get_bits(&gb, buf, buf_size * 8);

126

127 if (get_bits_left(&gb) < 128)

128 return -1;

129

130 // Header; no useful information in here

131 skip_bits_long(&gb, 128);

132

133 new_frame.reference = 3;

134 if (ff_get_buffer(avctx, &new_frame)) {

135 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

136 return -1;

137 }

138

139 new_y = new_frame.data[0];

140 new_cb = new_frame.data[1];

141 new_cr = new_frame.data[2];

142 new_y_stride = new_frame.linesize[0];

143 new_cb_stride = new_frame.linesize[1];

144 new_cr_stride = new_frame.linesize[2];

145 old_y = s->frame.data[0];

146 old_cb = s->frame.data[1];

147 old_cr = s->frame.data[2];

148 old_y_stride = s->frame.linesize[0];

149 old_cb_stride = s->frame.linesize[1];

150 old_cr_stride = s->frame.linesize[2];

151

152 av_log(avctx, AV_LOG_DEBUG,

153 "Strides: %i, %i\n",

154 new_y_stride, new_cb_stride);

155

156 for (block_index = 0; block_index < total_blocks; block_index++) {

157 // Note that this call will make us skip the rest of the blocks

158 // if the frame prematurely ends

159 if (skip == -1)

160 skip = decode_skip_count(&gb);

161

162 if (skip) {

163 if (old_y) {

164 y[0] = old_y[0] / 4;

165 y[1] = old_y[1] / 4;

166 y[2] = old_y[old_y_stride] / 4;

167 y[3] = old_y[old_y_stride+1] / 4;

168 y_base= yb[0];

169 cb = old_cb[0] / 8;

170 cr = old_cr[0] / 8;

171 } else {

172 y_base=y[0] = y[1] = y[2] = y[3] = 0;

173 cb = cr = 16;

174 }

175 } else {

176 if (get_bits1(&gb)) {

177 static const uint8_t offset_table[] = {2, 4, 10, 20};

178 static const int8_t sign_table[64][4] =

179 { {0, 0, 0, 0},

180 {-1, 1, 0, 0},

181 {1, -1, 0, 0},

182 {-1, 0, 1, 0},

183 {-1, 1, 1, 0},

184 {0, -1, 1, 0},

185 {1, -1, 1, 0},

186 {-1, -1, 1, 0},

187 {1, 0, -1, 0},

188 {0, 1, -1, 0},

189 {1, 1, -1, 0},

190 {-1, 1, -1, 0},

191 {1, -1, -1, 0},

192 {-1, 0, 0, 1},

193 {-1, 1, 0, 1},

194 {0, -1, 0, 1},

195

196 {0, 0, 0, 0},

197 {1, -1, 0, 1},

198 {-1, -1, 0, 1},

199 {-1, 0, 1, 1},

200 {-1, 1, 1, 1},

201 {0, -1, 1, 1},

202 {1, -1, 1, 1},

203 {-1, -1, 1, 1},

204 {0, 0, -1, 1},

205 {1, 0, -1, 1},

206 {-1, 0, -1, 1},

207 {0, 1, -1, 1},

208 {1, 1, -1, 1},

209 {-1, 1, -1, 1},

210 {0, -1, -1, 1},

211 {1, -1, -1, 1},

212

213 {0, 0, 0, 0},

214 {-1, -1, -1, 1},

215 {1, 0, 0, -1},

216 {0, 1, 0, -1},

217 {1, 1, 0, -1},

218 {-1, 1, 0, -1},

219 {1, -1, 0, -1},

220 {0, 0, 1, -1},

221 {1, 0, 1, -1},

222 {-1, 0, 1, -1},

223 {0, 1, 1, -1},

224 {1, 1, 1, -1},

225 {-1, 1, 1, -1},

226 {0, -1, 1, -1},

227 {1, -1, 1, -1},

228 {-1, -1, 1, -1},

229

230 {0, 0, 0, 0},

231 {1, 0, -1, -1},

232 {0, 1, -1, -1},

233 {1, 1, -1, -1},

234 {-1, 1, -1, -1},

235 {1, -1, -1, -1} };

236 unsigned sign_selector = get_bits(&gb, 6);

237 unsigned difference_selector = get_bits(&gb, 2);

238 y_base = 2 * get_bits(&gb, 5);

239 for (i = 0; i < 4; i++) {

240 y[i] = av_clip((int)y_base + offset_table[difference_selector] *

241 sign_table[sign_selector][i], 0, 63);

242 }

243 } else if (get_bits1(&gb)) {

244 if (get_bits1(&gb)) {

245 y_base = get_bits(&gb, 6);

246 } else {

247 unsigned adjust_index = get_bits(&gb, 3);

248 static const int8_t adjust[] = {-4, -3, -2, -1, 1, 2, 3, 4};

249 y_base = (y_base + adjust[adjust_index]) & 63;

250 }

251 for (i = 0; i < 4; i++)

252 y[i] = y_base;

253 }

254

255 if (get_bits1(&gb)) {

256 if (get_bits1(&gb)) {

257 cb = get_bits(&gb, 5);

258 cr = get_bits(&gb, 5);

259 } else {

260 unsigned adjust_index = get_bits(&gb, 3);

261 static const int8_t adjust[2][8] =

262 { { 1, 1, 0, -1, -1, -1, 0, 1 },

263 { 0, 1, 1, 1, 0, -1, -1, -1 } };

264 cb = (cb + adjust[0][adjust_index]) & 31;

265 cr = (cr + adjust[1][adjust_index]) & 31;

266 }

267 }

268 }

269 *yb++= y_base;

270

271 new_y[0] = y[0] * 4;

272 new_y[1] = y[1] * 4;

273 new_y[new_y_stride] = y[2] * 4;

274 new_y[new_y_stride + 1] = y[3] * 4;

275 *new_cb = cb * 8;

276 *new_cr = cr * 8;

277

278 if (old_y)

279 old_y += 2, old_cb++, old_cr++;

280 new_y += 2, new_cb++, new_cr++;

281 row_index++;

282 if (avctx->width / 2 == row_index) {

283 row_index = 0;

284 if (old_y) {

285 old_y += old_y_stride * 2 - avctx->width;

286 old_cb += old_cb_stride - avctx->width / 2;

287 old_cr += old_cr_stride - avctx->width / 2;

288 }

289 new_y += new_y_stride * 2 - avctx->width;

290 new_cb += new_cb_stride - avctx->width / 2;

291 new_cr += new_cr_stride - avctx->width / 2;

292 }

293

294 skip--;

295 }

296

297 av_log(avctx, AV_LOG_DEBUG,

298 "Escape sizes: %i, %i\n",

299 buf_size, get_bits_count(&gb) / 8);

300

301 if (s->frame.data[0])

302 avctx->release_buffer(avctx, &s->frame);

303

304 *(AVFrame*)data = s->frame = new_frame;

305 *got_frame = 1;

306

307 return buf_size;

308 }

309

310

311 AVCodec ff_escape130_decoder = {

312 .name = "escape130",

313 .type = AVMEDIA_TYPE_VIDEO,

314 .id = AV_CODEC_ID_ESCAPE130,

315 .priv_data_size = sizeof(Escape130Context),

316 .init = escape130_decode_init,

317 .close = escape130_decode_close,

318 .decode = escape130_decode_frame,

319 .capabilities = CODEC_CAP_DR1,

320 .long_name = NULL_IF_CONFIG_SMALL("Escape 130"),

321 };

Generated on Sat May 25 2013 04:01:03 for FFmpeg by doxygen 1.8.2