movtextdec: Fix memory leaks by freeing mem allocs correctly
[ffmpeg.git] / libavcodec / movtextdec.c
1 /*
2  * 3GPP TS 26.245 Timed Text decoder
3  * Copyright (c) 2012  Philip Langdale <philipl@overt.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 "avcodec.h"
23 #include "ass.h"
24 #include "libavutil/avstring.h"
25 #include "libavutil/common.h"
26 #include "libavutil/bprint.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/mem.h"
29
30 #define STYLE_FLAG_BOLD         (1<<0)
31 #define STYLE_FLAG_ITALIC       (1<<1)
32 #define STYLE_FLAG_UNDERLINE    (1<<2)
33
34 #define BOX_SIZE_INITIAL    40
35
36 #define STYL_BOX   (1<<0)
37 #define HLIT_BOX   (1<<1)
38 #define HCLR_BOX   (1<<2)
39
40 typedef struct {
41     uint16_t fontID;
42     char *font;
43 } FontRecord;
44
45 typedef struct {
46     uint16_t style_start;
47     uint16_t style_end;
48     uint8_t style_flag;
49     uint8_t fontsize;
50     uint16_t style_fontID;
51 } StyleBox;
52
53 typedef struct {
54     uint16_t hlit_start;
55     uint16_t hlit_end;
56 } HighlightBox;
57
58 typedef struct {
59    uint8_t hlit_color[4];
60 } HilightcolorBox;
61
62 typedef struct {
63     StyleBox **s;
64     StyleBox *s_temp;
65     HighlightBox h;
66     HilightcolorBox c;
67     FontRecord **ftab;
68     FontRecord *ftab_temp;
69     uint8_t box_flags;
70     uint16_t style_entries, ftab_entries;
71     uint64_t tracksize;
72     int size_var;
73     int count_s, count_f;
74 } MovTextContext;
75
76 typedef struct {
77     uint32_t type;
78     size_t base_size;
79     int (*decode)(const uint8_t *tsmb, MovTextContext *m, AVPacket *avpkt);
80 } Box;
81
82 static void mov_text_cleanup(MovTextContext *m)
83 {
84     int i;
85     if (m->box_flags & STYL_BOX) {
86         for(i = 0; i < m->count_s; i++) {
87             av_freep(&m->s[i]);
88         }
89         av_freep(&m->s);
90     }
91 }
92
93 static void mov_text_cleanup_ftab(MovTextContext *m)
94 {
95     int i;
96     if (m->ftab) {
97         for(i = 0; i < m->count_f; i++) {
98             av_freep(&m->ftab[i]->font);
99             av_freep(&m->ftab[i]);
100         }
101     }
102     av_freep(&m->ftab);
103 }
104
105 static int mov_text_tx3g(AVCodecContext *avctx, MovTextContext *m)
106 {
107     char *tx3g_ptr = avctx->extradata;
108     int i, box_size, font_length;
109
110     m->count_f = 0;
111     m->ftab_entries = 0;
112     box_size = BOX_SIZE_INITIAL; /* Size till ftab_entries */
113     if (avctx->extradata_size < box_size)
114         return -1;
115
116     // Display Flags
117     tx3g_ptr += 4;
118     // Alignment
119     tx3g_ptr += 2;
120     // Background Color
121     tx3g_ptr += 4;
122     // BoxRecord
123     tx3g_ptr += 8;
124     // StyleRecord
125     tx3g_ptr += 12;
126     // FontRecord
127     // FontRecord Size
128     tx3g_ptr += 4;
129     // ftab
130     tx3g_ptr += 4;
131
132     m->ftab_entries = AV_RB16(tx3g_ptr);
133     tx3g_ptr += 2;
134
135     for (i = 0; i < m->ftab_entries; i++) {
136
137         box_size += 3;
138         if (avctx->extradata_size < box_size) {
139             mov_text_cleanup_ftab(m);
140             m->ftab_entries = 0;
141             return -1;
142         }
143         m->ftab_temp = av_malloc(sizeof(*m->ftab_temp));
144         if (!m->ftab_temp) {
145             mov_text_cleanup_ftab(m);
146             return AVERROR(ENOMEM);
147         }
148         m->ftab_temp->fontID = AV_RB16(tx3g_ptr);
149         tx3g_ptr += 2;
150         font_length = *tx3g_ptr++;
151
152         box_size = box_size + font_length;
153         if (avctx->extradata_size < box_size) {
154             mov_text_cleanup_ftab(m);
155             m->ftab_entries = 0;
156             return -1;
157         }
158         m->ftab_temp->font = av_malloc(font_length + 1);
159         if (!m->ftab_temp->font) {
160             mov_text_cleanup_ftab(m);
161             return AVERROR(ENOMEM);
162         }
163         memcpy(m->ftab_temp->font, tx3g_ptr, font_length);
164         m->ftab_temp->font[font_length] = '\0';
165         av_dynarray_add(&m->ftab, &m->count_f, m->ftab_temp);
166         if (!m->ftab) {
167             mov_text_cleanup_ftab(m);
168             return AVERROR(ENOMEM);
169         }
170         tx3g_ptr = tx3g_ptr + font_length;
171     }
172     return 0;
173 }
174
175 static int decode_hlit(const uint8_t *tsmb, MovTextContext *m, AVPacket *avpkt)
176 {
177     m->box_flags |= HLIT_BOX;
178     m->h.hlit_start = AV_RB16(tsmb);
179     tsmb += 2;
180     m->h.hlit_end = AV_RB16(tsmb);
181     tsmb += 2;
182     return 0;
183 }
184
185 static int decode_hclr(const uint8_t *tsmb, MovTextContext *m, AVPacket *avpkt)
186 {
187     m->box_flags |= HCLR_BOX;
188     memcpy(m->c.hlit_color, tsmb, 4);
189     tsmb += 4;
190     return 0;
191 }
192
193 static int decode_styl(const uint8_t *tsmb, MovTextContext *m, AVPacket *avpkt)
194 {
195     int i;
196     m->style_entries = AV_RB16(tsmb);
197     tsmb += 2;
198     // A single style record is of length 12 bytes.
199     if (m->tracksize + m->size_var + 2 + m->style_entries * 12 > avpkt->size)
200         return -1;
201
202     m->box_flags |= STYL_BOX;
203     for(i = 0; i < m->style_entries; i++) {
204         m->s_temp = av_malloc(sizeof(*m->s_temp));
205         if (!m->s_temp) {
206             mov_text_cleanup(m);
207             return AVERROR(ENOMEM);
208         }
209         m->s_temp->style_start = AV_RB16(tsmb);
210         tsmb += 2;
211         m->s_temp->style_end = AV_RB16(tsmb);
212         tsmb += 2;
213         m->s_temp->style_fontID = AV_RB16(tsmb);
214         tsmb += 2;
215         m->s_temp->style_flag = AV_RB8(tsmb);
216         tsmb++;
217         m->s_temp->fontsize = AV_RB8(tsmb);
218         av_dynarray_add(&m->s, &m->count_s, m->s_temp);
219         if(!m->s) {
220             mov_text_cleanup(m);
221             return AVERROR(ENOMEM);
222         }
223         tsmb++;
224         // text-color-rgba
225         tsmb += 4;
226     }
227     return 0;
228 }
229
230 static const Box box_types[] = {
231     { MKBETAG('s','t','y','l'), 2, decode_styl },
232     { MKBETAG('h','l','i','t'), 4, decode_hlit },
233     { MKBETAG('h','c','l','r'), 4, decode_hclr }
234 };
235
236 const static size_t box_count = FF_ARRAY_ELEMS(box_types);
237
238 static int text_to_ass(AVBPrint *buf, const char *text, const char *text_end,
239                         MovTextContext *m)
240 {
241     int i = 0;
242     int j = 0;
243     int text_pos = 0;
244     while (text < text_end) {
245         if (m->box_flags & STYL_BOX) {
246             for (i = 0; i < m->style_entries; i++) {
247                 if (m->s[i]->style_flag && text_pos == m->s[i]->style_end) {
248                     av_bprintf(buf, "{\\r}");
249                 }
250             }
251             for (i = 0; i < m->style_entries; i++) {
252                 if (m->s[i]->style_flag && text_pos == m->s[i]->style_start) {
253                     if (m->s[i]->style_flag & STYLE_FLAG_BOLD)
254                         av_bprintf(buf, "{\\b1}");
255                     if (m->s[i]->style_flag & STYLE_FLAG_ITALIC)
256                         av_bprintf(buf, "{\\i1}");
257                     if (m->s[i]->style_flag & STYLE_FLAG_UNDERLINE)
258                         av_bprintf(buf, "{\\u1}");
259                     av_bprintf(buf, "{\\fs%d}", m->s[i]->fontsize);
260                     for (j = 0; j < m->ftab_entries; j++) {
261                         if (m->s[i]->style_fontID == m->ftab[j]->fontID)
262                             av_bprintf(buf, "{\\fn%s}", m->ftab[j]->font);
263                     }
264                 }
265             }
266         }
267         if (m->box_flags & HLIT_BOX) {
268             if (text_pos == m->h.hlit_start) {
269                 /* If hclr box is present, set the secondary color to the color
270                  * specified. Otherwise, set primary color to white and secondary
271                  * color to black. These colors will come from TextSampleModifier
272                  * boxes in future and inverse video technique for highlight will
273                  * be implemented.
274                  */
275                 if (m->box_flags & HCLR_BOX) {
276                     av_bprintf(buf, "{\\2c&H%02x%02x%02x&}", m->c.hlit_color[2],
277                                 m->c.hlit_color[1], m->c.hlit_color[0]);
278                 } else {
279                     av_bprintf(buf, "{\\1c&H000000&}{\\2c&HFFFFFF&}");
280                 }
281             }
282             if (text_pos == m->h.hlit_end) {
283                 if (m->box_flags & HCLR_BOX) {
284                     av_bprintf(buf, "{\\2c&H000000&}");
285                 } else {
286                     av_bprintf(buf, "{\\1c&HFFFFFF&}{\\2c&H000000&}");
287                 }
288             }
289         }
290
291         switch (*text) {
292         case '\r':
293             break;
294         case '\n':
295             av_bprintf(buf, "\\N");
296             break;
297         default:
298             av_bprint_chars(buf, *text, 1);
299             break;
300         }
301         text++;
302         text_pos++;
303     }
304
305     return 0;
306 }
307
308 static int mov_text_init(AVCodecContext *avctx) {
309     /*
310      * TODO: Handle the default text style.
311      * NB: Most players ignore styles completely, with the result that
312      * it's very common to find files where the default style is broken
313      * and respecting it results in a worse experience than ignoring it.
314      */
315     MovTextContext *m = avctx->priv_data;
316     mov_text_tx3g(avctx, m);
317     return ff_ass_subtitle_header_default(avctx);
318 }
319
320 static int mov_text_decode_frame(AVCodecContext *avctx,
321                             void *data, int *got_sub_ptr, AVPacket *avpkt)
322 {
323     AVSubtitle *sub = data;
324     MovTextContext *m = avctx->priv_data;
325     int ret, ts_start, ts_end;
326     AVBPrint buf;
327     char *ptr = avpkt->data;
328     char *end;
329     int text_length, tsmb_type, ret_tsmb;
330     uint64_t tsmb_size;
331     const uint8_t *tsmb;
332
333     if (!ptr || avpkt->size < 2)
334         return AVERROR_INVALIDDATA;
335
336     /*
337      * A packet of size two with value zero is an empty subtitle
338      * used to mark the end of the previous non-empty subtitle.
339      * We can just drop them here as we have duration information
340      * already. If the value is non-zero, then it's technically a
341      * bad packet.
342      */
343     if (avpkt->size == 2)
344         return AV_RB16(ptr) == 0 ? 0 : AVERROR_INVALIDDATA;
345
346     /*
347      * The first two bytes of the packet are the length of the text string
348      * In complex cases, there are style descriptors appended to the string
349      * so we can't just assume the packet size is the string size.
350      */
351     text_length = AV_RB16(ptr);
352     end = ptr + FFMIN(2 + text_length, avpkt->size);
353     ptr += 2;
354
355     ts_start = av_rescale_q(avpkt->pts,
356                             avctx->time_base,
357                             (AVRational){1,100});
358     ts_end   = av_rescale_q(avpkt->pts + avpkt->duration,
359                             avctx->time_base,
360                             (AVRational){1,100});
361
362     tsmb_size = 0;
363     m->tracksize = 2 + text_length;
364     m->style_entries = 0;
365     m->box_flags = 0;
366     m->count_s = 0;
367     // Note that the spec recommends lines be no longer than 2048 characters.
368     av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
369     if (text_length + 2 != avpkt->size) {
370         while (m->tracksize + 8 <= avpkt->size) {
371             // A box is a minimum of 8 bytes.
372             tsmb = ptr + m->tracksize - 2;
373             tsmb_size = AV_RB32(tsmb);
374             tsmb += 4;
375             tsmb_type = AV_RB32(tsmb);
376             tsmb += 4;
377
378             if (tsmb_size == 1) {
379                 if (m->tracksize + 16 > avpkt->size)
380                     break;
381                 tsmb_size = AV_RB64(tsmb);
382                 tsmb += 8;
383                 m->size_var = 16;
384             } else
385                 m->size_var = 8;
386             //size_var is equal to 8 or 16 depending on the size of box
387
388             if (m->tracksize + tsmb_size > avpkt->size)
389                 break;
390
391             for (size_t i = 0; i < box_count; i++) {
392                 if (tsmb_type == box_types[i].type) {
393                     if (m->tracksize + m->size_var + box_types[i].base_size > avpkt->size)
394                         break;
395                     ret_tsmb = box_types[i].decode(tsmb, m, avpkt);
396                     if (ret_tsmb == -1)
397                         break;
398                 }
399             }
400             m->tracksize = m->tracksize + tsmb_size;
401         }
402         text_to_ass(&buf, ptr, end, m);
403         mov_text_cleanup(m);
404     } else
405         text_to_ass(&buf, ptr, end, m);
406
407     ret = ff_ass_add_rect_bprint(sub, &buf, ts_start, ts_end - ts_start);
408     av_bprint_finalize(&buf, NULL);
409     if (ret < 0)
410         return ret;
411     *got_sub_ptr = sub->num_rects > 0;
412     return avpkt->size;
413 }
414
415 static int mov_text_decode_close(AVCodecContext *avctx)
416 {
417     MovTextContext *m = avctx->priv_data;
418     mov_text_cleanup_ftab(m);
419     return 0;
420 }
421
422 AVCodec ff_movtext_decoder = {
423     .name         = "mov_text",
424     .long_name    = NULL_IF_CONFIG_SMALL("3GPP Timed Text subtitle"),
425     .type         = AVMEDIA_TYPE_SUBTITLE,
426     .id           = AV_CODEC_ID_MOV_TEXT,
427     .priv_data_size = sizeof(MovTextContext),
428     .init         = mov_text_init,
429     .decode       = mov_text_decode_frame,
430     .close        = mov_text_decode_close,
431 };