Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * SubRip subtitle decoder
  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 "libavutil/avstring.h"
  23. #include "libavutil/common.h"
  24. #include "libavutil/intreadwrite.h"
  25. #include "libavutil/parseutils.h"
  26. #include "avcodec.h"
  27. #include "ass.h"
  28.  
  29. static int html_color_parse(AVCodecContext *avctx, const char *str)
  30. {
  31.     uint8_t rgba[4];
  32.     if (av_parse_color(rgba, str, strcspn(str, "\" >"), avctx) < 0)
  33.         return -1;
  34.     return rgba[0] | rgba[1] << 8 | rgba[2] << 16;
  35. }
  36.  
  37. enum {
  38.     PARAM_UNKNOWN = -1,
  39.     PARAM_SIZE,
  40.     PARAM_COLOR,
  41.     PARAM_FACE,
  42.     PARAM_NUMBER
  43. };
  44.  
  45. typedef struct SrtStack {
  46.     char tag[128];
  47.     char param[PARAM_NUMBER][128];
  48. } SrtStack;
  49.  
  50. static void rstrip_spaces_buf(AVBPrint *buf)
  51. {
  52.     while (buf->len > 0 && buf->str[buf->len - 1] == ' ')
  53.         buf->str[--buf->len] = 0;
  54. }
  55.  
  56. static void srt_to_ass(AVCodecContext *avctx, AVBPrint *dst,
  57.                        const char *in, int x1, int y1, int x2, int y2)
  58. {
  59.     char *param, buffer[128], tmp[128];
  60.     int len, tag_close, sptr = 1, line_start = 1, an = 0, end = 0;
  61.     SrtStack stack[16];
  62.  
  63.     stack[0].tag[0] = 0;
  64.     strcpy(stack[0].param[PARAM_SIZE],  "{\\fs}");
  65.     strcpy(stack[0].param[PARAM_COLOR], "{\\c}");
  66.     strcpy(stack[0].param[PARAM_FACE],  "{\\fn}");
  67.  
  68.     if (x1 >= 0 && y1 >= 0) {
  69.         /* XXX: here we rescale coordinate assuming they are in DVD resolution
  70.          * (720x480) since we don't have anything better */
  71.  
  72.         if (x2 >= 0 && y2 >= 0 && (x2 != x1 || y2 != y1) && x2 >= x1 && y2 >= y1) {
  73.             /* text rectangle defined, write the text at the center of the rectangle */
  74.             const int cx = x1 + (x2 - x1)/2;
  75.             const int cy = y1 + (y2 - y1)/2;
  76.             const int scaled_x = cx * ASS_DEFAULT_PLAYRESX / 720;
  77.             const int scaled_y = cy * ASS_DEFAULT_PLAYRESY / 480;
  78.             av_bprintf(dst, "{\\an5}{\\pos(%d,%d)}", scaled_x, scaled_y);
  79.         } else {
  80.             /* only the top left corner, assume the text starts in that corner */
  81.             const int scaled_x = x1 * ASS_DEFAULT_PLAYRESX / 720;
  82.             const int scaled_y = y1 * ASS_DEFAULT_PLAYRESY / 480;
  83.             av_bprintf(dst, "{\\an1}{\\pos(%d,%d)}", scaled_x, scaled_y);
  84.         }
  85.     }
  86.  
  87.     for (; !end && *in; in++) {
  88.         switch (*in) {
  89.         case '\r':
  90.             break;
  91.         case '\n':
  92.             if (line_start) {
  93.                 end = 1;
  94.                 break;
  95.             }
  96.             rstrip_spaces_buf(dst);
  97.             av_bprintf(dst, "\\N");
  98.             line_start = 1;
  99.             break;
  100.         case ' ':
  101.             if (!line_start)
  102.                 av_bprint_chars(dst, *in, 1);
  103.             break;
  104.         case '{':    /* skip all {\xxx} substrings except for {\an%d}
  105.                         and all microdvd like styles such as {Y:xxx} */
  106.             len = 0;
  107.             an += sscanf(in, "{\\an%*1u}%n", &len) >= 0 && len > 0;
  108.             if ((an != 1 && (len = 0, sscanf(in, "{\\%*[^}]}%n", &len) >= 0 && len > 0)) ||
  109.                 (len = 0, sscanf(in, "{%*1[CcFfoPSsYy]:%*[^}]}%n", &len) >= 0 && len > 0)) {
  110.                 in += len - 1;
  111.             } else
  112.                 av_bprint_chars(dst, *in, 1);
  113.             break;
  114.         case '<':
  115.             tag_close = in[1] == '/';
  116.             len = 0;
  117.             if (sscanf(in+tag_close+1, "%127[^>]>%n", buffer, &len) >= 1 && len > 0) {
  118.                 if ((param = strchr(buffer, ' ')))
  119.                     *param++ = 0;
  120.                 if ((!tag_close && sptr < FF_ARRAY_ELEMS(stack)) ||
  121.                     ( tag_close && sptr > 0 && !strcmp(stack[sptr-1].tag, buffer))) {
  122.                     int i, j, unknown = 0;
  123.                     in += len + tag_close;
  124.                     if (!tag_close)
  125.                         memset(stack+sptr, 0, sizeof(*stack));
  126.                     if (!strcmp(buffer, "font")) {
  127.                         if (tag_close) {
  128.                             for (i=PARAM_NUMBER-1; i>=0; i--)
  129.                                 if (stack[sptr-1].param[i][0])
  130.                                     for (j=sptr-2; j>=0; j--)
  131.                                         if (stack[j].param[i][0]) {
  132.                                             av_bprintf(dst, "%s", stack[j].param[i]);
  133.                                             break;
  134.                                         }
  135.                         } else {
  136.                             while (param) {
  137.                                 if (!strncmp(param, "size=", 5)) {
  138.                                     unsigned font_size;
  139.                                     param += 5 + (param[5] == '"');
  140.                                     if (sscanf(param, "%u", &font_size) == 1) {
  141.                                         snprintf(stack[sptr].param[PARAM_SIZE],
  142.                                              sizeof(stack[0].param[PARAM_SIZE]),
  143.                                              "{\\fs%u}", font_size);
  144.                                     }
  145.                                 } else if (!strncmp(param, "color=", 6)) {
  146.                                     param += 6 + (param[6] == '"');
  147.                                     snprintf(stack[sptr].param[PARAM_COLOR],
  148.                                          sizeof(stack[0].param[PARAM_COLOR]),
  149.                                          "{\\c&H%X&}",
  150.                                          html_color_parse(avctx, param));
  151.                                 } else if (!strncmp(param, "face=", 5)) {
  152.                                     param += 5 + (param[5] == '"');
  153.                                     len = strcspn(param,
  154.                                                   param[-1] == '"' ? "\"" :" ");
  155.                                     av_strlcpy(tmp, param,
  156.                                                FFMIN(sizeof(tmp), len+1));
  157.                                     param += len;
  158.                                     snprintf(stack[sptr].param[PARAM_FACE],
  159.                                              sizeof(stack[0].param[PARAM_FACE]),
  160.                                              "{\\fn%s}", tmp);
  161.                                 }
  162.                                 if ((param = strchr(param, ' ')))
  163.                                     param++;
  164.                             }
  165.                             for (i=0; i<PARAM_NUMBER; i++)
  166.                                 if (stack[sptr].param[i][0])
  167.                                     av_bprintf(dst, "%s", stack[sptr].param[i]);
  168.                         }
  169.                     } else if (!buffer[1] && strspn(buffer, "bisu") == 1) {
  170.                         av_bprintf(dst, "{\\%c%d}", buffer[0], !tag_close);
  171.                     } else {
  172.                         unknown = 1;
  173.                         snprintf(tmp, sizeof(tmp), "</%s>", buffer);
  174.                     }
  175.                     if (tag_close) {
  176.                         sptr--;
  177.                     } else if (unknown && !strstr(in, tmp)) {
  178.                         in -= len + tag_close;
  179.                         av_bprint_chars(dst, *in, 1);
  180.                     } else
  181.                         av_strlcpy(stack[sptr++].tag, buffer,
  182.                                    sizeof(stack[0].tag));
  183.                     break;
  184.                 }
  185.             }
  186.         default:
  187.             av_bprint_chars(dst, *in, 1);
  188.             break;
  189.         }
  190.         if (*in != ' ' && *in != '\r' && *in != '\n')
  191.             line_start = 0;
  192.     }
  193.  
  194.     while (dst->len >= 2 && !strncmp(&dst->str[dst->len - 2], "\\N", 2))
  195.         dst->len -= 2;
  196.     dst->str[dst->len] = 0;
  197.     rstrip_spaces_buf(dst);
  198. }
  199.  
  200. static int srt_decode_frame(AVCodecContext *avctx,
  201.                             void *data, int *got_sub_ptr, AVPacket *avpkt)
  202. {
  203.     AVSubtitle *sub = data;
  204.     AVBPrint buffer;
  205.     int ts_start, ts_end, x1 = -1, y1 = -1, x2 = -1, y2 = -1;
  206.     int size, ret;
  207.     const uint8_t *p = av_packet_get_side_data(avpkt, AV_PKT_DATA_SUBTITLE_POSITION, &size);
  208.  
  209.     if (p && size == 16) {
  210.         x1 = AV_RL32(p     );
  211.         y1 = AV_RL32(p +  4);
  212.         x2 = AV_RL32(p +  8);
  213.         y2 = AV_RL32(p + 12);
  214.     }
  215.  
  216.     if (avpkt->size <= 0)
  217.         return avpkt->size;
  218.  
  219.     av_bprint_init(&buffer, 0, AV_BPRINT_SIZE_UNLIMITED);
  220.  
  221.         // TODO: reindent
  222.             // Do final divide-by-10 outside rescale to force rounding down.
  223.             ts_start = av_rescale_q(avpkt->pts,
  224.                                     avctx->time_base,
  225.                                     (AVRational){1,100});
  226.             ts_end   = av_rescale_q(avpkt->pts + avpkt->duration,
  227.                                     avctx->time_base,
  228.                                     (AVRational){1,100});
  229.  
  230.     srt_to_ass(avctx, &buffer, avpkt->data, x1, y1, x2, y2);
  231.     ret = ff_ass_add_rect_bprint(sub, &buffer, ts_start, ts_end-ts_start);
  232.     av_bprint_finalize(&buffer, NULL);
  233.     if (ret < 0)
  234.         return ret;
  235.  
  236.     *got_sub_ptr = sub->num_rects > 0;
  237.     return avpkt->size;
  238. }
  239.  
  240. #if CONFIG_SRT_DECODER
  241. /* deprecated decoder */
  242. AVCodec ff_srt_decoder = {
  243.     .name         = "srt",
  244.     .long_name    = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
  245.     .type         = AVMEDIA_TYPE_SUBTITLE,
  246.     .id           = AV_CODEC_ID_SUBRIP,
  247.     .init         = ff_ass_subtitle_header_default,
  248.     .decode       = srt_decode_frame,
  249. };
  250. #endif
  251.  
  252. #if CONFIG_SUBRIP_DECODER
  253. AVCodec ff_subrip_decoder = {
  254.     .name         = "subrip",
  255.     .long_name    = NULL_IF_CONFIG_SMALL("SubRip subtitle"),
  256.     .type         = AVMEDIA_TYPE_SUBTITLE,
  257.     .id           = AV_CODEC_ID_SUBRIP,
  258.     .init         = ff_ass_subtitle_header_default,
  259.     .decode       = srt_decode_frame,
  260. };
  261. #endif
  262.