FFmpeg: libavcodec/nuv.c Source File

FFmpeg

[フレーム]

libavcodec

nuv.c

Go to the documentation of this file.

1 /*

2 * NuppelVideo 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 <stdio.h>

23 #include <stdlib.h>

24 #include <limits.h>

26 #include "libavutil/bswap.h"

27 #include "libavutil/common.h"

28 #include "libavutil/intreadwrite.h"

29 #include "libavutil/lzo.h"

30 #include "libavutil/imgutils.h"

31 #include "avcodec.h"

32 #include "idctdsp.h"

33 #include "internal.h"

34 #include "rtjpeg.h"

36 typedef struct NuvContext {

37 AVFrame *pic;

38 int codec_frameheader;

39 int quality;

40 int width, height;

41 unsigned int decomp_size;

42 unsigned char *decomp_buf;

43 uint32_t lq[64], cq[64];

44 RTJpegContext rtj;

45 } NuvContext;

47 static const uint8_t fallback_lquant[] = {

48 16, 11, 10, 16, 24, 40, 51, 61,

49 12, 12, 14, 19, 26, 58, 60, 55,

50 14, 13, 16, 24, 40, 57, 69, 56,

51 14, 17, 22, 29, 51, 87, 80, 62,

52 18, 22, 37, 56, 68, 109, 103, 77,

53 24, 35, 55, 64, 81, 104, 113, 92,

54 49, 64, 78, 87, 103, 121, 120, 101,

55 72, 92, 95, 98, 112, 100, 103, 99

56 };

58 static const uint8_t fallback_cquant[] = {

59 17, 18, 24, 47, 99, 99, 99, 99,

60 18, 21, 26, 66, 99, 99, 99, 99,

61 24, 26, 56, 99, 99, 99, 99, 99,

62 47, 66, 99, 99, 99, 99, 99, 99,

63 99, 99, 99, 99, 99, 99, 99, 99,

64 99, 99, 99, 99, 99, 99, 99, 99,

65 99, 99, 99, 99, 99, 99, 99, 99,

66 99, 99, 99, 99, 99, 99, 99, 99

67 };

69 /**

70 * @brief copy frame data from buffer to AVFrame, handling stride.

71 * @param f destination AVFrame

72 * @param src source buffer, does not use any line-stride

73 * @param width width of the video frame

74 * @param height height of the video frame

75 */

76 static void copy_frame(AVFrame *f, const uint8_t *src, int width, int height)

77 {

78 AVPicture pic;

79 avpicture_fill(&pic, src, AV_PIX_FMT_YUV420P, width, height);

80 av_picture_copy((AVPicture *)f, &pic, AV_PIX_FMT_YUV420P, width, height);

81 }

83 /**

84 * @brief extract quantization tables from codec data into our context

85 */

86 static int get_quant(AVCodecContext *avctx, NuvContext *c, const uint8_t *buf,

87 int size)

88 {

89 int i;

90 if (size < 2 * 64 * 4) {

91 av_log(avctx, AV_LOG_ERROR, "insufficient rtjpeg quant data\n");

92 return AVERROR_INVALIDDATA;

93 }

94 for (i = 0; i < 64; i++, buf += 4)

95 c->lq[i] = AV_RL32(buf);

96 for (i = 0; i < 64; i++, buf += 4)

97 c->cq[i] = AV_RL32(buf);

98 return 0;

99 }

100

101 /**

102 * @brief set quantization tables from a quality value

103 */

104 static void get_quant_quality(NuvContext *c, int quality)

105 {

106 int i;

107 quality = FFMAX(quality, 1);

108 for (i = 0; i < 64; i++) {

109 c->lq[i] = (fallback_lquant[i] << 7) / quality;

110 c->cq[i] = (fallback_cquant[i] << 7) / quality;

111 }

112 }

113

114 static int codec_reinit(AVCodecContext *avctx, int width, int height,

115 int quality)

116 {

117 NuvContext *c = avctx->priv_data;

118 int ret;

119

120 width = FFALIGN(width, 2);

121 height = FFALIGN(height, 2);

122 if (quality >= 0)

123 get_quant_quality(c, quality);

124 if (width != c->width || height != c->height) {

125 // also reserve space for a possible additional header

126 int buf_size = height * width * 3 / 2

127 + FFMAX(AV_LZO_OUTPUT_PADDING, FF_INPUT_BUFFER_PADDING_SIZE)

128 + RTJPEG_HEADER_SIZE;

129 if (buf_size > INT_MAX/8)

130 return -1;

131 if ((ret = av_image_check_size(height, width, 0, avctx)) < 0)

132 return ret;

133 avctx->width = c->width = width;

134 avctx->height = c->height = height;

135 av_fast_malloc(&c->decomp_buf, &c->decomp_size,

136 buf_size);

137 if (!c->decomp_buf) {

138 av_log(avctx, AV_LOG_ERROR,

139 "Can't allocate decompression buffer.\n");

140 return AVERROR(ENOMEM);

141 }

142 ff_rtjpeg_decode_init(&c->rtj, c->width, c->height, c->lq, c->cq);

143 av_frame_unref(c->pic);

144 return 1;

145 } else if (quality != c->quality)

146 ff_rtjpeg_decode_init(&c->rtj, c->width, c->height, c->lq, c->cq);

147

148 return 0;

149 }

150

151 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

152 AVPacket *avpkt)

153 {

154 const uint8_t *buf = avpkt->data;

155 int buf_size = avpkt->size;

156 NuvContext *c = avctx->priv_data;

157 AVFrame *picture = data;

158 int orig_size = buf_size;

159 int keyframe, ret;

160 int size_change = 0;

161 int result, init_frame = !avctx->frame_number;

162 enum {

163 NUV_UNCOMPRESSED = '0',

164 NUV_RTJPEG = '1',

165 NUV_RTJPEG_IN_LZO = '2',

166 NUV_LZO = '3',

167 NUV_BLACK = 'N',

168 NUV_COPY_LAST = 'L'

169 } comptype;

170

171 if (buf_size < 12) {

172 av_log(avctx, AV_LOG_ERROR, "coded frame too small\n");

173 return AVERROR_INVALIDDATA;

174 }

175

176 // codec data (rtjpeg quant tables)

177 if (buf[0] == 'D' && buf[1] == 'R') {

178 int ret;

179 // skip rest of the frameheader.

180 buf = &buf[12];

181 buf_size -= 12;

182 ret = get_quant(avctx, c, buf, buf_size);

183 if (ret < 0)

184 return ret;

185 ff_rtjpeg_decode_init(&c->rtj, c->width, c->height, c->lq, c->cq);

186 return orig_size;

187 }

188

189 if (buf_size < 12 || buf[0] != 'V') {

190 av_log(avctx, AV_LOG_ERROR, "not a nuv video frame\n");

191 return AVERROR_INVALIDDATA;

192 }

193 comptype = buf[1];

194 switch (comptype) {

195 case NUV_RTJPEG_IN_LZO:

196 case NUV_RTJPEG:

197 keyframe = !buf[2];

198 break;

199 case NUV_COPY_LAST:

200 keyframe = 0;

201 break;

202 default:

203 keyframe = 1;

204 break;

205 }

206 retry:

207 // skip rest of the frameheader.

208 buf = &buf[12];

209 buf_size -= 12;

210 if (comptype == NUV_RTJPEG_IN_LZO || comptype == NUV_LZO) {

211 int outlen = c->decomp_size - FFMAX(FF_INPUT_BUFFER_PADDING_SIZE, AV_LZO_OUTPUT_PADDING);

212 int inlen = buf_size;

213 if (av_lzo1x_decode(c->decomp_buf, &outlen, buf, &inlen)) {

214 av_log(avctx, AV_LOG_ERROR, "error during lzo decompression\n");

215 return AVERROR_INVALIDDATA;

216 }

217 buf = c->decomp_buf;

218 buf_size = c->decomp_size - FFMAX(FF_INPUT_BUFFER_PADDING_SIZE, AV_LZO_OUTPUT_PADDING) - outlen;

219 memset(c->decomp_buf + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

220 }

221 if (c->codec_frameheader) {

222 int w, h, q;

223 if (buf_size < RTJPEG_HEADER_SIZE) {

224 av_log(avctx, AV_LOG_ERROR, "Too small NUV video frame\n");

225 return AVERROR_INVALIDDATA;

226 }

227 // There seem to exist two variants of this header: one starts with 'V'

228 // and 5 bytes unknown, the other matches current MythTV and is 4 bytes size,

229 // 1 byte header size (== 12), 1 byte version (== 0)

230 if (buf[0] != 'V' && AV_RL16(&buf[4]) != 0x000c) {

231 av_log(avctx, AV_LOG_ERROR, "Unknown secondary frame header (wrong codec_tag?)\n");

232 return AVERROR_INVALIDDATA;

233 }

234 w = AV_RL16(&buf[6]);

235 h = AV_RL16(&buf[8]);

236 q = buf[10];

237 if ((result = codec_reinit(avctx, w, h, q)) < 0)

238 return result;

239 if (result) {

240 buf = avpkt->data;

241 buf_size = avpkt->size;

242 size_change = 1;

243 goto retry;

244 }

245 buf = &buf[RTJPEG_HEADER_SIZE];

246 buf_size -= RTJPEG_HEADER_SIZE;

247 }

248

249 if (size_change || keyframe) {

250 av_frame_unref(c->pic);

251 init_frame = 1;

252 }

253

254 if ((result = ff_reget_buffer(avctx, c->pic)) < 0)

255 return result;

256 if (init_frame) {

257 memset(c->pic->data[0], 0, avctx->height * c->pic->linesize[0]);

258 memset(c->pic->data[1], 0x80, avctx->height * c->pic->linesize[1] / 2);

259 memset(c->pic->data[2], 0x80, avctx->height * c->pic->linesize[2] / 2);

260 }

261

262 c->pic->pict_type = keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

263 c->pic->key_frame = keyframe;

264 // decompress/copy/whatever data

265 switch (comptype) {

266 case NUV_LZO:

267 case NUV_UNCOMPRESSED: {

268 int height = c->height;

269 if (buf_size < c->width * height * 3 / 2) {

270 av_log(avctx, AV_LOG_ERROR, "uncompressed frame too short\n");

271 height = buf_size / c->width / 3 * 2;

272 }

273 if(height > 0)

274 copy_frame(c->pic, buf, c->width, height);

275 break;

276 }

277 case NUV_RTJPEG_IN_LZO:

278 case NUV_RTJPEG:

279 ret = ff_rtjpeg_decode_frame_yuv420(&c->rtj, c->pic, buf, buf_size);

280 if (ret < 0)

281 return ret;

282 break;

283 case NUV_BLACK:

284 memset(c->pic->data[0], 0, c->width * c->height);

285 memset(c->pic->data[1], 128, c->width * c->height / 4);

286 memset(c->pic->data[2], 128, c->width * c->height / 4);

287 break;

288 case NUV_COPY_LAST:

289 /* nothing more to do here */

290 break;

291 default:

292 av_log(avctx, AV_LOG_ERROR, "unknown compression\n");

293 return AVERROR_INVALIDDATA;

294 }

295

296 if ((result = av_frame_ref(picture, c->pic)) < 0)

297 return result;

298

299 *got_frame = 1;

300 return orig_size;

301 }

302

303 static av_cold int decode_init(AVCodecContext *avctx)

304 {

305 NuvContext *c = avctx->priv_data;

306 int ret;

307

308 c->pic = av_frame_alloc();

309 if (!c->pic)

310 return AVERROR(ENOMEM);

311

312 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

313 c->decomp_buf = NULL;

314 c->quality = -1;

315 c->width = 0;

316 c->height = 0;

317

318 c->codec_frameheader = avctx->codec_tag == MKTAG('R', 'J', 'P', 'G');

319

320 if (avctx->extradata_size)

321 get_quant(avctx, c, avctx->extradata, avctx->extradata_size);

322

323 ff_rtjpeg_init(&c->rtj, avctx);

324

325 if ((ret = codec_reinit(avctx, avctx->width, avctx->height, -1)) < 0)

326 return ret;

327

328 return 0;

329 }

330

331 static av_cold int decode_end(AVCodecContext *avctx)

332 {

333 NuvContext *c = avctx->priv_data;

334

335 av_freep(&c->decomp_buf);

336 av_frame_free(&c->pic);

337

338 return 0;

339 }

340

341 AVCodec ff_nuv_decoder = {

342 .name = "nuv",

343 .long_name = NULL_IF_CONFIG_SMALL("NuppelVideo/RTJPEG"),

344 .type = AVMEDIA_TYPE_VIDEO,

345 .id = AV_CODEC_ID_NUV,

346 .priv_data_size = sizeof(NuvContext),

347 .init = decode_init,

348 .close = decode_end,

349 .decode = decode_frame,

350 .capabilities = CODEC_CAP_DR1,

351 };

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