GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/srtenc.c Lines: 83 145 57.2 %
Date: 2020-09-25 14:59:26 Branches: 30 84 35.7 %

Line Branch Exec Source
1
/*
2
 * SubRip subtitle encoder
3
 * Copyright (c) 2010  Aurelien Jacobs <aurel@gnuage.org>
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
#include <stdarg.h>
23
#include "avcodec.h"
24
#include "libavutil/avstring.h"
25
#include "libavutil/bprint.h"
26
#include "ass_split.h"
27
#include "ass.h"
28
29
30
#define SRT_STACK_SIZE 64
31
32
typedef struct {
33
    AVCodecContext *avctx;
34
    ASSSplitContext *ass_ctx;
35
    AVBPrint buffer;
36
    char stack[SRT_STACK_SIZE];
37
    int stack_ptr;
38
    int alignment_applied;
39
} SRTContext;
40
41
42
#ifdef __GNUC__
43
__attribute__ ((__format__ (__printf__, 2, 3)))
44
#endif
45
82
static void srt_print(SRTContext *s, const char *str, ...)
46
{
47
    va_list vargs;
48
82
    va_start(vargs, str);
49
82
    av_vbprintf(&s->buffer, str, vargs);
50
82
    va_end(vargs);
51
82
}
52
53
3
static int srt_stack_push(SRTContext *s, const char c)
54
{
55
3
    if (s->stack_ptr >= SRT_STACK_SIZE)
56
        return -1;
57
3
    s->stack[s->stack_ptr++] = c;
58
3
    return 0;
59
}
60
61
3
static char srt_stack_pop(SRTContext *s)
62
{
63
3
    if (s->stack_ptr <= 0)
64
        return 0;
65
3
    return s->stack[--s->stack_ptr];
66
}
67
68
static int srt_stack_find(SRTContext *s, const char c)
69
{
70
    int i;
71
    for (i = s->stack_ptr-1; i >= 0; i--)
72
        if (s->stack[i] == c)
73
            break;
74
    return i;
75
}
76
77
3
static void srt_close_tag(SRTContext *s, char tag)
78
{
79
3
    srt_print(s, "</%c%s>", tag, tag == 'f' ? "ont" : "");
80
3
}
81
82
3
static void srt_stack_push_pop(SRTContext *s, const char c, int close)
83
{
84
3
    if (close) {
85
3
        int i = c ? srt_stack_find(s, c) : 0;
86
3
        if (i < 0)
87
            return;
88
6
        while (s->stack_ptr != i)
89
3
            srt_close_tag(s, srt_stack_pop(s));
90
    } else if (srt_stack_push(s, c) < 0)
91
        av_log(s->avctx, AV_LOG_ERROR, "tag stack overflow\n");
92
}
93
94
3
static void srt_style_apply(SRTContext *s, const char *style)
95
{
96
3
    ASSStyle *st = ff_ass_style_get(s->ass_ctx, style);
97
3
    if (st) {
98
3
        int c = st->primary_color & 0xFFFFFF;
99

3
        if (st->font_name && strcmp(st->font_name, ASS_DEFAULT_FONT) ||
100
            st->font_size != ASS_DEFAULT_FONT_SIZE ||
101
            c != ASS_DEFAULT_COLOR) {
102
3
            srt_print(s, "<font");
103

3
            if (st->font_name && strcmp(st->font_name, ASS_DEFAULT_FONT))
104
3
                srt_print(s, " face=\"%s\"", st->font_name);
105
3
            if (st->font_size != ASS_DEFAULT_FONT_SIZE)
106
3
                srt_print(s, " size=\"%d\"", st->font_size);
107
3
            if (c != ASS_DEFAULT_COLOR)
108
                srt_print(s, " color=\"#%06x\"",
109
                          (c & 0xFF0000) >> 16 | c & 0xFF00 | (c & 0xFF) << 16);
110
3
            srt_print(s, ">");
111
3
            srt_stack_push(s, 'f');
112
        }
113
3
        if (st->bold != ASS_DEFAULT_BOLD) {
114
            srt_print(s, "<b>");
115
            srt_stack_push(s, 'b');
116
        }
117
3
        if (st->italic != ASS_DEFAULT_ITALIC) {
118
            srt_print(s, "<i>");
119
            srt_stack_push(s, 'i');
120
        }
121
3
        if (st->underline != ASS_DEFAULT_UNDERLINE) {
122
            srt_print(s, "<u>");
123
            srt_stack_push(s, 'u');
124
        }
125
3
        if (st->alignment != ASS_DEFAULT_ALIGNMENT) {
126
            srt_print(s, "{\\an%d}", st->alignment);
127
            s->alignment_applied = 1;
128
        }
129
    }
130
3
}
131
132
133
2
static av_cold int srt_encode_init(AVCodecContext *avctx)
134
{
135
2
    SRTContext *s = avctx->priv_data;
136
2
    s->avctx = avctx;
137
2
    s->ass_ctx = ff_ass_split(avctx->subtitle_header);
138
2
    av_bprint_init(&s->buffer, 0, AV_BPRINT_SIZE_UNLIMITED);
139
2
    return s->ass_ctx ? 0 : AVERROR_INVALIDDATA;
140
}
141
142
107
static void srt_text_cb(void *priv, const char *text, int len)
143
{
144
107
    SRTContext *s = priv;
145
107
    av_bprint_append_data(&s->buffer, text, len);
146
107
}
147
148
67
static void srt_new_line_cb(void *priv, int forced)
149
{
150
67
    srt_print(priv, "\r\n");
151
67
}
152
153
static void srt_style_cb(void *priv, char style, int close)
154
{
155
    srt_stack_push_pop(priv, style, close);
156
    if (!close)
157
        srt_print(priv, "<%c>", style);
158
}
159
160
static void srt_color_cb(void *priv, unsigned int color, unsigned int color_id)
161
{
162
    if (color_id > 1)
163
        return;
164
    srt_stack_push_pop(priv, 'f', color == 0xFFFFFFFF);
165
    if (color != 0xFFFFFFFF)
166
        srt_print(priv, "<font color=\"#%06x\">",
167
              (color & 0xFF0000) >> 16 | color & 0xFF00 | (color & 0xFF) << 16);
168
}
169
170
static void srt_font_name_cb(void *priv, const char *name)
171
{
172
    srt_stack_push_pop(priv, 'f', !name);
173
    if (name)
174
        srt_print(priv, "<font face=\"%s\">", name);
175
}
176
177
static void srt_font_size_cb(void *priv, int size)
178
{
179
    srt_stack_push_pop(priv, 'f', size < 0);
180
    if (size >= 0)
181
        srt_print(priv, "<font size=\"%d\">", size);
182
}
183
184
static void srt_alignment_cb(void *priv, int alignment)
185
{
186
    SRTContext *s = priv;
187
    if (!s->alignment_applied && alignment >= 0) {
188
        srt_print(s, "{\\an%d}", alignment);
189
        s->alignment_applied = 1;
190
    }
191
}
192
193
static void srt_cancel_overrides_cb(void *priv, const char *style)
194
{
195
    srt_stack_push_pop(priv, 0, 1);
196
    srt_style_apply(priv, style);
197
}
198
199
static void srt_move_cb(void *priv, int x1, int y1, int x2, int y2,
200
                        int t1, int t2)
201
{
202
    // TODO: add a AV_PKT_DATA_SUBTITLE_POSITION side data when a new subtitles
203
    // encoding API passing the AVPacket is available.
204
}
205
206
3
static void srt_end_cb(void *priv)
207
{
208
3
    srt_stack_push_pop(priv, 0, 1);
209
3
}
210
211
static const ASSCodesCallbacks srt_callbacks = {
212
    .text             = srt_text_cb,
213
    .new_line         = srt_new_line_cb,
214
    .style            = srt_style_cb,
215
    .color            = srt_color_cb,
216
    .font_name        = srt_font_name_cb,
217
    .font_size        = srt_font_size_cb,
218
    .alignment        = srt_alignment_cb,
219
    .cancel_overrides = srt_cancel_overrides_cb,
220
    .move             = srt_move_cb,
221
    .end              = srt_end_cb,
222
};
223
224
static const ASSCodesCallbacks text_callbacks = {
225
    .text             = srt_text_cb,
226
    .new_line         = srt_new_line_cb,
227
};
228
229
40
static int encode_frame(AVCodecContext *avctx,
230
                        unsigned char *buf, int bufsize, const AVSubtitle *sub,
231
                        const ASSCodesCallbacks *cb)
232
{
233
40
    SRTContext *s = avctx->priv_data;
234
    ASSDialog *dialog;
235
    int i;
236
237
40
    av_bprint_clear(&s->buffer);
238
239
80
    for (i=0; i<sub->num_rects; i++) {
240
40
        const char *ass = sub->rects[i]->ass;
241
242
40
        if (sub->rects[i]->type != SUBTITLE_ASS) {
243
            av_log(avctx, AV_LOG_ERROR, "Only SUBTITLE_ASS type supported.\n");
244
            return AVERROR(EINVAL);
245
        }
246
247
#if FF_API_ASS_TIMING
248
40
        if (!strncmp(ass, "Dialogue: ", 10)) {
249
            int num;
250
            dialog = ff_ass_split_dialog(s->ass_ctx, ass, 0, &num);
251
            for (; dialog && num--; dialog++) {
252
                s->alignment_applied = 0;
253
                if (avctx->codec_id == AV_CODEC_ID_SUBRIP)
254
                    srt_style_apply(s, dialog->style);
255
                ff_ass_split_override_codes(cb, s, dialog->text);
256
            }
257
        } else {
258
#endif
259
40
            dialog = ff_ass_split_dialog2(s->ass_ctx, ass);
260
40
            if (!dialog)
261
                return AVERROR(ENOMEM);
262
40
            s->alignment_applied = 0;
263
40
            if (avctx->codec_id == AV_CODEC_ID_SUBRIP)
264
3
                srt_style_apply(s, dialog->style);
265
40
            ff_ass_split_override_codes(cb, s, dialog->text);
266
40
            ff_ass_free_dialog(&dialog);
267
#if FF_API_ASS_TIMING
268
        }
269
#endif
270
    }
271
272
40
    if (!av_bprint_is_complete(&s->buffer))
273
        return AVERROR(ENOMEM);
274
40
    if (!s->buffer.len)
275
        return 0;
276
277
40
    if (s->buffer.len > bufsize) {
278
        av_log(avctx, AV_LOG_ERROR, "Buffer too small for ASS event.\n");
279
        return AVERROR_BUFFER_TOO_SMALL;
280
    }
281
40
    memcpy(buf, s->buffer.str, s->buffer.len);
282
283
40
    return s->buffer.len;
284
}
285
286
3
static int srt_encode_frame(AVCodecContext *avctx,
287
                               unsigned char *buf, int bufsize, const AVSubtitle *sub)
288
{
289
3
    return encode_frame(avctx, buf, bufsize, sub, &srt_callbacks);
290
}
291
292
37
static int text_encode_frame(AVCodecContext *avctx,
293
                             unsigned char *buf, int bufsize, const AVSubtitle *sub)
294
{
295
37
    return encode_frame(avctx, buf, bufsize, sub, &text_callbacks);
296
}
297
298
2
static int srt_encode_close(AVCodecContext *avctx)
299
{
300
2
    SRTContext *s = avctx->priv_data;
301
2
    ff_ass_split_free(s->ass_ctx);
302
2
    av_bprint_finalize(&s->buffer, NULL);
303
2
    return 0;
304
}
305
306
#if CONFIG_SRT_ENCODER
307
/* deprecated encoder */
308
AVCodec ff_srt_encoder = {
309
    .name           = "srt",
310
    .long_name      = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
311
    .type           = AVMEDIA_TYPE_SUBTITLE,
312
    .id             = AV_CODEC_ID_SUBRIP,
313
    .priv_data_size = sizeof(SRTContext),
314
    .init           = srt_encode_init,
315
    .encode_sub     = srt_encode_frame,
316
    .close          = srt_encode_close,
317
};
318
#endif
319
320
#if CONFIG_SUBRIP_ENCODER
321
AVCodec ff_subrip_encoder = {
322
    .name           = "subrip",
323
    .long_name      = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
324
    .type           = AVMEDIA_TYPE_SUBTITLE,
325
    .id             = AV_CODEC_ID_SUBRIP,
326
    .priv_data_size = sizeof(SRTContext),
327
    .init           = srt_encode_init,
328
    .encode_sub     = srt_encode_frame,
329
    .close          = srt_encode_close,
330
};
331
#endif
332
333
#if CONFIG_TEXT_ENCODER
334
AVCodec ff_text_encoder = {
335
    .name           = "text",
336
    .long_name      = NULL_IF_CONFIG_SMALL("Raw text subtitle"),
337
    .type           = AVMEDIA_TYPE_SUBTITLE,
338
    .id             = AV_CODEC_ID_TEXT,
339
    .priv_data_size = sizeof(SRTContext),
340
    .init           = srt_encode_init,
341
    .encode_sub     = text_encode_frame,
342
    .close          = srt_encode_close,
343
};
344
#endif