Head

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/jacosubdec.c	Lines:	63	81	77.8 %
Date:	2020-01-27 20:17:04	Branches:	51	70	72.9 %


/*
 * Copyright (c) 2012 Clément Bœsch
 *
 * 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
 */

/**
 * @file
 * JACOsub subtitle decoder
 * @see http://unicorn.us.com/jacosub/jscripts.html
 */

#include <time.h>
#include "ass.h"
#include "jacosub.h"
#include "libavutil/avstring.h"
#include "libavutil/bprint.h"
#include "libavutil/time_internal.h"

#undef time

static int insert_text(AVBPrint *dst, const char *in, const char *arg)
{
    av_bprintf(dst, "%s", arg);
    return 0;
}

static int insert_datetime(AVBPrint *dst, const char *in, const char *arg)
{
    char buf[16] = {0};
    time_t now = time(0);
    struct tm ltime;

    localtime_r(&now, &ltime);
    if (strftime(buf, sizeof(buf), arg, &ltime))
        av_bprintf(dst, "%s", buf);
    return 0;
}

static int insert_color(AVBPrint *dst, const char *in, const char *arg)
{
    return 1; // skip id
}

static int insert_font(AVBPrint *dst, const char *in, const char *arg)
{
    return 1; // skip id
}

static const struct {
    const char *from;
    const char *arg;
    int (*func)(AVBPrint *dst, const char *in, const char *arg);
} ass_codes_map[] = {
    {"\\~", "~",        insert_text},       // tilde doesn't need escaping
    {"~",   "{\\h}",    insert_text},       // hard space
    {"\\n", "\\N",      insert_text},       // newline
    {"\\D", "%d %b %Y", insert_datetime},   // current date
    {"\\T", "%H:%M",    insert_datetime},   // current time
    {"\\N", "{\\r}",    insert_text},       // reset to default style
    {"\\I", "{\\i1}",   insert_text},       // italic on
    {"\\i", "{\\i0}",   insert_text},       // italic off
    {"\\B", "{\\b1}",   insert_text},       // bold on
    {"\\b", "{\\b0}",   insert_text},       // bold off
    {"\\U", "{\\u1}",   insert_text},       // underline on
    {"\\u", "{\\u0}",   insert_text},       // underline off
    {"\\C", "",         insert_color},      // TODO: color
    {"\\F", "",         insert_font},       // TODO: font
};

enum {
    ALIGN_VB = 1<<0, // vertical bottom, default
    ALIGN_VM = 1<<1, // vertical middle
    ALIGN_VT = 1<<2, // vertical top
    ALIGN_JC = 1<<3, // justify center, default
    ALIGN_JL = 1<<4, // justify left
    ALIGN_JR = 1<<5, // justify right
};

static void jacosub_to_ass(AVCodecContext *avctx, AVBPrint *dst, const char *src)
{
    int i, valign = 0, halign = 0;
    char c = av_toupper(*src);
    char directives[128] = {0};

    /* extract the optional directives */
    if ((c >= 'A' && c <= 'Z') || c == '[') {
        char *p    = directives;
        char *pend = directives + sizeof(directives) - 1;

        do *p++ = av_toupper(*src++);
        while (*src && !jss_whitespace(*src) && p < pend);
        *p = 0;
        src = jss_skip_whitespace(src);
    }

    /* handle directives (TODO: handle more of them, and more reliably) */
    if      (strstr(directives, "VB")) valign = ALIGN_VB;
    else if (strstr(directives, "VM")) valign = ALIGN_VM;
    else if (strstr(directives, "VT")) valign = ALIGN_VT;
    if      (strstr(directives, "JC")) halign = ALIGN_JC;
    else if (strstr(directives, "JL")) halign = ALIGN_JL;
    else if (strstr(directives, "JR")) halign = ALIGN_JR;
    if (valign || halign) {
        if (!valign) valign = ALIGN_VB;
        if (!halign) halign = ALIGN_JC;
        switch (valign | halign) {
        case ALIGN_VB | ALIGN_JL: av_bprintf(dst, "{\\an1}"); break; // bottom left
        case ALIGN_VB | ALIGN_JC: av_bprintf(dst, "{\\an2}"); break; // bottom center
        case ALIGN_VB | ALIGN_JR: av_bprintf(dst, "{\\an3}"); break; // bottom right
        case ALIGN_VM | ALIGN_JL: av_bprintf(dst, "{\\an4}"); break; // middle left
        case ALIGN_VM | ALIGN_JC: av_bprintf(dst, "{\\an5}"); break; // middle center
        case ALIGN_VM | ALIGN_JR: av_bprintf(dst, "{\\an6}"); break; // middle right
        case ALIGN_VT | ALIGN_JL: av_bprintf(dst, "{\\an7}"); break; // top left
        case ALIGN_VT | ALIGN_JC: av_bprintf(dst, "{\\an8}"); break; // top center
        case ALIGN_VT | ALIGN_JR: av_bprintf(dst, "{\\an9}"); break; // top right
        }
    }

    /* process timed line */
    while (*src && *src != '\n') {

        /* text continue on the next line */
        if (src[0] == '\\' && src[1] == '\n') {
            src += 2;
            while (jss_whitespace(*src))
                src++;
            continue;
        }

        /* special character codes */
        for (i = 0; i < FF_ARRAY_ELEMS(ass_codes_map); i++) {
            const char *from = ass_codes_map[i].from;
            const char *arg  = ass_codes_map[i].arg;
            size_t codemap_len = strlen(from);

            if (!strncmp(src, from, codemap_len)) {
                src += codemap_len;
                src += ass_codes_map[i].func(dst, src, arg);
                break;
            }
        }

        /* simple char copy */
        if (i == FF_ARRAY_ELEMS(ass_codes_map))
            av_bprintf(dst, "%c", *src++);
    }
}

static int jacosub_decode_frame(AVCodecContext *avctx,
                                void *data, int *got_sub_ptr, AVPacket *avpkt)
{
    int ret;
    AVSubtitle *sub = data;
    const char *ptr = avpkt->data;
    FFASSDecoderContext *s = avctx->priv_data;

    if (avpkt->size <= 0)
        goto end;

    if (*ptr) {
        AVBPrint buffer;

        // skip timers
        ptr = jss_skip_whitespace(ptr);
        ptr = strchr(ptr, ' '); if (!ptr) goto end; ptr++;
        ptr = strchr(ptr, ' '); if (!ptr) goto end; ptr++;

        av_bprint_init(&buffer, JSS_MAX_LINESIZE, JSS_MAX_LINESIZE);
        jacosub_to_ass(avctx, &buffer, ptr);
        ret = ff_ass_add_rect(sub, buffer.str, s->readorder++, 0, NULL, NULL);
        av_bprint_finalize(&buffer, NULL);
        if (ret < 0)
            return ret;
    }

end:
    *got_sub_ptr = sub->num_rects > 0;
    return avpkt->size;
}

AVCodec ff_jacosub_decoder = {
    .name           = "jacosub",
    .long_name      = NULL_IF_CONFIG_SMALL("JACOsub subtitle"),
    .type           = AVMEDIA_TYPE_SUBTITLE,
    .id             = AV_CODEC_ID_JACOSUB,
    .init           = ff_ass_subtitle_header_default,
    .decode         = jacosub_decode_frame,
    .flush          = ff_ass_decoder_flush,
    .priv_data_size = sizeof(FFASSDecoderContext),
};


Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2012 Clément Bœsch
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			/**
22			* @file
23			* JACOsub subtitle decoder
24			* @see http://unicorn.us.com/jacosub/jscripts.html
25			*/
26
27			#include <time.h>
28			#include "ass.h"
29			#include "jacosub.h"
30			#include "libavutil/avstring.h"
31			#include "libavutil/bprint.h"
32			#include "libavutil/time_internal.h"
33
34			#undef time
35
36		13	static int insert_text(AVBPrint dst, const char in, const char *arg)
37			{
38		13	av_bprintf(dst, "%s", arg);
39		13	return 0;
40			}
41
42			static int insert_datetime(AVBPrint dst, const char in, const char *arg)
43			{
44			char buf[16] = {0};
45			time_t now = time(0);
46			struct tm ltime;
47
48			localtime_r(&now, &ltime);
49			if (strftime(buf, sizeof(buf), arg, &ltime))
50			av_bprintf(dst, "%s", buf);
51			return 0;
52			}
53
54			static int insert_color(AVBPrint dst, const char in, const char *arg)
55			{
56			return 1; // skip id
57			}
58
59			static int insert_font(AVBPrint dst, const char in, const char *arg)
60			{
61			return 1; // skip id
62			}
63
64			static const struct {
65			const char *from;
66			const char *arg;
67			int (func)(AVBPrint dst, const char in, const char arg);
68			} ass_codes_map[] = {
69			{"\\~", "~", insert_text}, // tilde doesn't need escaping
70			{"~", "{\\h}", insert_text}, // hard space
71			{"\\n", "\\N", insert_text}, // newline
72			{"\\D", "%d %b %Y", insert_datetime}, // current date
73			{"\\T", "%H:%M", insert_datetime}, // current time
74			{"\\N", "{\\r}", insert_text}, // reset to default style
75			{"\\I", "{\\i1}", insert_text}, // italic on
76			{"\\i", "{\\i0}", insert_text}, // italic off
77			{"\\B", "{\\b1}", insert_text}, // bold on
78			{"\\b", "{\\b0}", insert_text}, // bold off
79			{"\\U", "{\\u1}", insert_text}, // underline on
80			{"\\u", "{\\u0}", insert_text}, // underline off
81			{"\\C", "", insert_color}, // TODO: color
82			{"\\F", "", insert_font}, // TODO: font
83			};
84
85			enum {
86			ALIGN_VB = 1<<0, // vertical bottom, default
87			ALIGN_VM = 1<<1, // vertical middle
88			ALIGN_VT = 1<<2, // vertical top
89			ALIGN_JC = 1<<3, // justify center, default
90			ALIGN_JL = 1<<4, // justify left
91			ALIGN_JR = 1<<5, // justify right
92			};
93
94		11	static void jacosub_to_ass(AVCodecContext avctx, AVBPrint dst, const char *src)
95			{
96		11	int i, valign = 0, halign = 0;
97		11	char c = av_toupper(*src);
98		11	char directives[128] = {0};
99
100			/* extract the optional directives */
101	✓✗✗✓ ✗✗	11	if ((c >= 'A' && c <= 'Z') \|\| c == '[') {
102		11	char *p = directives;
103		11	char *pend = directives + sizeof(directives) - 1;
104
105		23	do p++ = av_toupper(src++);
106	✓✗✓✓ ✓✗	23	while (src && !jss_whitespace(src) && p < pend);
107		11	*p = 0;
108		11	src = jss_skip_whitespace(src);
109			}
110
111			/* handle directives (TODO: handle more of them, and more reliably) */
112	✓✓	11	if (strstr(directives, "VB")) valign = ALIGN_VB;
113	✓✓	10	else if (strstr(directives, "VM")) valign = ALIGN_VM;
114	✓✓	6	else if (strstr(directives, "VT")) valign = ALIGN_VT;
115	✓✓	11	if (strstr(directives, "JC")) halign = ALIGN_JC;
116	✓✓	10	else if (strstr(directives, "JL")) halign = ALIGN_JL;
117	✓✓	9	else if (strstr(directives, "JR")) halign = ALIGN_JR;
118	✓✓✓✓	11	if (valign \|\| halign) {
119	✓✓	9	if (!valign) valign = ALIGN_VB;
120	✓✓	9	if (!halign) halign = ALIGN_JC;
121	✓✓✓✗ ✓✗✗✓ ✗✗	9	switch (valign \| halign) {
122		1	case ALIGN_VB \| ALIGN_JL: av_bprintf(dst, "{\\an1}"); break; // bottom left
123		2	case ALIGN_VB \| ALIGN_JC: av_bprintf(dst, "{\\an2}"); break; // bottom center
124		1	case ALIGN_VB \| ALIGN_JR: av_bprintf(dst, "{\\an3}"); break; // bottom right
125			case ALIGN_VM \| ALIGN_JL: av_bprintf(dst, "{\\an4}"); break; // middle left
126		4	case ALIGN_VM \| ALIGN_JC: av_bprintf(dst, "{\\an5}"); break; // middle center
127			case ALIGN_VM \| ALIGN_JR: av_bprintf(dst, "{\\an6}"); break; // middle right
128			case ALIGN_VT \| ALIGN_JL: av_bprintf(dst, "{\\an7}"); break; // top left
129		1	case ALIGN_VT \| ALIGN_JC: av_bprintf(dst, "{\\an8}"); break; // top center
130			case ALIGN_VT \| ALIGN_JR: av_bprintf(dst, "{\\an9}"); break; // top right
131			}
132		2	}
133
134			/* process timed line */
135	✓✗✓✓	586	while (src && src != '\n') {
136
137			/* text continue on the next line */
138	✓✓✓✓	575	if (src[0] == '\\' && src[1] == '\n') {
139		7	src += 2;
140	✓✓	183	while (jss_whitespace(*src))
141		176	src++;
142		7	continue;
143			}
144
145			/* special character codes */
146	✓✓	8380	for (i = 0; i < FF_ARRAY_ELEMS(ass_codes_map); i++) {
147		7825	const char *from = ass_codes_map[i].from;
148		7825	const char *arg = ass_codes_map[i].arg;
149		7825	size_t codemap_len = strlen(from);
150
151	✓✓	7825	if (!strncmp(src, from, codemap_len)) {
152		13	src += codemap_len;
153		13	src += ass_codes_map[i].func(dst, src, arg);
154		13	break;
155			}
156			}
157
158			/* simple char copy */
159	✓✓	568	if (i == FF_ARRAY_ELEMS(ass_codes_map))
160		555	av_bprintf(dst, "%c", *src++);
161			}
162		11	}
163
164		11	static int jacosub_decode_frame(AVCodecContext *avctx,
165			void data, int got_sub_ptr, AVPacket *avpkt)
166			{
167			int ret;
168		11	AVSubtitle *sub = data;
169		11	const char *ptr = avpkt->data;
170		11	FFASSDecoderContext *s = avctx->priv_data;
171
172	✗✓	11	if (avpkt->size <= 0)
173			goto end;
174
175	✗✓	11	if (*ptr) {
176			AVBPrint buffer;
177
178			// skip timers
179		11	ptr = jss_skip_whitespace(ptr);
180	✗✓	11	ptr = strchr(ptr, ' '); if (!ptr) goto end; ptr++;
181	✗✓	11	ptr = strchr(ptr, ' '); if (!ptr) goto end; ptr++;
182
183		11	av_bprint_init(&buffer, JSS_MAX_LINESIZE, JSS_MAX_LINESIZE);
184		11	jacosub_to_ass(avctx, &buffer, ptr);
185		11	ret = ff_ass_add_rect(sub, buffer.str, s->readorder++, 0, NULL, NULL);
186		11	av_bprint_finalize(&buffer, NULL);
187	✗✓	11	if (ret < 0)
188			return ret;
189			}
190
191			end:
192		11	*got_sub_ptr = sub->num_rects > 0;
193		11	return avpkt->size;
194			}
195
196			AVCodec ff_jacosub_decoder = {
197			.name = "jacosub",
198			.long_name = NULL_IF_CONFIG_SMALL("JACOsub subtitle"),
199			.type = AVMEDIA_TYPE_SUBTITLE,
200			.id = AV_CODEC_ID_JACOSUB,
201			.init = ff_ass_subtitle_header_default,
202			.decode = jacosub_decode_frame,
203			.flush = ff_ass_decoder_flush,
204			.priv_data_size = sizeof(FFASSDecoderContext),
205			};