libkvazaar: Replace asserts with proper errors
[ffmpeg.git] / libavcodec / libkvazaar.c
1 /*
2  * libkvazaar encoder
3  *
4  * Copyright (c) 2015 Tampere University of Technology
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include <kvazaar.h>
24 #include <string.h>
25
26 #include "libavutil/avassert.h"
27 #include "libavutil/dict.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30 #include "avcodec.h"
31 #include "internal.h"
32
33 typedef struct LibkvazaarContext {
34     const AVClass *class;
35
36     const kvz_api *api;
37     kvz_encoder *encoder;
38     kvz_config *config;
39
40     char *kvz_params;
41 } LibkvazaarContext;
42
43 static av_cold int libkvazaar_init(AVCodecContext *avctx)
44 {
45     int retval = 0;
46     kvz_config *cfg = NULL;
47     kvz_encoder *enc = NULL;
48     const kvz_api *const api = kvz_api_get(8);
49
50     LibkvazaarContext *const ctx = avctx->priv_data;
51
52     // Kvazaar requires width and height to be multiples of eight.
53     if (avctx->width % 8 || avctx->height % 8) {
54         av_log(avctx, AV_LOG_ERROR, "Video dimensions are not a multiple of 8.\n");
55         retval = AVERROR_INVALIDDATA;
56         goto done;
57     }
58
59     cfg = api->config_alloc();
60     if (!cfg) {
61         av_log(avctx, AV_LOG_ERROR, "Could not allocate kvazaar config structure.\n");
62         retval = AVERROR(ENOMEM);
63         goto done;
64     }
65
66     if (!api->config_init(cfg)) {
67         av_log(avctx, AV_LOG_ERROR, "Could not initialize kvazaar config structure.\n");
68         retval = AVERROR_EXTERNAL;
69         goto done;
70     }
71
72     cfg->width = avctx->width;
73     cfg->height = avctx->height;
74     cfg->framerate =
75       (double)(avctx->time_base.num * avctx->ticks_per_frame) / avctx->time_base.den;
76     cfg->threads = avctx->thread_count;
77     cfg->target_bitrate = avctx->bit_rate;
78     cfg->vui.sar_width = avctx->sample_aspect_ratio.num;
79     cfg->vui.sar_height = avctx->sample_aspect_ratio.den;
80
81     if (ctx->kvz_params) {
82         AVDictionary *dict = NULL;
83         if (!av_dict_parse_string(&dict, ctx->kvz_params, "=", ",", 0)) {
84             AVDictionaryEntry *entry = NULL;
85             while ((entry = av_dict_get(dict, "", entry, AV_DICT_IGNORE_SUFFIX))) {
86                 if (!api->config_parse(cfg, entry->key, entry->value)) {
87                     av_log(avctx, AV_LOG_WARNING,
88                            "Invalid option: %s=%s.\n",
89                            entry->key, entry->value);
90                 }
91             }
92             av_dict_free(&dict);
93         }
94     }
95
96     enc = api->encoder_open(cfg);
97     if (!enc) {
98         av_log(avctx, AV_LOG_ERROR, "Could not open kvazaar encoder.\n");
99         retval = AVERROR_EXTERNAL;
100         goto done;
101     }
102
103     ctx->api = api;
104     ctx->encoder = enc;
105     ctx->config = cfg;
106     enc = NULL;
107     cfg = NULL;
108
109 done:
110     api->config_destroy(cfg);
111     api->encoder_close(enc);
112
113     return retval;
114 }
115
116 static av_cold int libkvazaar_close(AVCodecContext *avctx)
117 {
118     LibkvazaarContext *ctx = avctx->priv_data;
119     if (!ctx->api) return 0;
120
121     if (ctx->encoder) {
122         ctx->api->encoder_close(ctx->encoder);
123         ctx->encoder = NULL;
124     }
125
126     if (ctx->config) {
127         ctx->api->config_destroy(ctx->config);
128         ctx->config = NULL;
129     }
130
131     return 0;
132 }
133
134 static int libkvazaar_encode(AVCodecContext *avctx,
135                              AVPacket *avpkt,
136                              const AVFrame *frame,
137                              int *got_packet_ptr)
138 {
139     int retval = 0;
140     kvz_picture *img_in = NULL;
141
142     kvz_data_chunk *data_out = NULL;
143     uint32_t len_out = 0;
144     kvz_frame_info frame_info;
145
146     LibkvazaarContext *ctx = avctx->priv_data;
147
148     *got_packet_ptr = 0;
149
150     if (frame) {
151         int i = 0;
152
153         if (frame->width != ctx->config->width ||
154                 frame->height != ctx->config->height) {
155             av_log(avctx, AV_LOG_ERROR,
156                    "Changing video dimensions during encoding is not supported. "
157                    "(changed from %dx%d to %dx%d)\n",
158                    ctx->config->width, ctx->config->height,
159                    frame->width, frame->height);
160             retval = AVERROR_INVALIDDATA;
161             goto done;
162         }
163
164         if (frame->format != avctx->pix_fmt) {
165             av_log(avctx, AV_LOG_ERROR,
166                    "Changing pixel format during encoding is not supported. "
167                    "(changed from %s to %s)\n",
168                    av_get_pix_fmt_name(avctx->pix_fmt),
169                    av_get_pix_fmt_name(frame->format));
170             retval = AVERROR_INVALIDDATA;
171             goto done;
172         }
173
174         // Allocate input picture for kvazaar.
175         img_in = ctx->api->picture_alloc(frame->width, frame->height);
176         if (!img_in) {
177             av_log(avctx, AV_LOG_ERROR, "Failed to allocate picture.\n");
178             retval = AVERROR(ENOMEM);
179             goto done;
180         }
181
182         // Copy pixels from frame to img_in.
183         for (i = 0; i < 3; ++i) {
184             uint8_t *dst = img_in->data[i];
185             uint8_t *src = frame->data[i];
186             int width = (i == 0) ? frame->width : (frame->width / 2);
187             int height = (i == 0) ? frame->height : (frame->height / 2);
188             int y = 0;
189             for (y = 0; y < height; ++y) {
190                 memcpy(dst, src, width);
191                 src += frame->linesize[i];
192                 dst += width;
193             }
194         }
195     }
196
197     if (!ctx->api->encoder_encode(ctx->encoder, img_in,
198                                   &data_out, &len_out,
199                                   NULL, NULL,
200                                   &frame_info)) {
201         av_log(avctx, AV_LOG_ERROR, "Failed to encode frame.\n");
202         retval = AVERROR_EXTERNAL;
203         goto done;
204     }
205
206     if (data_out) {
207         kvz_data_chunk *chunk = NULL;
208         uint64_t written = 0;
209
210         retval = ff_alloc_packet(avpkt, len_out);
211         if (retval < 0) {
212             av_log(avctx, AV_LOG_ERROR, "Failed to allocate output packet.\n");
213             goto done;
214         }
215
216         for (chunk = data_out; chunk != NULL; chunk = chunk->next) {
217             av_assert0(written + chunk->len <= len_out);
218             memcpy(avpkt->data + written, chunk->data, chunk->len);
219             written += chunk->len;
220         }
221         *got_packet_ptr = 1;
222
223         ctx->api->chunk_free(data_out);
224         data_out = NULL;
225
226         avpkt->flags = 0;
227         // IRAP VCL NAL unit types span the range
228         // [BLA_W_LP (16), RSV_IRAP_VCL23 (23)].
229         if (frame_info.nal_unit_type >= KVZ_NAL_BLA_W_LP &&
230                 frame_info.nal_unit_type <= KVZ_NAL_RSV_IRAP_VCL23) {
231             avpkt->flags |= AV_PKT_FLAG_KEY;
232         }
233     }
234
235 done:
236     ctx->api->picture_free(img_in);
237     ctx->api->chunk_free(data_out);
238     return retval;
239 }
240
241 static const enum AVPixelFormat pix_fmts[] = {
242     AV_PIX_FMT_YUV420P,
243     AV_PIX_FMT_NONE
244 };
245
246 static const AVOption options[] = {
247     { "kvazaar-params", "Set kvazaar parameters as a comma-separated list of name=value pairs.",
248       offsetof(LibkvazaarContext, kvz_params), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0,
249       AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
250     { NULL },
251 };
252
253 static const AVClass class = {
254     .class_name = "libkvazaar",
255     .item_name  = av_default_item_name,
256     .option     = options,
257     .version    = LIBAVUTIL_VERSION_INT,
258 };
259
260 static const AVCodecDefault defaults[] = {
261     { "b", "0" },
262     { NULL },
263 };
264
265 AVCodec ff_libkvazaar_encoder = {
266     .name             = "libkvazaar",
267     .long_name        = NULL_IF_CONFIG_SMALL("libkvazaar H.265 / HEVC"),
268     .type             = AVMEDIA_TYPE_VIDEO,
269     .id               = AV_CODEC_ID_HEVC,
270     .capabilities     = AV_CODEC_CAP_DELAY,
271     .pix_fmts         = pix_fmts,
272
273     .priv_class       = &class,
274     .priv_data_size   = sizeof(LibkvazaarContext),
275     .defaults         = defaults,
276
277     .init             = libkvazaar_init,
278     .encode2          = libkvazaar_encode,
279     .close            = libkvazaar_close,
280 };