FFmpeg: libavcodec/mdec.c Source File

FFmpeg

[フレーム]

libavcodec

mdec.c

Go to the documentation of this file.

1 /*

2 * Sony PlayStation MDEC (Motion DECoder)

4 *

5 * based upon code from Sebastian Jedruszkiewicz <elf@frogger.rules.pl>

6 *

7 * This file is part of FFmpeg.

8 *

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

10 * 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 * FFmpeg is distributed in the hope that it will be useful,

15 * 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 * License along with FFmpeg; if not, write to the Free Software

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

22 */

24 /**

25 * @file

26 * Sony PlayStation MDEC (Motion DECoder)

27 * This is very similar to intra-only MPEG-1.

28 */

30 #include "avcodec.h"

31 #include "blockdsp.h"

32 #include "bswapdsp.h"

33 #include "idctdsp.h"

34 #include "mpegvideo.h"

35 #include "mpeg12.h"

36 #include "thread.h"

38 typedef struct MDECContext {

39 AVCodecContext *avctx;

40 BlockDSPContext bdsp;

41 BswapDSPContext bbdsp;

42 IDCTDSPContext idsp;

43 ThreadFrame frame;

44 GetBitContext gb;

45 ScanTable scantable;

46 int version;

47 int qscale;

48 int last_dc[3];

49 int mb_width;

50 int mb_height;

51 int mb_x, mb_y;

52 DECLARE_ALIGNED(16, int16_t, block)[6][64];

53 uint8_t *bitstream_buffer;

54 unsigned int bitstream_buffer_size;

55 int block_last_index[6];

56 } MDECContext;

58 //very similar to MPEG-1

59 static inline int mdec_decode_block_intra(MDECContext *a, int16_t *block, int n)

60 {

61 int level, diff, i, j, run;

62 int component;

63 RLTable *rl = &ff_rl_mpeg1;

64 uint8_t * const scantable = a->scantable.permutated;

65 const uint16_t *quant_matrix = ff_mpeg1_default_intra_matrix;

66 const int qscale = a->qscale;

68 /* DC coefficient */

69 if (a->version == 2) {

70 block[0] = 2 * get_sbits(&a->gb, 10) + 1024;

71 } else {

72 component = (n <= 3 ? 0 : n - 4 + 1);

73 diff = decode_dc(&a->gb, component);

74 if (diff >= 0xffff)

75 return AVERROR_INVALIDDATA;

76 a->last_dc[component] += diff;

77 block[0] = a->last_dc[component] << 3;

78 }

80 i = 0;

81 {

82 OPEN_READER(re, &a->gb);

83 /* now quantify & encode AC coefficients */

84 for (;;) {

85 UPDATE_CACHE(re, &a->gb);

86 GET_RL_VLC(level, run, re, &a->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);

88 if (level == 127) {

89 break;

90 } else if (level != 0) {

91 i += run;

92 j = scantable[i];

93 level = (level * qscale * quant_matrix[j]) >> 3;

94 level = (level ^ SHOW_SBITS(re, &a->gb, 1)) - SHOW_SBITS(re, &a->gb, 1);

95 LAST_SKIP_BITS(re, &a->gb, 1);

96 } else {

97 /* escape */

98 run = SHOW_UBITS(re, &a->gb, 6)+1; LAST_SKIP_BITS(re, &a->gb, 6);

99 UPDATE_CACHE(re, &a->gb);

100 level = SHOW_SBITS(re, &a->gb, 10); SKIP_BITS(re, &a->gb, 10);

101 i += run;

102 j = scantable[i];

103 if (level < 0) {

104 level = -level;

105 level = (level * qscale * quant_matrix[j]) >> 3;

106 level = (level - 1) | 1;

107 level = -level;

108 } else {

109 level = (level * qscale * quant_matrix[j]) >> 3;

110 level = (level - 1) | 1;

111 }

112 }

113 if (i > 63) {

114 av_log(a->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", a->mb_x, a->mb_y);

115 return AVERROR_INVALIDDATA;

116 }

117

118 block[j] = level;

119 }

120 CLOSE_READER(re, &a->gb);

121 }

122 a->block_last_index[n] = i;

123 return 0;

124 }

125

126 static inline int decode_mb(MDECContext *a, int16_t block[6][64])

127 {

128 int i, ret;

129 static const int block_index[6] = { 5, 4, 0, 1, 2, 3 };

130

131 a->bdsp.clear_blocks(block[0]);

132

133 for (i = 0; i < 6; i++) {

134 if ((ret = mdec_decode_block_intra(a, block[block_index[i]],

135 block_index[i])) < 0)

136 return ret;

137 if (get_bits_left(&a->gb) < 0)

138 return AVERROR_INVALIDDATA;

139 }

140 return 0;

141 }

142

143 static inline void idct_put(MDECContext *a, AVFrame *frame, int mb_x, int mb_y)

144 {

145 int16_t (*block)[64] = a->block;

146 int linesize = frame->linesize[0];

147

148 uint8_t *dest_y = frame->data[0] + (mb_y * 16* linesize ) + mb_x * 16;

149 uint8_t *dest_cb = frame->data[1] + (mb_y * 8 * frame->linesize[1]) + mb_x * 8;

150 uint8_t *dest_cr = frame->data[2] + (mb_y * 8 * frame->linesize[2]) + mb_x * 8;

151

152 a->idsp.idct_put(dest_y, linesize, block[0]);

153 a->idsp.idct_put(dest_y + 8, linesize, block[1]);

154 a->idsp.idct_put(dest_y + 8 * linesize, linesize, block[2]);

155 a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);

156

157 if (!(a->avctx->flags & CODEC_FLAG_GRAY)) {

158 a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);

159 a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);

160 }

161 }

162

163 static int decode_frame(AVCodecContext *avctx,

164 void *data, int *got_frame,

165 AVPacket *avpkt)

166 {

167 MDECContext * const a = avctx->priv_data;

168 const uint8_t *buf = avpkt->data;

169 int buf_size = avpkt->size;

170 ThreadFrame frame = { .f = data };

171 int ret;

172

173 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

174 return ret;

175 frame.f->pict_type = AV_PICTURE_TYPE_I;

176 frame.f->key_frame = 1;

177

178 av_fast_padded_malloc(&a->bitstream_buffer, &a->bitstream_buffer_size, buf_size);

179 if (!a->bitstream_buffer)

180 return AVERROR(ENOMEM);

181 a->bbdsp.bswap16_buf((uint16_t *)a->bitstream_buffer, (uint16_t *)buf, (buf_size + 1) / 2);

182 if ((ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size)) < 0)

183 return ret;

184

185 /* skip over 4 preamble bytes in stream (typically 0xXX 0xXX 0x00 0x38) */

186 skip_bits(&a->gb, 32);

187

188 a->qscale = get_bits(&a->gb, 16);

189 a->version = get_bits(&a->gb, 16);

190

191 a->last_dc[0] = a->last_dc[1] = a->last_dc[2] = 128;

192

193 for (a->mb_x = 0; a->mb_x < a->mb_width; a->mb_x++) {

194 for (a->mb_y = 0; a->mb_y < a->mb_height; a->mb_y++) {

195 if ((ret = decode_mb(a, a->block)) < 0)

196 return ret;

197

198 idct_put(a, frame.f, a->mb_x, a->mb_y);

199 }

200 }

201

202 *got_frame = 1;

203

204 return (get_bits_count(&a->gb) + 31) / 32 * 4;

205 }

206

207 static av_cold int decode_init(AVCodecContext *avctx)

208 {

209 MDECContext * const a = avctx->priv_data;

210

211 a->mb_width = (avctx->coded_width + 15) / 16;

212 a->mb_height = (avctx->coded_height + 15) / 16;

213

214 a->avctx = avctx;

215

216 ff_blockdsp_init(&a->bdsp, avctx);

217 ff_bswapdsp_init(&a->bbdsp);

218 ff_idctdsp_init(&a->idsp, avctx);

219 ff_mpeg12_init_vlcs();

220 ff_init_scantable(a->idsp.idct_permutation, &a->scantable,

221 ff_zigzag_direct);

222

223 if (avctx->idct_algo == FF_IDCT_AUTO)

224 avctx->idct_algo = FF_IDCT_SIMPLE;

225 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;

226 avctx->color_range = AVCOL_RANGE_JPEG;

227

228 return 0;

229 }

230

231 static av_cold int decode_init_thread_copy(AVCodecContext *avctx)

232 {

233 MDECContext * const a = avctx->priv_data;

234

235 a->avctx = avctx;

236

237 return 0;

238 }

239

240 static av_cold int decode_end(AVCodecContext *avctx)

241 {

242 MDECContext * const a = avctx->priv_data;

243

244 av_freep(&a->bitstream_buffer);

245 a->bitstream_buffer_size = 0;

246

247 return 0;

248 }

249

250 AVCodec ff_mdec_decoder = {

251 .name = "mdec",

252 .long_name = NULL_IF_CONFIG_SMALL("Sony PlayStation MDEC (Motion DECoder)"),

253 .type = AVMEDIA_TYPE_VIDEO,

254 .id = AV_CODEC_ID_MDEC,

255 .priv_data_size = sizeof(MDECContext),

256 .init = decode_init,

257 .close = decode_end,

258 .decode = decode_frame,

259 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,

260 .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy)

261 };

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