FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/hdrenc.c
Date: 2022-10-02 18:56:10
Exec Total Coverage
Lines: 0 85 0.0%
Branches: 0 50 0.0%

Line Branch Exec Source
1 /*
2 * Radiance HDR image format
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "libavutil/imgutils.h"
22 #include "avcodec.h"
23 #include "bytestream.h"
24 #include "codec_internal.h"
25 #include "encode.h"
26
27 typedef struct HDREncContext {
28 uint8_t *scanline;
29 } HDREncContext;
30
31 static av_cold int hdr_encode_init(AVCodecContext *avctx)
32 {
33 HDREncContext *s = avctx->priv_data;
34
35 s->scanline = av_calloc(avctx->width * 4, sizeof(*s->scanline));
36 if (!s->scanline)
37 return AVERROR(ENOMEM);
38
39 return 0;
40 }
41
42 static av_cold int hdr_encode_close(AVCodecContext *avctx)
43 {
44 HDREncContext *s = avctx->priv_data;
45
46 av_freep(&s->scanline);
47
48 return 0;
49 }
50
51 static void bytestream_put_str(uint8_t **buf, const char *const line)
52 {
53 bytestream_put_buffer(buf, line, strlen(line));
54 }
55
56 static void float2rgbe(uint8_t *rgbe, float red, float green, float blue)
57 {
58 float v;
59 int e;
60
61 v = FFMAX3(red, green, blue);
62
63 if (v < 1e-32f) {
64 rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0;
65 } else {
66 v = frexpf(v, &e) * 256.f / v;
67
68 rgbe[0] = av_clip_uint8(red * v);
69 rgbe[1] = av_clip_uint8(green * v);
70 rgbe[2] = av_clip_uint8(blue * v);
71 rgbe[3] = av_clip_uint8(e + 128);
72 }
73 }
74
75 static void rle(uint8_t **buffer, const uint8_t *data, int width)
76 {
77 #define MIN_RLE 4
78 int cur = 0;
79
80 while (cur < width) {
81 int run_count = 0, old_run_count = 0;
82 int beg_run = cur;
83 uint8_t buf[2];
84
85 while (run_count < MIN_RLE && beg_run < width) {
86 beg_run += run_count;
87 old_run_count = run_count;
88 run_count = 1;
89 while ((beg_run + run_count < width) && (run_count < 127) &&
90 (data[beg_run * 4] == data[(beg_run + run_count) * 4]))
91 run_count++;
92 }
93
94 if ((old_run_count > 1) && (old_run_count == beg_run - cur)) {
95 buf[0] = 128 + old_run_count;
96 buf[1] = data[cur * 4];
97 bytestream_put_buffer(buffer, buf, sizeof(buf));
98 cur = beg_run;
99 }
100
101 while (cur < beg_run) {
102 int nonrun_count = FFMIN(128, beg_run - cur);
103 buf[0] = nonrun_count;
104 bytestream_put_byte(buffer, buf[0]);
105 for (int n = 0; n < nonrun_count; n++)
106 bytestream_put_byte(buffer, data[(cur + n) * 4]);
107 cur += nonrun_count;
108 }
109
110 if (run_count >= MIN_RLE) {
111 buf[0] = 128 + run_count;
112 buf[1] = data[beg_run * 4];
113 bytestream_put_buffer(buffer, buf, sizeof(buf));
114 cur += run_count;
115 }
116 }
117 }
118
119 static int hdr_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
120 const AVFrame *frame, int *got_packet)
121 {
122 HDREncContext *s = avctx->priv_data;
123 int64_t packet_size;
124 uint8_t *buf;
125 int ret;
126
127 packet_size = avctx->width * avctx->height * 4LL + 1024LL;
128 if ((ret = ff_get_encode_buffer(avctx, pkt, packet_size, 0)) < 0)
129 return ret;
130
131 buf = pkt->data;
132 bytestream_put_str(&buf, "#?RADIANCE\n");
133 bytestream_put_str(&buf, "SOFTWARE=lavc\n");
134 ret = snprintf(buf, 32, "PIXASPECT=%f\n", av_q2d(av_inv_q(avctx->sample_aspect_ratio)));
135 if (ret > 0)
136 buf += ret;
137 bytestream_put_str(&buf, "FORMAT=32-bit_rle_rgbe\n\n");
138 ret = snprintf(buf, 32, "-Y %d +X %d\n", avctx->height, avctx->width);
139 if (ret > 0)
140 buf += ret;
141
142 for (int y = 0; y < avctx->height; y++) {
143 const float *red = (const float *)(frame->data[2] + y * frame->linesize[2]);
144 const float *green = (const float *)(frame->data[0] + y * frame->linesize[0]);
145 const float *blue = (const float *)(frame->data[1] + y * frame->linesize[1]);
146
147 if (avctx->width < 8 || avctx->width > 0x7fff) {
148 for (int x = 0; x < avctx->width; x++) {
149 float2rgbe(buf, red[x], green[x], blue[x]);
150 buf += 4;
151 }
152 } else {
153 bytestream_put_byte(&buf, 2);
154 bytestream_put_byte(&buf, 2);
155 bytestream_put_byte(&buf, avctx->width >> 8);
156 bytestream_put_byte(&buf, avctx->width & 0xFF);
157
158 for (int x = 0; x < avctx->width; x++)
159 float2rgbe(s->scanline + 4 * x, red[x], green[x], blue[x]);
160 for (int p = 0; p < 4; p++)
161 rle(&buf, s->scanline + p, avctx->width);
162 }
163 }
164
165 pkt->flags |= AV_PKT_FLAG_KEY;
166
167 av_shrink_packet(pkt, buf - pkt->data);
168
169 *got_packet = 1;
170
171 return 0;
172 }
173
174 const FFCodec ff_hdr_encoder = {
175 .p.name = "hdr",
176 CODEC_LONG_NAME("HDR (Radiance RGBE format) image"),
177 .priv_data_size = sizeof(HDREncContext),
178 .p.type = AVMEDIA_TYPE_VIDEO,
179 .p.id = AV_CODEC_ID_RADIANCE_HDR,
180 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
181 .init = hdr_encode_init,
182 FF_CODEC_ENCODE_CB(hdr_encode_frame),
183 .close = hdr_encode_close,
184 .p.pix_fmts = (const enum AVPixelFormat[]){
185 AV_PIX_FMT_GBRPF32,
186 AV_PIX_FMT_NONE
187 },
188 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
189 };
190