@@ -173,6 +173,7 @@ OBJS-$(CONFIG_BRENDER_PIX_DECODER)     += brenderpix.o

 OBJS-$(CONFIG_C93_DECODER)             += c93.o

 OBJS-$(CONFIG_CAVS_DECODER)            += cavs.o cavsdec.o cavsdsp.o \

                                           cavsdata.o mpeg12data.o

+OBJS-$(CONFIG_CCAPTION_DECODER)        += ccaption_dec.o

 OBJS-$(CONFIG_CDGRAPHICS_DECODER)      += cdgraphics.o

 OBJS-$(CONFIG_CDXL_DECODER)            += cdxl.o

 OBJS-$(CONFIG_CINEPAK_DECODER)         += cinepak.o

@@ -481,6 +481,7 @@ void avcodec_register_all(void)

     /* subtitles */

     REGISTER_ENCDEC (SSA,               ssa);

     REGISTER_ENCDEC (ASS,               ass);

+    REGISTER_DECODER(CCAPTION,          ccaption);

     REGISTER_ENCDEC (DVBSUB,            dvbsub);

     REGISTER_ENCDEC (DVDSUB,            dvdsub);

     REGISTER_DECODER(JACOSUB,           jacosub);

new file mode 100644

@@ -0,0 +1,529 @@

+/*

+ * Closed Caption Decoding

+ * Copyright (c) 2015 Anshul Maheshwari

+ *

+ * 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 "avcodec.h"

+#include "ass.h"

+#include "libavutil/opt.h"

+

+#define CHAR_DEBUG

+#define SCREEN_ROWS 15

+#define SCREEN_COLUMNS 32

+

+#define SET_FLAG(var, val) ( var |= ( 1 << (val) ) )

+#define UNSET_FLAG(var, val) ( var &=  ~( 1 << (val)) )

+#define CHECK_FLAG(var, val) ( (var) & (1 << (val) ) )

+

+/*

+ * TODO list

+ * 1) handle font and color completely

+ */

+enum cc_mode {

+    CCMODE_POPON,

+    CCMODE_PAINTON,

+    CCMODE_ROLLUP_2,

+    CCMODE_ROLLUP_3,

+    CCMODE_ROLLUP_4,

+    CCMODE_TEXT,

+};

+

+enum cc_color_code

+{

+    CCCOL_WHITE,

+    CCCOL_GREEN,

+    CCCOL_BLUE,

+    CCCOL_CYAN,

+    CCCOL_RED,

+    CCCOL_YELLOW,

+    CCCOL_MAGENTA,

+    CCCOL_USERDEFINED,

+    CCCOL_BLACK,

+    CCCOL_TRANSPARENT

+};

+

+enum cc_font

+{

+    CCFONT_REGULAR,

+    CCFONT_ITALICS,

+    CCFONT_UNDERLINED,

+    CCFONT_UNDERLINED_ITALICS

+};

+

+static const unsigned char pac2_attribs[][3] = // Color, font, ident

+{

+    { CCCOL_WHITE, CCFONT_REGULAR, 0 },  // 0x40 || 0x60

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 0 },  // 0x41 || 0x61

+    { CCCOL_GREEN, CCFONT_REGULAR, 0 },  // 0x42 || 0x62

+    { CCCOL_GREEN, CCFONT_UNDERLINED, 0 },  // 0x43 || 0x63

+    { CCCOL_BLUE, CCFONT_REGULAR, 0 },  // 0x44 || 0x64

+    { CCCOL_BLUE, CCFONT_UNDERLINED, 0 },  // 0x45 || 0x65

+    { CCCOL_CYAN, CCFONT_REGULAR, 0 },  // 0x46 || 0x66

+    { CCCOL_CYAN, CCFONT_UNDERLINED, 0 },  // 0x47 || 0x67

+    { CCCOL_RED, CCFONT_REGULAR, 0 },  // 0x48 || 0x68

+    { CCCOL_RED, CCFONT_UNDERLINED, 0 },  // 0x49 || 0x69

+    { CCCOL_YELLOW, CCFONT_REGULAR, 0 },  // 0x4a || 0x6a

+    { CCCOL_YELLOW, CCFONT_UNDERLINED, 0 },  // 0x4b || 0x6b

+    { CCCOL_MAGENTA, CCFONT_REGULAR, 0 },  // 0x4c || 0x6c

+    { CCCOL_MAGENTA, CCFONT_UNDERLINED, 0 },  // 0x4d || 0x6d

+    { CCCOL_WHITE, CCFONT_ITALICS, 0 },  // 0x4e || 0x6e

+    { CCCOL_WHITE, CCFONT_UNDERLINED_ITALICS, 0 },  // 0x4f || 0x6f

+    { CCCOL_WHITE, CCFONT_REGULAR, 0 },  // 0x50 || 0x70

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 0 },  // 0x51 || 0x71

+    { CCCOL_WHITE, CCFONT_REGULAR, 4 },  // 0x52 || 0x72

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 4 },  // 0x53 || 0x73

+    { CCCOL_WHITE, CCFONT_REGULAR, 8 },  // 0x54 || 0x74

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 8 },  // 0x55 || 0x75

+    { CCCOL_WHITE, CCFONT_REGULAR, 12 }, // 0x56 || 0x76

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 12 }, // 0x57 || 0x77

+    { CCCOL_WHITE, CCFONT_REGULAR, 16 }, // 0x58 || 0x78

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 16 }, // 0x59 || 0x79

+    { CCCOL_WHITE, CCFONT_REGULAR, 20 }, // 0x5a || 0x7a

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 20 }, // 0x5b || 0x7b

+    { CCCOL_WHITE, CCFONT_REGULAR, 24 }, // 0x5c || 0x7c

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 24 }, // 0x5d || 0x7d

+    { CCCOL_WHITE, CCFONT_REGULAR, 28 }, // 0x5e || 0x7e

+    { CCCOL_WHITE, CCFONT_UNDERLINED, 28 }  // 0x5f || 0x7f

+    /* total 32 entry */

+};

+/* 0-255 needs 256 space */

+static const uint8_t parity_table[256] = { 0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           0, 1, 1, 0, 1, 0, 0, 1,

+                                           1, 0, 0, 1, 0, 1, 1, 0 };

+struct Screen {

+    /* +1 is used to compensate null character of string */

+    uint8_t characters[SCREEN_ROWS][SCREEN_COLUMNS+1];

+    /*

+     * Bitmask of used rows; if a bit is not set, the

+     * corresponding row is not used.

+     * for setting row 1  use row | (0 << 1)

+     * for setting row 15 use row | (1 << 14)

+     */

+    int16_t  row_used;

+};

+

+

+typedef struct CCaptionSubContext {

+    AVClass *class;

+    int row_cnt;

+    struct Screen screen[2];

+    int active_screen;

+    uint8_t cursor_row;

+    uint8_t cursor_column;

+    uint8_t cursor_color;

+    uint8_t cursor_font;

+    AVBPrint buffer;

+    int erase_display_memory;

+    int rollup;

+    enum  cc_mode mode;

+    int64_t start_time;

+    /* visible screen time */

+    int64_t startv_time;

+    int64_t end_time;

+    char prev_cmd[2];

+    /* buffer to store pkt data */

+    AVBufferRef *pktbuf;

+}CCaptionSubContext;

+

+

+static av_cold int init_decoder(AVCodecContext *avctx)

+{

+    int ret;

+    CCaptionSubContext *ctx = avctx->priv_data;

+

+    av_bprint_init(&ctx->buffer, 0, AV_BPRINT_SIZE_UNLIMITED);

+    /* taking by default roll up to 2 */

+    ctx->rollup = 2;

+    ret = ff_ass_subtitle_header_default(avctx);

+    /* allocate pkt buffer */

+    ctx->pktbuf = av_buffer_alloc(128);

+    if( !ctx->pktbuf) {

+        ret = AVERROR(ENOMEM);

+    }

+

+

+    return ret;

+}

+

+static av_cold int close_decoder(AVCodecContext *avctx)

+{

+    CCaptionSubContext *ctx = avctx->priv_data;

+    av_bprint_finalize( &ctx->buffer, NULL);

+    av_buffer_unref(&ctx->pktbuf);

+    return 0;

+}

+/**

+ * @param ctx closed caption context just to print log

+ */

+static int write_char (CCaptionSubContext *ctx, char *row,uint8_t col, char ch)

+{

+    if(col < SCREEN_COLUMNS) {

+        row[col] = ch;

+        return 0;

+    }

+    /* We have extra space at end only for null character */

+    else if ( col == SCREEN_COLUMNS && ch == 0) {

+        row[col] = ch;

+        return 0;

+    }

+    else {

+        av_log(ctx, AV_LOG_WARNING,"Data Ignored since exciding screen width\n");

+        return AVERROR_INVALIDDATA;

+    }

+}

+/**

+ * This function after validating parity bit, also remove it from data pair.

+ * The first byte doesn't pass parity, we replace it with a solid blank

+ * and process the pair.

+ * If the second byte doesn't pass parity, it returns INVALIDDATA

+ * user can ignore the whole pair and pass the other pair.

+ */

+static int validate_cc_data_pair (uint8_t *cc_data_pair)

+{

+    uint8_t cc_valid = (*cc_data_pair & 4) >>2;

+    uint8_t cc_type = *cc_data_pair & 3;

+

+    if (!cc_valid)

+        return AVERROR_INVALIDDATA;

+

+    // if EIA-608 data then verify parity.

+    if (cc_type==0 || cc_type==1) {

+        if (!parity_table[cc_data_pair[2]]) {

+            return AVERROR_INVALIDDATA;

+        }

+        if (!parity_table[cc_data_pair[1]]) {

+            cc_data_pair[1]=0x7F;

+        }

+    }

+

+    //Skip non-data

+    if( (cc_data_pair[0] == 0xFA || cc_data_pair[0] == 0xFC || cc_data_pair[0] == 0xFD )

+         && (cc_data_pair[1] & 0x7F) == 0 && (cc_data_pair[2] & 0x7F) == 0)

+        return AVERROR_PATCHWELCOME;

+

+    //skip 708 data

+    if(cc_type == 3 || cc_type == 2 )

+        return AVERROR_PATCHWELCOME;

+

+    /* remove parity bit */

+    cc_data_pair[1] &= 0x7F;

+    cc_data_pair[2] &= 0x7F;

+

+

+    return 0;

+

+}

+

+static struct Screen *get_writing_screen(CCaptionSubContext *ctx)

+{

+    switch (ctx->mode) {

+    case CCMODE_POPON:

+        // use Inactive screen

+        return ctx->screen + !ctx->active_screen;

+    case CCMODE_PAINTON:

+    case CCMODE_ROLLUP_2:

+    case CCMODE_ROLLUP_3:

+    case CCMODE_ROLLUP_4:

+    case CCMODE_TEXT:

+        // use active screen

+        return ctx->screen + ctx->active_screen;

+    }

+    /* It was never an option */

+    return NULL;

+}

+

+static void handle_textattr( CCaptionSubContext *ctx, uint8_t hi, uint8_t lo )

+{

+    int i = lo - 0x20;

+    int ret;

+    struct Screen *screen = get_writing_screen(ctx);

+    char *row = screen->characters[ctx->cursor_row];

+

+    if( i >= 32)

+        return;

+

+    ctx->cursor_color =  pac2_attribs[i][0];

+    ctx->cursor_font = pac2_attribs[i][1];

+

+    SET_FLAG(screen->row_used,ctx->cursor_row);

+    ret = write_char(ctx, row, ctx->cursor_column, ' ');

+    if(ret == 0)

+        ctx->cursor_column++;

+}

+static void handle_pac( CCaptionSubContext *ctx, uint8_t hi, uint8_t lo )

+{

+    static const int8_t row_map[] = {

+        11, -1, 1, 2, 3, 4, 12, 13, 14, 15, 5, 6, 7, 8, 9, 10

+    };

+    const int index = ( (hi<<1) & 0x0e) | ( (lo>>5) & 0x01 );

+    struct Screen *screen = get_writing_screen(ctx);

+    char *row;

+    int indent,i,ret;

+

+    if( row_map[index] <= 0 )

+        return;

+

+    lo &= 0x1f;

+

+    ctx->cursor_row = row_map[index] - 1;

+    ctx->cursor_color =  pac2_attribs[lo][0];

+    ctx->cursor_font = pac2_attribs[lo][1];

+    ctx->cursor_column = 0;

+    indent = pac2_attribs[lo][2];

+    row = screen->characters[ctx->cursor_row];

+    for(i = 0;i < indent; i++) {

+        ret = write_char(ctx, row, ctx->cursor_column, ' ');

+        if(  ret == 0 )

+            ctx->cursor_column++;

+    }

+

+}

+

+/**

+ * @param pts it is required to set end time

+ */

+static int handle_edm(CCaptionSubContext *ctx,int64_t pts)

+{

+    int i;

+    int ret = 0;

+    struct Screen *screen = ctx->screen + ctx->active_screen;

+

+    ctx->start_time = ctx->startv_time;

+    for( i = 0; screen->row_used && i < SCREEN_ROWS; i++)

+    {

+        if(CHECK_FLAG(screen->row_used,i)) {

+            char *str = screen->characters[i];

+            /* skip space */

+            while (*str == ' ')

+                str++;

+            av_bprint_append_data(&ctx->buffer, str, strlen(str));

+            av_bprint_append_data(&ctx->buffer, "\\N",2);

+            UNSET_FLAG(screen->row_used, i);

+            ret = av_bprint_is_complete(&ctx->buffer);

+            if( ret == 0) {

+                ret = AVERROR(ENOMEM);

+                break;

+            }

+        }

+

+    }

+    ctx->startv_time = pts;

+    ctx->erase_display_memory = 1;

+    ctx->end_time = pts;

+    return ret;

+}

+static int handle_eoc(CCaptionSubContext *ctx, int64_t pts)

+{

+    int ret;

+    ret = handle_edm(ctx,pts);

+    ctx->active_screen = !ctx->active_screen;

+    ctx->cursor_column = 0;

+    return ret;

+}

+static void handle_delete_end_of_row( CCaptionSubContext *ctx, char hi, char lo)

+{

+    struct Screen *screen = get_writing_screen(ctx);

+    char *row = screen->characters[ctx->cursor_row];

+    write_char(ctx, row, ctx->cursor_column, 0);

+

+}

+static void handle_char(CCaptionSubContext *ctx, char hi, char lo, int64_t pts)

+{

+    struct Screen *screen = get_writing_screen(ctx);

+    char *row = screen->characters[ctx->cursor_row];

+    int ret;

+

+    SET_FLAG(screen->row_used,ctx->cursor_row);

+

+    ret = write_char(ctx, row, ctx->cursor_column, hi);

+    if( ret == 0 )

+        ctx->cursor_column++;

+

+    if(lo) {

+        ret = write_char(ctx, row, ctx->cursor_column, lo);

+        if ( ret == 0 )

+            ctx->cursor_column++;

+    }

+    write_char(ctx, row, ctx->cursor_column, 0);

+

+    /* reset prev command since character can repeat */

+    ctx->prev_cmd[0] = 0;

+    ctx->prev_cmd[1] = 0;

+#ifdef CHAR_DEBUG

+    av_log(ctx, AV_LOG_DEBUG,"(%c,%c)\n",hi,lo);

+#endif

+}

+static int process_cc608(CCaptionSubContext *ctx, int64_t pts, uint8_t hi, uint8_t lo)

+{

+    int ret = 0;

+#define COR3(var, with1, with2, with3)  ( (var) == (with1) ||  (var) == (with2) || (var) == (with3) )

+    if ( hi == ctx->prev_cmd[0] && lo == ctx->prev_cmd[1]) {

+    /* ignore redundant command */

+    } else if ( (hi == 0x10 && (lo >= 0x40 || lo <= 0x5f)) ||

+              ( (hi >= 0x11 && hi <= 0x17) && (lo >= 0x40 && lo <= 0x7f) ) ) {

+        handle_pac(ctx, hi, lo);

+    } else if ( ( hi == 0x11 && lo >= 0x20 && lo <= 0x2f ) ||

+                ( hi == 0x17 && lo >= 0x2e && lo <= 0x2f) ) {

+        handle_textattr(ctx, hi, lo);

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x20 ) {

+    /* resume caption loading */

+        ctx->mode = CCMODE_POPON;

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x24 ) {

+        handle_delete_end_of_row(ctx, hi, lo);

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x25 ) {

+        ctx->rollup = 2;

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x26 ) {

+        ctx->rollup = 3;

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x27 ) {

+        ctx->rollup = 4;

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x29 ) {

+    /* resume direct captioning */

+        ctx->mode = CCMODE_PAINTON;

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x2B ) {

+    /* resume text display */

+        ctx->mode = CCMODE_TEXT;

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x2C ) {

+    /* erase display memory */

+        ret = handle_edm(ctx, pts);

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x2D ) {

+    /* carriage return */

+        ctx->row_cnt++;

+        if(ctx->row_cnt >= ctx->rollup) {

+            ctx->row_cnt = 0;

+            ret = handle_edm(ctx, pts);

+            ctx->active_screen = !ctx->active_screen;

+        }

+        ctx->cursor_column = 0;

+    } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x2F ) {

+    /* end of caption */

+        ret = handle_eoc(ctx, pts);

+    } else if (hi>=0x20) {

+    /* Standard characters (always in pairs) */

+        handle_char(ctx, hi, lo, pts);

+    } else {

+    /* Ignoring all other non data code */

+    }

+

+    /* set prev command */

+     ctx->prev_cmd[0] = hi;

+     ctx->prev_cmd[1] = lo;

+

+#undef COR3

+    return ret;

+

+}

+static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)

+{

+    CCaptionSubContext *ctx = avctx->priv_data;

+    AVSubtitle *sub = data;

+    uint8_t *bptr = NULL;

+    int len = avpkt->size;

+    int ret = 0;

+    int i;

+

+    if ( ctx->pktbuf->size < len) {

+        ret = av_buffer_realloc(&ctx->pktbuf, len);

+         if(ret < 0) {

+            av_log(ctx, AV_LOG_WARNING, "Insufficient Memory of %d truncated to %d\n",len, ctx->pktbuf->size);

+            len = ctx->pktbuf->size;

+            ret = 0;

+        }

+    }

+    memcpy(ctx->pktbuf->data, avpkt->data, len);

+    bptr = ctx->pktbuf->data;

+

+

+    for (i  = 0; i < len; i += 3) {

+        uint8_t cc_type = *(bptr + i) & 3;

+        if (validate_cc_data_pair( bptr + i) )

+            continue;

+        /* ignoring data field 1 */

+        if(cc_type == 1)

+            continue;

+        else

+            process_cc608(ctx, avpkt->pts, *(bptr + i + 1) & 0x7f, *(bptr + i + 2) & 0x7f);

+        if(ctx->erase_display_memory && *ctx->buffer.str)

+        {

+            int start_time = av_rescale_q(ctx->start_time, avctx->time_base, (AVRational){ 1, 100 });

+            int end_time = av_rescale_q(ctx->end_time, avctx->time_base, (AVRational){ 1, 100 });

+#ifdef CHAR_DEBUG

+            av_log(ctx, AV_LOG_DEBUG,"cdp writing data (%s)\n",ctx->buffer.str);

+#endif

+            ret = ff_ass_add_rect(sub, ctx->buffer.str, start_time, end_time - start_time , 0);

+            if (ret < 0)

+                return ret;

+            sub->pts = av_rescale_q(ctx->start_time, avctx->time_base, AV_TIME_BASE_Q);

+            ctx->erase_display_memory = 0;

+            av_bprint_clear(&ctx->buffer);

+        }

+    }

+

+    *got_sub = sub->num_rects > 0;

+    return ret;

+}

+static const AVOption options[] = {

+    {NULL}

+};

+static const AVClass ccaption_dec_class = {

+    .class_name = "Closed caption Decoder",

+    .item_name  = av_default_item_name,

+    .option     = options,

+    .version    = LIBAVUTIL_VERSION_INT,

+};

+

+AVCodec ff_ccaption_decoder = {

+    .name           = "cc_dec",

+    .long_name      = NULL_IF_CONFIG_SMALL("Closed Caption (EIA-608 / CEA-708) Decoder"),

+    .type           = AVMEDIA_TYPE_SUBTITLE,

+    .id             = AV_CODEC_ID_EIA_608,

+    .priv_data_size = sizeof(CCaptionSubContext),

+    .init           = init_decoder,

+    .close          = close_decoder,

+    .decode         = decode,

+    .priv_class     = &ccaption_dec_class,

+};