GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/a64multienc.c Lines: 0 169 0.0 %
Date: 2021-04-19 06:27:07 Branches: 0 108 0.0 %

Line Branch Exec Source
1
/*
2
 * a64 video encoder - multicolor modes
3
 * Copyright (c) 2009 Tobias Bindhammer
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
 */
21
22
/**
23
 * @file
24
 * a64 video encoder - multicolor modes
25
 */
26
27
#include "a64colors.h"
28
#include "a64tables.h"
29
#include "elbg.h"
30
#include "internal.h"
31
#include "libavutil/avassert.h"
32
#include "libavutil/common.h"
33
#include "libavutil/intreadwrite.h"
34
35
#define DITHERSTEPS   8
36
#define CHARSET_CHARS 256
37
#define INTERLACED    1
38
#define CROP_SCREENS  1
39
40
#define C64XRES 320
41
#define C64YRES 200
42
43
typedef struct A64Context {
44
    /* variables for multicolor modes */
45
    AVLFG randctx;
46
    int mc_lifetime;
47
    int mc_use_5col;
48
    unsigned mc_frame_counter;
49
    int *mc_meta_charset;
50
    int *mc_charmap;
51
    int *mc_best_cb;
52
    int mc_luma_vals[5];
53
    uint8_t *mc_charset;
54
    uint8_t *mc_colram;
55
    uint8_t *mc_palette;
56
    int mc_pal_size;
57
58
    /* pts of the next packet that will be output */
59
    int64_t next_pts;
60
} A64Context;
61
62
/* gray gradient */
63
static const uint8_t mc_colors[5]={0x0,0xb,0xc,0xf,0x1};
64
65
/* other possible gradients - to be tested */
66
//static const uint8_t mc_colors[5]={0x0,0x8,0xa,0xf,0x7};
67
//static const uint8_t mc_colors[5]={0x0,0x9,0x8,0xa,0x3};
68
69
static void to_meta_with_crop(AVCodecContext *avctx,
70
                              const AVFrame *p, int *dest)
71
{
72
    int blockx, blocky, x, y;
73
    int luma = 0;
74
    int height = FFMIN(avctx->height, C64YRES);
75
    int width  = FFMIN(avctx->width , C64XRES);
76
    uint8_t *src = p->data[0];
77
78
    for (blocky = 0; blocky < C64YRES; blocky += 8) {
79
        for (blockx = 0; blockx < C64XRES; blockx += 8) {
80
            for (y = blocky; y < blocky + 8 && y < C64YRES; y++) {
81
                for (x = blockx; x < blockx + 8 && x < C64XRES; x += 2) {
82
                    if(x < width && y < height) {
83
                        if (x + 1 < width) {
84
                            /* build average over 2 pixels */
85
                            luma = (src[(x + 0 + y * p->linesize[0])] +
86
                                    src[(x + 1 + y * p->linesize[0])]) / 2;
87
                        } else {
88
                            luma = src[(x + y * p->linesize[0])];
89
                        }
90
                        /* write blocks as linear data now so they are suitable for elbg */
91
                        dest[0] = luma;
92
                    }
93
                    dest++;
94
                }
95
            }
96
        }
97
    }
98
}
99
100
static void render_charset(AVCodecContext *avctx, uint8_t *charset,
101
                           uint8_t *colrammap)
102
{
103
    A64Context *c = avctx->priv_data;
104
    uint8_t row1, row2;
105
    int charpos, x, y;
106
    int a, b;
107
    uint8_t pix;
108
    int lowdiff, highdiff;
109
    int *best_cb = c->mc_best_cb;
110
    uint8_t index1[256];
111
    uint8_t index2[256];
112
    uint8_t dither[256];
113
    int i;
114
    int distance;
115
116
    /* Generate lookup-tables for dither and index before looping.
117
     * This code relies on c->mc_luma_vals[c->mc_pal_size - 1] being
118
     * the maximum of all the mc_luma_vals values and on the minimum
119
     * being zero; this ensures that dither is properly initialized. */
120
    i = 0;
121
    for (a=0; a < 256; a++) {
122
        if(i < c->mc_pal_size -1 && a == c->mc_luma_vals[i + 1]) {
123
            distance = c->mc_luma_vals[i + 1] - c->mc_luma_vals[i];
124
            for(b = 0; b <= distance; b++) {
125
                  dither[c->mc_luma_vals[i] + b] = b * (DITHERSTEPS - 1) / distance;
126
            }
127
            i++;
128
        }
129
        if(i >= c->mc_pal_size - 1) dither[a] = 0;
130
        index1[a] = i;
131
        index2[a] = FFMIN(i + 1, c->mc_pal_size - 1);
132
    }
133
134
    /* and render charset */
135
    for (charpos = 0; charpos < CHARSET_CHARS; charpos++) {
136
        lowdiff  = 0;
137
        highdiff = 0;
138
        for (y = 0; y < 8; y++) {
139
            row1 = 0; row2 = 0;
140
            for (x = 0; x < 4; x++) {
141
                pix = best_cb[y * 4 + x];
142
143
                /* accumulate error for brightest/darkest color */
144
                if (index1[pix] >= 3)
145
                    highdiff += pix - c->mc_luma_vals[3];
146
                if (index1[pix] < 1)
147
                    lowdiff += c->mc_luma_vals[1] - pix;
148
149
                row1 <<= 2;
150
151
                if (INTERLACED) {
152
                    row2 <<= 2;
153
                    if (interlaced_dither_patterns[dither[pix]][(y & 3) * 2 + 0][x & 3])
154
                        row1 |= 3-(index2[pix] & 3);
155
                    else
156
                        row1 |= 3-(index1[pix] & 3);
157
158
                    if (interlaced_dither_patterns[dither[pix]][(y & 3) * 2 + 1][x & 3])
159
                        row2 |= 3-(index2[pix] & 3);
160
                    else
161
                        row2 |= 3-(index1[pix] & 3);
162
                }
163
                else {
164
                    if (multi_dither_patterns[dither[pix]][(y & 3)][x & 3])
165
                        row1 |= 3-(index2[pix] & 3);
166
                    else
167
                        row1 |= 3-(index1[pix] & 3);
168
                }
169
            }
170
            charset[y+0x000] = row1;
171
            if (INTERLACED) charset[y+0x800] = row2;
172
        }
173
        /* do we need to adjust pixels? */
174
        if (highdiff > 0 && lowdiff > 0 && c->mc_use_5col) {
175
            if (lowdiff > highdiff) {
176
                for (x = 0; x < 32; x++)
177
                    best_cb[x] = FFMIN(c->mc_luma_vals[3], best_cb[x]);
178
            } else {
179
                for (x = 0; x < 32; x++)
180
                    best_cb[x] = FFMAX(c->mc_luma_vals[1], best_cb[x]);
181
            }
182
            charpos--;          /* redo now adjusted char */
183
        /* no adjustment needed, all fine */
184
        } else {
185
            /* advance pointers */
186
            best_cb += 32;
187
            charset += 8;
188
189
            /* remember colorram value */
190
            colrammap[charpos] = (highdiff > 0);
191
        }
192
    }
193
}
194
195
static av_cold int a64multi_close_encoder(AVCodecContext *avctx)
196
{
197
    A64Context *c = avctx->priv_data;
198
    av_freep(&c->mc_meta_charset);
199
    av_freep(&c->mc_best_cb);
200
    av_freep(&c->mc_charset);
201
    av_freep(&c->mc_charmap);
202
    av_freep(&c->mc_colram);
203
    return 0;
204
}
205
206
static av_cold int a64multi_encode_init(AVCodecContext *avctx)
207
{
208
    A64Context *c = avctx->priv_data;
209
    int a;
210
    av_lfg_init(&c->randctx, 1);
211
212
    if (avctx->global_quality < 1) {
213
        c->mc_lifetime = 4;
214
    } else {
215
        c->mc_lifetime = avctx->global_quality /= FF_QP2LAMBDA;
216
    }
217
218
    av_log(avctx, AV_LOG_INFO, "charset lifetime set to %d frame(s)\n", c->mc_lifetime);
219
220
    c->mc_frame_counter = 0;
221
    c->mc_use_5col      = avctx->codec->id == AV_CODEC_ID_A64_MULTI5;
222
    c->mc_pal_size      = 4 + c->mc_use_5col;
223
224
    /* precalc luma values for later use */
225
    for (a = 0; a < c->mc_pal_size; a++) {
226
        c->mc_luma_vals[a]=a64_palette[mc_colors[a]][0] * 0.30 +
227
                           a64_palette[mc_colors[a]][1] * 0.59 +
228
                           a64_palette[mc_colors[a]][2] * 0.11;
229
    }
230
231
    if (!(c->mc_meta_charset = av_mallocz_array(c->mc_lifetime, 32000 * sizeof(int))) ||
232
       !(c->mc_best_cb       = av_malloc(CHARSET_CHARS * 32 * sizeof(int)))     ||
233
       !(c->mc_charmap       = av_mallocz_array(c->mc_lifetime, 1000 * sizeof(int))) ||
234
       !(c->mc_colram        = av_mallocz(CHARSET_CHARS * sizeof(uint8_t)))     ||
235
       !(c->mc_charset       = av_malloc(0x800 * (INTERLACED+1) * sizeof(uint8_t)))) {
236
        av_log(avctx, AV_LOG_ERROR, "Failed to allocate buffer memory.\n");
237
        return AVERROR(ENOMEM);
238
    }
239
240
    /* set up extradata */
241
    if (!(avctx->extradata = av_mallocz(8 * 4 + AV_INPUT_BUFFER_PADDING_SIZE))) {
242
        av_log(avctx, AV_LOG_ERROR, "Failed to allocate memory for extradata.\n");
243
        return AVERROR(ENOMEM);
244
    }
245
    avctx->extradata_size = 8 * 4;
246
    AV_WB32(avctx->extradata, c->mc_lifetime);
247
    AV_WB32(avctx->extradata + 16, INTERLACED);
248
249
    if (!avctx->codec_tag)
250
         avctx->codec_tag = AV_RL32("a64m");
251
252
    c->next_pts = AV_NOPTS_VALUE;
253
254
    return 0;
255
}
256
257
static void a64_compress_colram(unsigned char *buf, int *charmap, uint8_t *colram)
258
{
259
    int a;
260
    uint8_t temp;
261
    /* only needs to be done in 5col mode */
262
    /* XXX could be squeezed to 0x80 bytes */
263
    for (a = 0; a < 256; a++) {
264
        temp  = colram[charmap[a + 0x000]] << 0;
265
        temp |= colram[charmap[a + 0x100]] << 1;
266
        temp |= colram[charmap[a + 0x200]] << 2;
267
        if (a < 0xe8) temp |= colram[charmap[a + 0x300]] << 3;
268
        buf[a] = temp << 2;
269
    }
270
}
271
272
static int a64multi_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
273
                                 const AVFrame *p, int *got_packet)
274
{
275
    A64Context *c = avctx->priv_data;
276
277
    int frame;
278
    int x, y;
279
    int b_height;
280
    int b_width;
281
282
    int req_size, ret;
283
    uint8_t *buf = NULL;
284
285
    int *charmap     = c->mc_charmap;
286
    uint8_t *colram  = c->mc_colram;
287
    uint8_t *charset = c->mc_charset;
288
    int *meta        = c->mc_meta_charset;
289
    int *best_cb     = c->mc_best_cb;
290
291
    int charset_size = 0x800 * (INTERLACED + 1);
292
    int colram_size  = 0x100 * c->mc_use_5col;
293
    int screen_size;
294
295
    if(CROP_SCREENS) {
296
        b_height = FFMIN(avctx->height,C64YRES) >> 3;
297
        b_width  = FFMIN(avctx->width ,C64XRES) >> 3;
298
        screen_size = b_width * b_height;
299
    } else {
300
        b_height = C64YRES >> 3;
301
        b_width  = C64XRES >> 3;
302
        screen_size = 0x400;
303
    }
304
305
    /* no data, means end encoding asap */
306
    if (!p) {
307
        /* all done, end encoding */
308
        if (!c->mc_lifetime) return 0;
309
        /* no more frames in queue, prepare to flush remaining frames */
310
        if (!c->mc_frame_counter) {
311
            c->mc_lifetime = 0;
312
        }
313
        /* still frames in queue so limit lifetime to remaining frames */
314
        else c->mc_lifetime = c->mc_frame_counter;
315
    /* still new data available */
316
    } else {
317
        /* fill up mc_meta_charset with data until lifetime exceeds */
318
        if (c->mc_frame_counter < c->mc_lifetime) {
319
            to_meta_with_crop(avctx, p, meta + 32000 * c->mc_frame_counter);
320
            c->mc_frame_counter++;
321
            if (c->next_pts == AV_NOPTS_VALUE)
322
                c->next_pts = p->pts;
323
            /* lifetime is not reached so wait for next frame first */
324
            return 0;
325
        }
326
    }
327
328
    /* lifetime reached so now convert X frames at once */
329
    if (c->mc_frame_counter == c->mc_lifetime) {
330
        req_size = 0;
331
        /* any frames to encode? */
332
        if (c->mc_lifetime) {
333
            int alloc_size = charset_size + c->mc_lifetime*(screen_size + colram_size);
334
            if ((ret = ff_alloc_packet2(avctx, pkt, alloc_size, 0)) < 0)
335
                return ret;
336
            buf = pkt->data;
337
338
            /* calc optimal new charset + charmaps */
339
            ret = avpriv_init_elbg(meta, 32, 1000 * c->mc_lifetime, best_cb,
340
                               CHARSET_CHARS, 50, charmap, &c->randctx);
341
            if (ret < 0)
342
                return ret;
343
            ret = avpriv_do_elbg(meta, 32, 1000 * c->mc_lifetime, best_cb,
344
                             CHARSET_CHARS, 50, charmap, &c->randctx);
345
            if (ret < 0)
346
                return ret;
347
348
            /* create colorram map and a c64 readable charset */
349
            render_charset(avctx, charset, colram);
350
351
            /* copy charset to buf */
352
            memcpy(buf, charset, charset_size);
353
354
            /* advance pointers */
355
            buf      += charset_size;
356
            req_size += charset_size;
357
        }
358
359
        /* write x frames to buf */
360
        for (frame = 0; frame < c->mc_lifetime; frame++) {
361
            /* copy charmap to buf. buf is uchar*, charmap is int*, so no memcpy here, sorry */
362
            for (y = 0; y < b_height; y++) {
363
                for (x = 0; x < b_width; x++) {
364
                    buf[y * b_width + x] = charmap[y * b_width + x];
365
                }
366
            }
367
            /* advance pointers */
368
            buf += screen_size;
369
            req_size += screen_size;
370
371
            /* compress and copy colram to buf */
372
            if (c->mc_use_5col) {
373
                a64_compress_colram(buf, charmap, colram);
374
                /* advance pointers */
375
                buf += colram_size;
376
                req_size += colram_size;
377
            }
378
379
            /* advance to next charmap */
380
            charmap += 1000;
381
        }
382
383
        AV_WB32(avctx->extradata + 4,  c->mc_frame_counter);
384
        AV_WB32(avctx->extradata + 8,  charset_size);
385
        AV_WB32(avctx->extradata + 12, screen_size + colram_size);
386
387
        /* reset counter */
388
        c->mc_frame_counter = 0;
389
390
        pkt->pts = pkt->dts = c->next_pts;
391
        c->next_pts         = AV_NOPTS_VALUE;
392
393
        av_assert0(pkt->size >= req_size);
394
        pkt->size   = req_size;
395
        pkt->flags |= AV_PKT_FLAG_KEY;
396
        *got_packet = !!req_size;
397
    }
398
    return 0;
399
}
400
401
#if CONFIG_A64MULTI_ENCODER
402
AVCodec ff_a64multi_encoder = {
403
    .name           = "a64multi",
404
    .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64"),
405
    .type           = AVMEDIA_TYPE_VIDEO,
406
    .id             = AV_CODEC_ID_A64_MULTI,
407
    .priv_data_size = sizeof(A64Context),
408
    .init           = a64multi_encode_init,
409
    .encode2        = a64multi_encode_frame,
410
    .close          = a64multi_close_encoder,
411
    .pix_fmts       = (const enum AVPixelFormat[]) {AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE},
412
    .capabilities   = AV_CODEC_CAP_DELAY,
413
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,
414
};
415
#endif
416
#if CONFIG_A64MULTI5_ENCODER
417
AVCodec ff_a64multi5_encoder = {
418
    .name           = "a64multi5",
419
    .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64, extended with 5th color (colram)"),
420
    .type           = AVMEDIA_TYPE_VIDEO,
421
    .id             = AV_CODEC_ID_A64_MULTI5,
422
    .priv_data_size = sizeof(A64Context),
423
    .init           = a64multi_encode_init,
424
    .encode2        = a64multi_encode_frame,
425
    .close          = a64multi_close_encoder,
426
    .pix_fmts       = (const enum AVPixelFormat[]) {AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE},
427
    .capabilities   = AV_CODEC_CAP_DELAY,
428
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,
429
};
430
#endif