FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/webvttenc.c	Lines:	79	102	77.5 %
Date:	2021-01-20 23:14:43	Branches:	31	50	62.0 %


/*
 * WebVTT subtitle encoder
 * Copyright (c) 2010  Aurelien Jacobs <aurel@gnuage.org>
 * Copyright (c) 2014  Aman Gupta <ffmpeg@tmm1.net>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdarg.h>
#include "avcodec.h"
#include "libavutil/avstring.h"
#include "libavutil/bprint.h"
#include "ass_split.h"
#include "ass.h"

#define WEBVTT_STACK_SIZE 64
typedef struct {
    AVCodecContext *avctx;
    ASSSplitContext *ass_ctx;
    AVBPrint buffer;
    unsigned timestamp_end;
    int count;
    char stack[WEBVTT_STACK_SIZE];
    int stack_ptr;
} WebVTTContext;

#ifdef __GNUC__
__attribute__ ((__format__ (__printf__, 2, 3)))
#endif
static void webvtt_print(WebVTTContext *s, const char *str, ...)
{
    va_list vargs;
    va_start(vargs, str);
    av_vbprintf(&s->buffer, str, vargs);
    va_end(vargs);
}

static int webvtt_stack_push(WebVTTContext *s, const char c)
{
    if (s->stack_ptr >= WEBVTT_STACK_SIZE)
        return -1;
    s->stack[s->stack_ptr++] = c;
    return 0;
}

static char webvtt_stack_pop(WebVTTContext *s)
{
    if (s->stack_ptr <= 0)
        return 0;
    return s->stack[--s->stack_ptr];
}

static int webvtt_stack_find(WebVTTContext *s, const char c)
{
    int i;
    for (i = s->stack_ptr-1; i >= 0; i--)
        if (s->stack[i] == c)
            break;
    return i;
}

static void webvtt_close_tag(WebVTTContext *s, char tag)
{
    webvtt_print(s, "</%c>", tag);
}

static void webvtt_stack_push_pop(WebVTTContext *s, const char c, int close)
{
    if (close) {
        int i = c ? webvtt_stack_find(s, c) : 0;
        if (i < 0)
            return;
        while (s->stack_ptr != i)
            webvtt_close_tag(s, webvtt_stack_pop(s));
    } else if (webvtt_stack_push(s, c) < 0)
        av_log(s->avctx, AV_LOG_ERROR, "tag stack overflow\n");
}

static void webvtt_style_apply(WebVTTContext *s, const char *style)
{
    ASSStyle *st = ff_ass_style_get(s->ass_ctx, style);
    if (st) {
        if (st->bold != ASS_DEFAULT_BOLD) {
            webvtt_print(s, "<b>");
            webvtt_stack_push(s, 'b');
        }
        if (st->italic != ASS_DEFAULT_ITALIC) {
            webvtt_print(s, "<i>");
            webvtt_stack_push(s, 'i');
        }
        if (st->underline != ASS_DEFAULT_UNDERLINE) {
            webvtt_print(s, "<u>");
            webvtt_stack_push(s, 'u');
        }
    }
}

static void webvtt_text_cb(void *priv, const char *text, int len)
{
    WebVTTContext *s = priv;
    av_bprint_append_data(&s->buffer, text, len);
}

static void webvtt_new_line_cb(void *priv, int forced)
{
    webvtt_print(priv, "\n");
}

static void webvtt_style_cb(void *priv, char style, int close)
{
    if (style == 's') // strikethrough unsupported
        return;

    webvtt_stack_push_pop(priv, style, close);
    if (!close)
        webvtt_print(priv, "<%c>", style);
}

static void webvtt_cancel_overrides_cb(void *priv, const char *style)
{
    webvtt_stack_push_pop(priv, 0, 1);
    webvtt_style_apply(priv, style);
}

static void webvtt_end_cb(void *priv)
{
    webvtt_stack_push_pop(priv, 0, 1);
}

static const ASSCodesCallbacks webvtt_callbacks = {
    .text             = webvtt_text_cb,
    .new_line         = webvtt_new_line_cb,
    .style            = webvtt_style_cb,
    .color            = NULL,
    .font_name        = NULL,
    .font_size        = NULL,
    .alignment        = NULL,
    .cancel_overrides = webvtt_cancel_overrides_cb,
    .move             = NULL,
    .end              = webvtt_end_cb,
};

static int webvtt_encode_frame(AVCodecContext *avctx,
                               unsigned char *buf, int bufsize, const AVSubtitle *sub)
{
    WebVTTContext *s = avctx->priv_data;
    ASSDialog *dialog;
    int i;

    av_bprint_clear(&s->buffer);

    for (i=0; i<sub->num_rects; i++) {
        const char *ass = sub->rects[i]->ass;

        if (sub->rects[i]->type != SUBTITLE_ASS) {
            av_log(avctx, AV_LOG_ERROR, "Only SUBTITLE_ASS type supported.\n");
            return AVERROR(EINVAL);
        }

#if FF_API_ASS_TIMING
        if (!strncmp(ass, "Dialogue: ", 10)) {
            int num;
            dialog = ff_ass_split_dialog(s->ass_ctx, ass, 0, &num);
            // TODO reindent
        for (; dialog && num--; dialog++) {
            webvtt_style_apply(s, dialog->style);
            ff_ass_split_override_codes(&webvtt_callbacks, s, dialog->text);
        }
        } else {
#endif
            dialog = ff_ass_split_dialog2(s->ass_ctx, ass);
            if (!dialog)
                return AVERROR(ENOMEM);
            webvtt_style_apply(s, dialog->style);
            ff_ass_split_override_codes(&webvtt_callbacks, s, dialog->text);
            ff_ass_free_dialog(&dialog);
#if FF_API_ASS_TIMING
        }
#endif
    }

    if (!av_bprint_is_complete(&s->buffer))
        return AVERROR(ENOMEM);
    if (!s->buffer.len)
        return 0;

    if (s->buffer.len > bufsize) {
        av_log(avctx, AV_LOG_ERROR, "Buffer too small for ASS event.\n");
        return AVERROR_BUFFER_TOO_SMALL;
    }
    memcpy(buf, s->buffer.str, s->buffer.len);

    return s->buffer.len;
}

static int webvtt_encode_close(AVCodecContext *avctx)
{
    WebVTTContext *s = avctx->priv_data;
    ff_ass_split_free(s->ass_ctx);
    av_bprint_finalize(&s->buffer, NULL);
    return 0;
}

static av_cold int webvtt_encode_init(AVCodecContext *avctx)
{
    WebVTTContext *s = avctx->priv_data;
    s->avctx = avctx;
    s->ass_ctx = ff_ass_split(avctx->subtitle_header);
    av_bprint_init(&s->buffer, 0, AV_BPRINT_SIZE_UNLIMITED);
    return s->ass_ctx ? 0 : AVERROR_INVALIDDATA;
}

AVCodec ff_webvtt_encoder = {
    .name           = "webvtt",
    .long_name      = NULL_IF_CONFIG_SMALL("WebVTT subtitle"),
    .type           = AVMEDIA_TYPE_SUBTITLE,
    .id             = AV_CODEC_ID_WEBVTT,
    .priv_data_size = sizeof(WebVTTContext),
    .init           = webvtt_encode_init,
    .encode_sub     = webvtt_encode_frame,
    .close          = webvtt_encode_close,
};


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			/*
2			* WebVTT subtitle encoder
3			* Copyright (c) 2010 Aurelien Jacobs <aurel@gnuage.org>
4			* Copyright (c) 2014 Aman Gupta <ffmpeg@tmm1.net>
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 <stdarg.h>
24			#include "avcodec.h"
25			#include "libavutil/avstring.h"
26			#include "libavutil/bprint.h"
27			#include "ass_split.h"
28			#include "ass.h"
29
30			#define WEBVTT_STACK_SIZE 64
31			typedef struct {
32			AVCodecContext *avctx;
33			ASSSplitContext *ass_ctx;
34			AVBPrint buffer;
35			unsigned timestamp_end;
36			int count;
37			char stack[WEBVTT_STACK_SIZE];
38			int stack_ptr;
39			} WebVTTContext;
40
41			#ifdef __GNUC__
42			__attribute__ ((__format__ (__printf__, 2, 3)))
43			#endif
44		85	static void webvtt_print(WebVTTContext s, const char str, ...)
45			{
46			va_list vargs;
47		85	va_start(vargs, str);
48		85	av_vbprintf(&s->buffer, str, vargs);
49		85	va_end(vargs);
50		85	}
51
52		10	static int webvtt_stack_push(WebVTTContext *s, const char c)
53			{
54	✗✓	10	if (s->stack_ptr >= WEBVTT_STACK_SIZE)
55			return -1;
56		10	s->stack[s->stack_ptr++] = c;
57		10	return 0;
58			}
59
60		10	static char webvtt_stack_pop(WebVTTContext *s)
61			{
62	✗✓	10	if (s->stack_ptr <= 0)
63			return 0;
64		10	return s->stack[--s->stack_ptr];
65			}
66
67		11	static int webvtt_stack_find(WebVTTContext *s, const char c)
68			{
69			int i;
70	✓✓	11	for (i = s->stack_ptr-1; i >= 0; i--)
71	✓✗	10	if (s->stack[i] == c)
72		10	break;
73		11	return i;
74			}
75
76		10	static void webvtt_close_tag(WebVTTContext *s, char tag)
77			{
78		10	webvtt_print(s, "</%c>", tag);
79		10	}
80
81		58	static void webvtt_stack_push_pop(WebVTTContext *s, const char c, int close)
82			{
83	✓✓	58	if (close) {
84	✓✓	48	int i = c ? webvtt_stack_find(s, c) : 0;
85	✓✓	48	if (i < 0)
86		1	return;
87	✓✓	57	while (s->stack_ptr != i)
88		10	webvtt_close_tag(s, webvtt_stack_pop(s));
89	✗✓	10	} else if (webvtt_stack_push(s, c) < 0)
90			av_log(s->avctx, AV_LOG_ERROR, "tag stack overflow\n");
91			}
92
93		37	static void webvtt_style_apply(WebVTTContext s, const char style)
94			{
95		37	ASSStyle *st = ff_ass_style_get(s->ass_ctx, style);
96	✓✗	37	if (st) {
97	✗✓	37	if (st->bold != ASS_DEFAULT_BOLD) {
98			webvtt_print(s, "<b>");
99			webvtt_stack_push(s, 'b');
100			}
101	✗✓	37	if (st->italic != ASS_DEFAULT_ITALIC) {
102			webvtt_print(s, "<i>");
103			webvtt_stack_push(s, 'i');
104			}
105	✗✓	37	if (st->underline != ASS_DEFAULT_UNDERLINE) {
106			webvtt_print(s, "<u>");
107			webvtt_stack_push(s, 'u');
108			}
109			}
110		37	}
111
112		102	static void webvtt_text_cb(void priv, const char text, int len)
113			{
114		102	WebVTTContext *s = priv;
115		102	av_bprint_append_data(&s->buffer, text, len);
116		102	}
117
118		65	static void webvtt_new_line_cb(void *priv, int forced)
119			{
120		65	webvtt_print(priv, "\n");
121		65	}
122
123		28	static void webvtt_style_cb(void *priv, char style, int close)
124			{
125	✓✓	28	if (style == 's') // strikethrough unsupported
126		7	return;
127
128		21	webvtt_stack_push_pop(priv, style, close);
129	✓✓	21	if (!close)
130		10	webvtt_print(priv, "<%c>", style);
131			}
132
133			static void webvtt_cancel_overrides_cb(void priv, const char style)
134			{
135			webvtt_stack_push_pop(priv, 0, 1);
136			webvtt_style_apply(priv, style);
137			}
138
139		37	static void webvtt_end_cb(void *priv)
140			{
141		37	webvtt_stack_push_pop(priv, 0, 1);
142		37	}
143
144			static const ASSCodesCallbacks webvtt_callbacks = {
145			.text = webvtt_text_cb,
146			.new_line = webvtt_new_line_cb,
147			.style = webvtt_style_cb,
148			.color = NULL,
149			.font_name = NULL,
150			.font_size = NULL,
151			.alignment = NULL,
152			.cancel_overrides = webvtt_cancel_overrides_cb,
153			.move = NULL,
154			.end = webvtt_end_cb,
155			};
156
157		37	static int webvtt_encode_frame(AVCodecContext *avctx,
158			unsigned char buf, int bufsize, const AVSubtitle sub)
159			{
160		37	WebVTTContext *s = avctx->priv_data;
161			ASSDialog *dialog;
162			int i;
163
164		37	av_bprint_clear(&s->buffer);
165
166	✓✓	74	for (i=0; i<sub->num_rects; i++) {
167		37	const char *ass = sub->rects[i]->ass;
168
169	✗✓	37	if (sub->rects[i]->type != SUBTITLE_ASS) {
170			av_log(avctx, AV_LOG_ERROR, "Only SUBTITLE_ASS type supported.\n");
171			return AVERROR(EINVAL);
172			}
173
174			#if FF_API_ASS_TIMING
175	✗✓	37	if (!strncmp(ass, "Dialogue: ", 10)) {
176			int num;
177			dialog = ff_ass_split_dialog(s->ass_ctx, ass, 0, &num);
178			// TODO reindent
179			for (; dialog && num--; dialog++) {
180			webvtt_style_apply(s, dialog->style);
181			ff_ass_split_override_codes(&webvtt_callbacks, s, dialog->text);
182			}
183			} else {
184			#endif
185		37	dialog = ff_ass_split_dialog2(s->ass_ctx, ass);
186	✗✓	37	if (!dialog)
187			return AVERROR(ENOMEM);
188		37	webvtt_style_apply(s, dialog->style);
189		37	ff_ass_split_override_codes(&webvtt_callbacks, s, dialog->text);
190		37	ff_ass_free_dialog(&dialog);
191			#if FF_API_ASS_TIMING
192			}
193			#endif
194			}
195
196	✗✓	37	if (!av_bprint_is_complete(&s->buffer))
197			return AVERROR(ENOMEM);
198	✗✓	37	if (!s->buffer.len)
199			return 0;
200
201	✗✓	37	if (s->buffer.len > bufsize) {
202			av_log(avctx, AV_LOG_ERROR, "Buffer too small for ASS event.\n");
203			return AVERROR_BUFFER_TOO_SMALL;
204			}
205		37	memcpy(buf, s->buffer.str, s->buffer.len);
206
207		37	return s->buffer.len;
208			}
209
210		1	static int webvtt_encode_close(AVCodecContext *avctx)
211			{
212		1	WebVTTContext *s = avctx->priv_data;
213		1	ff_ass_split_free(s->ass_ctx);
214		1	av_bprint_finalize(&s->buffer, NULL);
215		1	return 0;
216			}
217
218		1	static av_cold int webvtt_encode_init(AVCodecContext *avctx)
219			{
220		1	WebVTTContext *s = avctx->priv_data;
221		1	s->avctx = avctx;
222		1	s->ass_ctx = ff_ass_split(avctx->subtitle_header);
223		1	av_bprint_init(&s->buffer, 0, AV_BPRINT_SIZE_UNLIMITED);
224	✓✗	1	return s->ass_ctx ? 0 : AVERROR_INVALIDDATA;
225			}
226
227			AVCodec ff_webvtt_encoder = {
228			.name = "webvtt",
229			.long_name = NULL_IF_CONFIG_SMALL("WebVTT subtitle"),
230			.type = AVMEDIA_TYPE_SUBTITLE,
231			.id = AV_CODEC_ID_WEBVTT,
232			.priv_data_size = sizeof(WebVTTContext),
233			.init = webvtt_encode_init,
234			.encode_sub = webvtt_encode_frame,
235			.close = webvtt_encode_close,
236			};