FFmpeg: libavcodec/cdxl.c Source File

FFmpeg

[フレーム]

libavcodec

cdxl.c

Go to the documentation of this file.

1 /*

2 * CDXL 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 /**

23 * @file

24 * Commodore CDXL video decoder

25 * @author Paul B Mahol

26 */

28 #define UNCHECKED_BITSTREAM_READER 1

30 #include "libavutil/intreadwrite.h"

31 #include "libavutil/imgutils.h"

32 #include "avcodec.h"

33 #include "bytestream.h"

34 #include "codec_internal.h"

35 #include "get_bits.h"

36 #include "internal.h"

38 #define BIT_PLANAR 0x00

39 #define CHUNKY 0x20

40 #define BYTE_PLANAR 0x40

41 #define BIT_LINE 0x80

42 #define BYTE_LINE 0xC0

44 typedef struct CDXLVideoContext {

45 AVCodecContext *avctx;

46 int bpp;

47 int type;

48 int format;

49 int padded_bits;

50 const uint8_t *palette;

51 int palette_size;

52 const uint8_t *video;

53 int video_size;

54 uint8_t *new_video;

55 int new_video_size;

56 } CDXLVideoContext;

58 static av_cold int cdxl_decode_init(AVCodecContext *avctx)

59 {

60 CDXLVideoContext *c = avctx->priv_data;

62 c->new_video_size = 0;

63 c->avctx = avctx;

65 return 0;

66 }

68 static void import_palette(CDXLVideoContext *c, uint32_t *new_palette)

69 {

70 if (c->type == 1) {

71 for (int i = 0; i < c->palette_size / 2; i++) {

72 unsigned rgb = AV_RB16(&c->palette[i * 2]);

73 unsigned r = ((rgb >> 8) & 0xF) * 0x11;

74 unsigned g = ((rgb >> 4) & 0xF) * 0x11;

75 unsigned b = (rgb & 0xF) * 0x11;

76 AV_WN32(&new_palette[i], (0xFFU << 24) | (r << 16) | (g << 8) | b);

77 }

78 } else {

79 for (int i = 0; i < c->palette_size / 3; i++) {

80 unsigned rgb = AV_RB24(&c->palette[i * 3]);

81 AV_WN32(&new_palette[i], (0xFFU << 24) | rgb);

82 }

83 }

84 }

86 static void bitplanar2chunky(CDXLVideoContext *c, int linesize, uint8_t *out)

87 {

88 GetBitContext gb;

89 int x, y, plane;

91 if (init_get_bits8(&gb, c->video, c->video_size) < 0)

92 return;

93 for (plane = 0; plane < c->bpp; plane++) {

94 for (y = 0; y < c->avctx->height; y++) {

95 for (x = 0; x < c->avctx->width; x++)

96 out[linesize * y + x] |= get_bits1(&gb) << plane;

97 skip_bits(&gb, c->padded_bits);

98 }

99 }

100 }

101

102 static void bitline2chunky(CDXLVideoContext *c, int linesize, uint8_t *out)

103 {

104 GetBitContext gb;

105 int x, y, plane;

106

107 if (init_get_bits8(&gb, c->video, c->video_size) < 0)

108 return;

109 for (y = 0; y < c->avctx->height; y++) {

110 for (plane = 0; plane < c->bpp; plane++) {

111 for (x = 0; x < c->avctx->width; x++)

112 out[linesize * y + x] |= get_bits1(&gb) << plane;

113 skip_bits(&gb, c->padded_bits);

114 }

115 }

116 }

117

118 static void chunky2chunky(CDXLVideoContext *c, int linesize, uint8_t *out)

119 {

120 GetByteContext gb;

121 int y;

122

123 bytestream2_init(&gb, c->video, c->video_size);

124 for (y = 0; y < c->avctx->height; y++) {

125 bytestream2_get_buffer(&gb, out + linesize * y, c->avctx->width * 3);

126 }

127 }

128

129 static void import_format(CDXLVideoContext *c, int linesize, uint8_t *out)

130 {

131 memset(out, 0, linesize * c->avctx->height);

132

133 switch (c->format) {

134 case BIT_PLANAR:

135 bitplanar2chunky(c, linesize, out);

136 break;

137 case BIT_LINE:

138 bitline2chunky(c, linesize, out);

139 break;

140 case CHUNKY:

141 chunky2chunky(c, linesize, out);

142 break;

143 }

144 }

145

146 static void cdxl_decode_rgb(CDXLVideoContext *c, AVFrame *frame)

147 {

148 uint32_t *new_palette = (uint32_t *)frame->data[1];

149

150 memset(frame->data[1], 0, AVPALETTE_SIZE);

151 import_palette(c, new_palette);

152 import_format(c, frame->linesize[0], frame->data[0]);

153 }

154

155 static void cdxl_decode_raw(CDXLVideoContext *c, AVFrame *frame)

156 {

157 import_format(c, frame->linesize[0], frame->data[0]);

158 }

159

160 static void cdxl_decode_ham6(CDXLVideoContext *c, AVFrame *frame)

161 {

162 AVCodecContext *avctx = c->avctx;

163 uint32_t new_palette[16], r, g, b;

164 uint8_t *ptr, *out, index, op;

165 int x, y;

166

167 ptr = c->new_video;

168 out = frame->data[0];

169

170 import_palette(c, new_palette);

171 import_format(c, avctx->width, c->new_video);

172

173 for (y = 0; y < avctx->height; y++) {

174 r = new_palette[0] & 0xFF0000;

175 g = new_palette[0] & 0xFF00;

176 b = new_palette[0] & 0xFF;

177 for (x = 0; x < avctx->width; x++) {

178 index = *ptr++;

179 op = index >> 4;

180 index &= 15;

181 switch (op) {

182 case 0:

183 r = new_palette[index] & 0xFF0000;

184 g = new_palette[index] & 0xFF00;

185 b = new_palette[index] & 0xFF;

186 break;

187 case 1:

188 b = index * 0x11;

189 break;

190 case 2:

191 r = index * 0x11 << 16;

192 break;

193 case 3:

194 g = index * 0x11 << 8;

195 break;

196 }

197 AV_WL24(out + x * 3, r | g | b);

198 }

199 out += frame->linesize[0];

200 }

201 }

202

203 static void cdxl_decode_ham8(CDXLVideoContext *c, AVFrame *frame)

204 {

205 AVCodecContext *avctx = c->avctx;

206 uint32_t new_palette[64], r, g, b;

207 uint8_t *ptr, *out, index, op;

208 int x, y;

209

210 ptr = c->new_video;

211 out = frame->data[0];

212

213 import_palette(c, new_palette);

214 import_format(c, avctx->width, c->new_video);

215

216 for (y = 0; y < avctx->height; y++) {

217 r = new_palette[0] & 0xFF0000;

218 g = new_palette[0] & 0xFF00;

219 b = new_palette[0] & 0xFF;

220 for (x = 0; x < avctx->width; x++) {

221 index = *ptr++;

222 op = index >> 6;

223 index &= 63;

224 switch (op) {

225 case 0:

226 r = new_palette[index] & 0xFF0000;

227 g = new_palette[index] & 0xFF00;

228 b = new_palette[index] & 0xFF;

229 break;

230 case 1:

231 b = (index << 2) | (b & 3);

232 break;

233 case 2:

234 r = (index << 18) | (r & (3 << 16));

235 break;

236 case 3:

237 g = (index << 10) | (g & (3 << 8));

238 break;

239 }

240 AV_WL24(out + x * 3, r | g | b);

241 }

242 out += frame->linesize[0];

243 }

244 }

245

246 static int cdxl_decode_frame(AVCodecContext *avctx, AVFrame *p,

247 int *got_frame, AVPacket *pkt)

248 {

249 CDXLVideoContext *c = avctx->priv_data;

250 int ret, w, h, encoding, aligned_width, buf_size = pkt->size;

251 const uint8_t *buf = pkt->data;

252

253 if (buf_size < 32)

254 return AVERROR_INVALIDDATA;

255 c->type = buf[0];

256 encoding = buf[1] & 7;

257 c->format = buf[1] & 0xE0;

258 w = AV_RB16(&buf[14]);

259 h = AV_RB16(&buf[16]);

260 c->bpp = buf[19];

261 c->palette_size = AV_RB16(&buf[20]);

262 c->palette = buf + 32;

263 c->video = c->palette + c->palette_size;

264 c->video_size = buf_size - c->palette_size - 32;

265

266 if (c->type > 1)

267 return AVERROR_INVALIDDATA;

268 if (c->type == 1 && c->palette_size > 512)

269 return AVERROR_INVALIDDATA;

270 if (c->type == 0 && c->palette_size > 768)

271 return AVERROR_INVALIDDATA;

272 if (buf_size < c->palette_size + 32)

273 return AVERROR_INVALIDDATA;

274 if (c->bpp < 1)

275 return AVERROR_INVALIDDATA;

276 if (c->format != BIT_PLANAR && c->format != BIT_LINE && c->format != CHUNKY) {

277 avpriv_request_sample(avctx, "Pixel format 0x%0x", c->format);

278 return AVERROR_PATCHWELCOME;

279 }

280

281 if ((ret = ff_set_dimensions(avctx, w, h)) < 0)

282 return ret;

283

284 if (c->format == CHUNKY)

285 aligned_width = avctx->width;

286 else

287 aligned_width = FFALIGN(c->avctx->width, 16);

288 c->padded_bits = aligned_width - c->avctx->width;

289 if (c->video_size < aligned_width * avctx->height * (int64_t)c->bpp / 8)

290 return AVERROR_INVALIDDATA;

291 if (!encoding && c->palette_size && c->bpp <= 8 && c->format != CHUNKY) {

292 avctx->pix_fmt = AV_PIX_FMT_PAL8;

293 } else if (encoding == 1 && (c->bpp == 6 || c->bpp == 8) && c->format != CHUNKY) {

294 if (c->palette_size != (1 << (c->bpp - 1)))

295 return AVERROR_INVALIDDATA;

296 avctx->pix_fmt = AV_PIX_FMT_BGR24;

297 } else if (!encoding && c->bpp == 24 && c->format == CHUNKY &&

298 !c->palette_size) {

299 avctx->pix_fmt = AV_PIX_FMT_RGB24;

300 } else {

301 avpriv_request_sample(avctx, "Encoding %d, bpp %d and format 0x%x",

302 encoding, c->bpp, c->format);

303 return AVERROR_PATCHWELCOME;

304 }

305

306 if ((ret = ff_get_buffer(avctx, p, 0)) < 0)

307 return ret;

308 p->pict_type = AV_PICTURE_TYPE_I;

309 p->key_frame = 1;

310

311 if (encoding) {

312 av_fast_padded_malloc(&c->new_video, &c->new_video_size,

313 h * w + AV_INPUT_BUFFER_PADDING_SIZE);

314 if (!c->new_video)

315 return AVERROR(ENOMEM);

316 if (c->bpp == 8)

317 cdxl_decode_ham8(c, p);

318 else

319 cdxl_decode_ham6(c, p);

320 } else if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

321 cdxl_decode_rgb(c, p);

322 } else {

323 cdxl_decode_raw(c, p);

324 }

325 *got_frame = 1;

326

327 return buf_size;

328 }

329

330 static av_cold int cdxl_decode_end(AVCodecContext *avctx)

331 {

332 CDXLVideoContext *c = avctx->priv_data;

333

334 av_freep(&c->new_video);

335

336 return 0;

337 }

338

339 const FFCodec ff_cdxl_decoder = {

340 .p.name = "cdxl",

341 .p.long_name = NULL_IF_CONFIG_SMALL("Commodore CDXL video"),

342 .p.type = AVMEDIA_TYPE_VIDEO,

343 .p.id = AV_CODEC_ID_CDXL,

344 .priv_data_size = sizeof(CDXLVideoContext),

345 .init = cdxl_decode_init,

346 .close = cdxl_decode_end,

347 FF_CODEC_DECODE_CB(cdxl_decode_frame),

348 .p.capabilities = AV_CODEC_CAP_DR1,

349 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,

350 };

const char * r

Definition: vf_curves.c:116

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

out

FILE * out

Definition: movenc.c:54

CDXLVideoContext::video_size

int video_size

Definition: cdxl.c:53

GetByteContext

Definition: bytestream.h:33

CDXLVideoContext::format

int format

Definition: cdxl.c:48

AVFrame

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

Definition: frame.h:325

uint8_t w

Definition: llviddspenc.c:38

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:374

#define b

Definition: input.c:34

FFCodec

Definition: codec_internal.h:112

CDXLVideoContext::palette

const uint8_t * palette

Definition: cdxl.c:50

AV_PIX_FMT_BGR24

@ AV_PIX_FMT_BGR24

packed RGB 8:8:8, 24bpp, BGRBGR...

Definition: pixfmt.h:69

cdxl_decode_rgb

static void cdxl_decode_rgb(CDXLVideoContext *c, AVFrame *frame)

Definition: cdxl.c:146

CHUNKY

#define CHUNKY

Definition: cdxl.c:39

init

static int init

Definition: av_tx.c:47

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:467

rgb

Definition: rpzaenc.c:59

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:116

GetBitContext

Definition: get_bits.h:61

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:417

pkt

AVPacket * pkt

Definition: movenc.c:59

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:667

cdxl_decode_end

static av_cold int cdxl_decode_end(AVCodecContext *avctx)

Definition: cdxl.c:330

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:254

intreadwrite.h

const char * g

Definition: vf_curves.c:117

static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)

Perform decode operation.

Definition: anm.c:76

CDXLVideoContext

Definition: cdxl.c:44

get_bits.h

bitplanar2chunky

static void bitplanar2chunky(CDXLVideoContext *c, int linesize, uint8_t *out)

Definition: cdxl.c:86

import_format

static void import_format(CDXLVideoContext *c, int linesize, uint8_t *out)

Definition: cdxl.c:129

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

AVPALETTE_SIZE

#define AVPALETTE_SIZE

Definition: pixfmt.h:32

AV_WL24

#define AV_WL24(p, d)

Definition: intreadwrite.h:464

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:498

bytestream2_get_buffer

static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)

Definition: bytestream.h:267

CDXLVideoContext::type

int type

Definition: cdxl.c:47

index

int index

Definition: gxfenc.c:89

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

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:422

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1403

AV_PIX_FMT_RGB24

@ AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:68

bitline2chunky

static void bitline2chunky(CDXLVideoContext *c, int linesize, uint8_t *out)

Definition: cdxl.c:102

BIT_LINE

#define BIT_LINE

Definition: cdxl.c:41

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

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

codec_internal.h

AV_WN32

#define AV_WN32(p, v)

Definition: intreadwrite.h:376

cdxl_decode_raw

static void cdxl_decode_raw(CDXLVideoContext *c, AVFrame *frame)

Definition: cdxl.c:155

CDXLVideoContext::avctx

AVCodecContext * avctx

Definition: cdxl.c:45

CDXLVideoContext::bpp

int bpp

Definition: cdxl.c:46

chunky2chunky

static void chunky2chunky(CDXLVideoContext *c, int linesize, uint8_t *out)

Definition: cdxl.c:118

CDXLVideoContext::new_video

uint8_t * new_video

Definition: cdxl.c:54

import_palette

static void import_palette(CDXLVideoContext *c, uint32_t *new_palette)

Definition: cdxl.c:68

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

Definition: cbs_h2645.c:269

cdxl_decode_init

static av_cold int cdxl_decode_init(AVCodecContext *avctx)

Definition: cdxl.c:58

av_fast_padded_malloc

void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)

Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...

Definition: utils.c:48

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: codec_internal.h:31

cdxl_decode_ham6

static void cdxl_decode_ham6(CDXLVideoContext *c, AVFrame *frame)

Definition: cdxl.c:160

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:203

ff_cdxl_decoder

const FFCodec ff_cdxl_decoder

Definition: cdxl.c:339

AVCodecContext::height

int height

Definition: avcodec.h:562

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:599

avcodec.h

AV_PIX_FMT_PAL8

@ AV_PIX_FMT_PAL8

8 bits with AV_PIX_FMT_RGB32 palette

Definition: pixfmt.h:77

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

AVCodecContext

main external API structure.

Definition: avcodec.h:389

CDXLVideoContext::new_video_size

int new_video_size

Definition: cdxl.c:55

CDXLVideoContext::video

const uint8_t * video

Definition: cdxl.c:52

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

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

avpriv_request_sample

#define avpriv_request_sample(...)

Definition: tableprint_vlc.h:36

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

CDXLVideoContext::padded_bits

int padded_bits

Definition: cdxl.c:49

AVPacket

This structure stores compressed data.

Definition: packet.h:351

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:416

cdxl_decode_ham8

static void cdxl_decode_ham8(CDXLVideoContext *c, AVFrame *frame)

Definition: cdxl.c:203

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:562

bytestream.h

imgutils.h

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:137

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

Definition: vp9dsp_template.c:2038

cdxl_decode_frame

static int cdxl_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *pkt)

Definition: cdxl.c:246

AV_RB24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24

Definition: bytestream.h:97

BIT_PLANAR

#define BIT_PLANAR

Definition: cdxl.c:38

AV_CODEC_ID_CDXL

@ AV_CODEC_ID_CDXL

Definition: codec_id.h:209

CDXLVideoContext::palette_size

int palette_size

Definition: cdxl.c:51

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:98

Generated on Wed Aug 24 2022 21:41:20 for FFmpeg by doxygen 1.8.17