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 <stddef.h>

23 #include <limits.h>

25 #include "libavutil/common.h"

26 #include "libavutil/intreadwrite.h"

27 #include "libavutil/lzo.h"

28 #include "libavutil/imgutils.h"

29 #include "avcodec.h"

30 #include "codec_internal.h"

31 #include "decode.h"

32 #include "jpegquanttables.h"

33 #include "rtjpeg.h"

35 typedef struct NuvContext {

36 AVFrame *pic;

37 int codec_frameheader;

38 int quality;

39 int width, height;

40 unsigned int decomp_size;

41 unsigned char *decomp_buf;

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

43 RTJpegContext rtj;

44 } NuvContext;

46 /**

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

48 * @param f destination AVFrame

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

50 * @param width width of the video frame

51 * @param height height of the video frame

52 */

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

54 {

55 uint8_t *src_data[4];

56 int src_linesize[4];

57 av_image_fill_arrays(src_data, src_linesize, src,

58 f->format, width, height, 1);

59 av_image_copy(f->data, f->linesize, (const uint8_t **)src_data, src_linesize,

60 f->format, width, height);

61 }

63 /**

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

65 */

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

67 int size)

68 {

69 int i;

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

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

72 return AVERROR_INVALIDDATA;

73 }

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

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

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

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

78 return 0;

79 }

81 /**

82 * @brief set quantization tables from a quality value

83 */

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

85 {

86 int i;

87 quality = FFMAX(quality, 1);

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

89 c->lq[i] = (ff_mjpeg_std_luminance_quant_tbl[i] << 7) / quality;

90 c->cq[i] = (ff_mjpeg_std_chrominance_quant_tbl[i] << 7) / quality;

91 }

92 }

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

95 int quality)

96 {

97 NuvContext *c = avctx->priv_data;

98 int ret;

100 width = FFALIGN(width, 2);

101 height = FFALIGN(height, 2);

102 if (quality >= 0)

103 get_quant_quality(c, quality);

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

105 // also reserve space for a possible additional header

106 int64_t buf_size = height * (int64_t)width * 3 / 2

107 + FFMAX(AV_LZO_OUTPUT_PADDING, AV_INPUT_BUFFER_PADDING_SIZE)

108 + RTJPEG_HEADER_SIZE;

109 if (buf_size > INT_MAX/8)

110 return -1;

111 if ((ret = ff_set_dimensions(avctx, width, height)) < 0)

112 return ret;

113 c->width = width;

114 c->height = height;

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

116 buf_size);

117 if (!c->decomp_buf) {

118 av_log(avctx, AV_LOG_ERROR,

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

120 return AVERROR(ENOMEM);

121 }

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

123 av_frame_unref(c->pic);

124 return 1;

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

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

127

128 return 0;

129 }

130

131 static int decode_frame(AVCodecContext *avctx, AVFrame *picture,

132 int *got_frame, AVPacket *avpkt)

133 {

134 const uint8_t *buf = avpkt->data;

135 int buf_size = avpkt->size;

136 NuvContext *c = avctx->priv_data;

137 int orig_size = buf_size;

138 int keyframe, ret;

139 int size_change = 0;

140 int minsize = 0;

141 int flags = 0;

142 int result, init_frame = !avctx->frame_num;

143 enum {

144 NUV_UNCOMPRESSED = '0',

145 NUV_RTJPEG = '1',

146 NUV_RTJPEG_IN_LZO = '2',

147 NUV_LZO = '3',

148 NUV_BLACK = 'N',

149 NUV_COPY_LAST = 'L'

150 } comptype;

151

152 if (buf_size < 12) {

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

154 return AVERROR_INVALIDDATA;

155 }

156

157 // codec data (rtjpeg quant tables)

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

159 int ret;

160 // Skip the rest of the frame header.

161 buf = &buf[12];

162 buf_size -= 12;

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

164 if (ret < 0)

165 return ret;

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

167 return orig_size;

168 }

169

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

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

172 return AVERROR_INVALIDDATA;

173 }

174 comptype = buf[1];

175 switch (comptype) {

176 case NUV_RTJPEG_IN_LZO:

177 case NUV_RTJPEG:

178 keyframe = !buf[2];

179 if (c->width < 16 || c->height < 16) {

180 return AVERROR_INVALIDDATA;

181 }

182 break;

183 case NUV_COPY_LAST:

184 flags |= FF_REGET_BUFFER_FLAG_READONLY;

185 keyframe = 0;

186 break;

187 default:

188 keyframe = 1;

189 break;

190 }

191 switch (comptype) {

192 case NUV_UNCOMPRESSED:

193 minsize = c->width * c->height * 3 / 2;

194 break;

195 case NUV_RTJPEG:

196 minsize = c->width/16 * (c->height/16) * 6;

197 break;

198 case NUV_BLACK:

199 case NUV_COPY_LAST:

200 case NUV_LZO:

201 case NUV_RTJPEG_IN_LZO:

202 break;

203 default:

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

205 return AVERROR_INVALIDDATA;

206 }

207 if (buf_size < minsize / 4)

208 return AVERROR_INVALIDDATA;

209 retry:

210 // Skip the rest of the frame header.

211 buf = &buf[12];

212 buf_size -= 12;

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

214 int outlen = c->decomp_size - FFMAX(AV_INPUT_BUFFER_PADDING_SIZE, AV_LZO_OUTPUT_PADDING);

215 int inlen = buf_size;

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

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

218 return AVERROR_INVALIDDATA;

219 }

220 buf = c->decomp_buf;

221 buf_size = c->decomp_size - FFMAX(AV_INPUT_BUFFER_PADDING_SIZE, AV_LZO_OUTPUT_PADDING) - outlen;

222 memset(c->decomp_buf + buf_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

223 }

224 if (c->codec_frameheader) {

225 int w, h, q;

226 if (buf_size < RTJPEG_HEADER_SIZE) {

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

228 return AVERROR_INVALIDDATA;

229 }

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

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

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

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

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

235 return AVERROR_INVALIDDATA;

236 }

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

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

239 q = buf[10];

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

241 return result;

242 if (result) {

243 buf = avpkt->data;

244 buf_size = avpkt->size;

245 size_change = 1;

246 goto retry;

247 }

248 buf = &buf[RTJPEG_HEADER_SIZE];

249 buf_size -= RTJPEG_HEADER_SIZE;

250 }

251

252 if (size_change || keyframe) {

253 av_frame_unref(c->pic);

254 init_frame = 1;

255 }

256

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

258 return result;

259 if (init_frame) {

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

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

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

263 }

264

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

266 c->pic->key_frame = keyframe;

267 // decompress/copy/whatever data

268 switch (comptype) {

269 case NUV_LZO:

270 case NUV_UNCOMPRESSED: {

271 int height = c->height;

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

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

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

275 }

276 if(height > 0)

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

278 break;

279 }

280 case NUV_RTJPEG_IN_LZO:

281 case NUV_RTJPEG:

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

283 if (ret < 0)

284 return ret;

285 break;

286 case NUV_BLACK:

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

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

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

290 break;

291 case NUV_COPY_LAST:

292 /* nothing more to do here */

293 break;

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 const FFCodec ff_nuv_decoder = {

342 .p.name = "nuv",

343 CODEC_LONG_NAME("NuppelVideo/RTJPEG"),

344 .p.type = AVMEDIA_TYPE_VIDEO,

345 .p.id = AV_CODEC_ID_NUV,

346 .priv_data_size = sizeof(NuvContext),

347 .init = decode_init,

348 .close = decode_end,

349 FF_CODEC_DECODE_CB(decode_frame),

350 .p.capabilities = AV_CODEC_CAP_DR1,

351 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

352 };

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:42

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

NuvContext::codec_frameheader

int codec_frameheader

Definition: nuv.c:37

NuvContext::cq

uint32_t cq[64]

Definition: nuv.c:42

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:99

copy_frame

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

copy frame data from buffer to AVFrame, handling stride.

Definition: nuv.c:53

AVFrame

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

Definition: frame.h:330

uint8_t w

Definition: llviddspenc.c:38

NuvContext::width

int width

Definition: nuv.c:39

AVPacket::data

uint8_t * data

Definition: packet.h:374

codec_reinit

static int codec_reinit(AVCodecContext *avctx, int width, int height, int quality)

Definition: nuv.c:94

FFCodec

Definition: codec_internal.h:127

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:91

quality

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality

Definition: rate_distortion.txt:12

RTJPEG_HEADER_SIZE

#define RTJPEG_HEADER_SIZE

Definition: rtjpeg.h:31

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

NuvContext::quality

int quality

Definition: nuv.c:38

decode_frame

static int decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)

Definition: nuv.c:131

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:87

ff_rtjpeg_decode_init

void ff_rtjpeg_decode_init(RTJpegContext *c, int width, int height, const uint32_t *lquant, const uint32_t *cquant)

initialize an RTJpegContext, may be called multiple times

Definition: rtjpeg.c:158

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:528

width

#define width

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:306

intreadwrite.h

AV_CODEC_ID_NUV

@ AV_CODEC_ID_NUV

Definition: codec_id.h:136

NuvContext

Definition: nuv.c:35

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

get_quant

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

extract quantization tables from codec data into our context

Definition: nuv.c:66

decode.h

limits.h

AV_RL16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16

Definition: bytestream.h:94

NuvContext::decomp_buf

unsigned char * decomp_buf

Definition: nuv.c:41

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:66

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

result

and forward the result(frame or status change) to the corresponding input. If nothing is possible

NULL

#define NULL

Definition: coverity.c:32

ff_nuv_decoder

const FFCodec ff_nuv_decoder

Definition: nuv.c:341

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

ff_rtjpeg_decode_frame_yuv420

int ff_rtjpeg_decode_frame_yuv420(RTJpegContext *c, AVFrame *f, const uint8_t *buf, int buf_size)

decode one rtjpeg YUV420 frame

Definition: rtjpeg.c:106

jpegquanttables.h

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

decode_end

static av_cold int decode_end(AVCodecContext *avctx)

Definition: nuv.c:331

Definition: af_crystalizer.c:122

av_lzo1x_decode

int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen)

Decodes LZO 1x compressed data.

Definition: lzo.c:136

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

av_image_fill_arrays

int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], const uint8_t *src, enum AVPixelFormat pix_fmt, int width, int height, int align)

Setup the data pointers and linesizes based on the specified image parameters and the provided array.

Definition: imgutils.c:446

av_frame_ref

int av_frame_ref(AVFrame *dst, const AVFrame *src)

Set up a new reference to the data described by the source frame.

Definition: frame.c:344

codec_internal.h

size

int size

Definition: twinvq_data.h:10344

ff_rtjpeg_init

void ff_rtjpeg_init(RTJpegContext *c, AVCodecContext *avctx)

Definition: rtjpeg.c:170

get_quant_quality

static void get_quant_quality(NuvContext *c, int quality)

set quantization tables from a quality value

Definition: nuv.c:84

height

#define height

NuvContext::decomp_size

unsigned int decomp_size

Definition: nuv.c:40

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

Definition: cbs_h2645.c:269

AV_LZO_OUTPUT_PADDING

#define AV_LZO_OUTPUT_PADDING

Definition: lzo.h:47

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:527

common.h

ff_mjpeg_std_chrominance_quant_tbl

const uint8_t ff_mjpeg_std_chrominance_quant_tbl[64]

Definition: jpegquanttables.c:45

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:478

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

AVCodecContext::height

int height

Definition: avcodec.h:598

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:635

NuvContext::lq

uint32_t lq[64]

Definition: nuv.c:42

avcodec.h

AVCodecContext::frame_num

int64_t frame_num

Frame counter, set by libavcodec.

Definition: avcodec.h:2065

ff_reget_buffer

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

Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.

Definition: decode.c:1591

ret

Definition: filter_design.txt:187

NuvContext::pic

AVFrame * pic

Definition: nuv.c:36

lzo.h

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

ff_mjpeg_std_luminance_quant_tbl

const uint8_t ff_mjpeg_std_luminance_quant_tbl[64]

Definition: jpegquanttables.c:35

AVCodecContext

main external API structure.

Definition: avcodec.h:426

av_image_copy

void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], const uint8_t *src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)

Copy image in src_data to dst_data.

Definition: imgutils.c:422

rtjpeg.h

NuvContext::rtj

RTJpegContext rtj

Definition: nuv.c:43

init_frame

static void init_frame(FlacEncodeContext *s, int nb_samples)

Definition: flacenc.c:478

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.