git.sesse.net Git - ffmpeg/blob - libavcodec/ccaption_dec.c

   1 /*
   2  * Closed Caption Decoding
   3  * Copyright (c) 2015 Anshul Maheshwari
   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/internal.h"
  25 #include "libavutil/opt.h"
  26
  27 #define SCREEN_ROWS 15
  28 #define SCREEN_COLUMNS 32
  29
  30 #define SET_FLAG(var, val)   ( (var) |=   ( 1 << (val)) )
  31 #define UNSET_FLAG(var, val) ( (var) &=  ~( 1 << (val)) )
  32 #define CHECK_FLAG(var, val) ( (var) &    ( 1 << (val)) )
  33
  34 /*
  35  * TODO list
  36  * 1) handle font and color completely
  37  */
  38 enum cc_mode {
  39     CCMODE_POPON,
  40     CCMODE_PAINTON,
  41     CCMODE_ROLLUP_2,
  42     CCMODE_ROLLUP_3,
  43     CCMODE_ROLLUP_4,
  44     CCMODE_TEXT,
  45 };
  46
  47 enum cc_color_code {
  48     CCCOL_WHITE,
  49     CCCOL_GREEN,
  50     CCCOL_BLUE,
  51     CCCOL_CYAN,
  52     CCCOL_RED,
  53     CCCOL_YELLOW,
  54     CCCOL_MAGENTA,
  55     CCCOL_USERDEFINED,
  56     CCCOL_BLACK,
  57     CCCOL_TRANSPARENT,
  58 };
  59
  60 enum cc_font {
  61     CCFONT_REGULAR,
  62     CCFONT_ITALICS,
  63     CCFONT_UNDERLINED,
  64     CCFONT_UNDERLINED_ITALICS,
  65 };
  66
  67 static const unsigned char pac2_attribs[32][3] = // Color, font, ident
  68 {
  69     { CCCOL_WHITE,   CCFONT_REGULAR,            0 },  // 0x40 || 0x60
  70     { CCCOL_WHITE,   CCFONT_UNDERLINED,         0 },  // 0x41 || 0x61
  71     { CCCOL_GREEN,   CCFONT_REGULAR,            0 },  // 0x42 || 0x62
  72     { CCCOL_GREEN,   CCFONT_UNDERLINED,         0 },  // 0x43 || 0x63
  73     { CCCOL_BLUE,    CCFONT_REGULAR,            0 },  // 0x44 || 0x64
  74     { CCCOL_BLUE,    CCFONT_UNDERLINED,         0 },  // 0x45 || 0x65
  75     { CCCOL_CYAN,    CCFONT_REGULAR,            0 },  // 0x46 || 0x66
  76     { CCCOL_CYAN,    CCFONT_UNDERLINED,         0 },  // 0x47 || 0x67
  77     { CCCOL_RED,     CCFONT_REGULAR,            0 },  // 0x48 || 0x68
  78     { CCCOL_RED,     CCFONT_UNDERLINED,         0 },  // 0x49 || 0x69
  79     { CCCOL_YELLOW,  CCFONT_REGULAR,            0 },  // 0x4a || 0x6a
  80     { CCCOL_YELLOW,  CCFONT_UNDERLINED,         0 },  // 0x4b || 0x6b
  81     { CCCOL_MAGENTA, CCFONT_REGULAR,            0 },  // 0x4c || 0x6c
  82     { CCCOL_MAGENTA, CCFONT_UNDERLINED,         0 },  // 0x4d || 0x6d
  83     { CCCOL_WHITE,   CCFONT_ITALICS,            0 },  // 0x4e || 0x6e
  84     { CCCOL_WHITE,   CCFONT_UNDERLINED_ITALICS, 0 },  // 0x4f || 0x6f
  85     { CCCOL_WHITE,   CCFONT_REGULAR,            0 },  // 0x50 || 0x70
  86     { CCCOL_WHITE,   CCFONT_UNDERLINED,         0 },  // 0x51 || 0x71
  87     { CCCOL_WHITE,   CCFONT_REGULAR,            4 },  // 0x52 || 0x72
  88     { CCCOL_WHITE,   CCFONT_UNDERLINED,         4 },  // 0x53 || 0x73
  89     { CCCOL_WHITE,   CCFONT_REGULAR,            8 },  // 0x54 || 0x74
  90     { CCCOL_WHITE,   CCFONT_UNDERLINED,         8 },  // 0x55 || 0x75
  91     { CCCOL_WHITE,   CCFONT_REGULAR,           12 },  // 0x56 || 0x76
  92     { CCCOL_WHITE,   CCFONT_UNDERLINED,        12 },  // 0x57 || 0x77
  93     { CCCOL_WHITE,   CCFONT_REGULAR,           16 },  // 0x58 || 0x78
  94     { CCCOL_WHITE,   CCFONT_UNDERLINED,        16 },  // 0x59 || 0x79
  95     { CCCOL_WHITE,   CCFONT_REGULAR,           20 },  // 0x5a || 0x7a
  96     { CCCOL_WHITE,   CCFONT_UNDERLINED,        20 },  // 0x5b || 0x7b
  97     { CCCOL_WHITE,   CCFONT_REGULAR,           24 },  // 0x5c || 0x7c
  98     { CCCOL_WHITE,   CCFONT_UNDERLINED,        24 },  // 0x5d || 0x7d
  99     { CCCOL_WHITE,   CCFONT_REGULAR,           28 },  // 0x5e || 0x7e
 100     { CCCOL_WHITE,   CCFONT_UNDERLINED,        28 }   // 0x5f || 0x7f
 101     /* total 32 entries */
 102 };
 103
 104 /* 0-255 needs 256 spaces */
 105 static const uint8_t parity_table[256] = { 0, 1, 1, 0, 1, 0, 0, 1,
 106                                            1, 0, 0, 1, 0, 1, 1, 0,
 107                                            1, 0, 0, 1, 0, 1, 1, 0,
 108                                            0, 1, 1, 0, 1, 0, 0, 1,
 109                                            1, 0, 0, 1, 0, 1, 1, 0,
 110                                            0, 1, 1, 0, 1, 0, 0, 1,
 111                                            0, 1, 1, 0, 1, 0, 0, 1,
 112                                            1, 0, 0, 1, 0, 1, 1, 0,
 113                                            1, 0, 0, 1, 0, 1, 1, 0,
 114                                            0, 1, 1, 0, 1, 0, 0, 1,
 115                                            0, 1, 1, 0, 1, 0, 0, 1,
 116                                            1, 0, 0, 1, 0, 1, 1, 0,
 117                                            0, 1, 1, 0, 1, 0, 0, 1,
 118                                            1, 0, 0, 1, 0, 1, 1, 0,
 119                                            1, 0, 0, 1, 0, 1, 1, 0,
 120                                            0, 1, 1, 0, 1, 0, 0, 1,
 121                                            1, 0, 0, 1, 0, 1, 1, 0,
 122                                            0, 1, 1, 0, 1, 0, 0, 1,
 123                                            0, 1, 1, 0, 1, 0, 0, 1,
 124                                            1, 0, 0, 1, 0, 1, 1, 0,
 125                                            0, 1, 1, 0, 1, 0, 0, 1,
 126                                            1, 0, 0, 1, 0, 1, 1, 0,
 127                                            1, 0, 0, 1, 0, 1, 1, 0,
 128                                            0, 1, 1, 0, 1, 0, 0, 1,
 129                                            0, 1, 1, 0, 1, 0, 0, 1,
 130                                            1, 0, 0, 1, 0, 1, 1, 0,
 131                                            1, 0, 0, 1, 0, 1, 1, 0,
 132                                            0, 1, 1, 0, 1, 0, 0, 1,
 133                                            1, 0, 0, 1, 0, 1, 1, 0,
 134                                            0, 1, 1, 0, 1, 0, 0, 1,
 135                                            0, 1, 1, 0, 1, 0, 0, 1,
 136                                            1, 0, 0, 1, 0, 1, 1, 0 };
 137
 138 struct Screen {
 139     /* +1 is used to compensate null character of string */
 140     uint8_t characters[SCREEN_ROWS][SCREEN_COLUMNS+1];
 141     uint8_t colors[SCREEN_ROWS][SCREEN_COLUMNS+1];
 142     uint8_t fonts[SCREEN_ROWS][SCREEN_COLUMNS+1];
 143     /*
 144      * Bitmask of used rows; if a bit is not set, the
 145      * corresponding row is not used.
 146      * for setting row 1  use row | (1 << 0)
 147      * for setting row 15 use row | (1 << 14)
 148      */
 149     int16_t  row_used;
 150 };
 151
 152
 153 typedef struct CCaptionSubContext {
 154     AVClass *class;
 155     struct Screen screen[2];
 156     int active_screen;
 157     uint8_t cursor_row;
 158     uint8_t cursor_column;
 159     uint8_t cursor_color;
 160     uint8_t cursor_font;
 161     AVBPrint buffer;
 162     int screen_changed;
 163     int rollup;
 164     enum  cc_mode mode;
 165     int64_t start_time;
 166     /* visible screen time */
 167     int64_t startv_time;
 168     int64_t end_time;
 169     char prev_cmd[2];
 170     /* buffer to store pkt data */
 171     AVBufferRef *pktbuf;
 172 }CCaptionSubContext;
 173
 174
 175 static av_cold int init_decoder(AVCodecContext *avctx)
 176 {
 177     int ret;
 178     CCaptionSubContext *ctx = avctx->priv_data;
 179
 180     av_bprint_init(&ctx->buffer, 0, AV_BPRINT_SIZE_UNLIMITED);
 181     /* taking by default roll up to 2 */
 182     ctx->mode = CCMODE_ROLLUP_2;
 183     ctx->rollup = 2;
 184     ret = ff_ass_subtitle_header_default(avctx);
 185     if(ret < 0) {
 186         return ret;
 187     }
 188     /* allocate pkt buffer */
 189     ctx->pktbuf = av_buffer_alloc(128);
 190     if( !ctx->pktbuf) {
 191         ret = AVERROR(ENOMEM);
 192     }
 193     return ret;
 194 }
 195
 196 static av_cold int close_decoder(AVCodecContext *avctx)
 197 {
 198     CCaptionSubContext *ctx = avctx->priv_data;
 199     av_bprint_finalize( &ctx->buffer, NULL);
 200     av_buffer_unref(&ctx->pktbuf);
 201     return 0;
 202 }
 203
 204 /**
 205  * @param ctx closed caption context just to print log
 206  */
 207 static int write_char (CCaptionSubContext *ctx, char *row,uint8_t col, char ch)
 208 {
 209     if(col < SCREEN_COLUMNS) {
 210         row[col] = ch;
 211         return 0;
 212     }
 213     /* We have extra space at end only for null character */
 214     else if ( col == SCREEN_COLUMNS && ch == 0) {
 215         row[col] = ch;
 216         return 0;
 217     }
 218     else {
 219         av_log(ctx, AV_LOG_WARNING,"Data Ignored since exceeding screen width\n");
 220         return AVERROR_INVALIDDATA;
 221     }
 222 }
 223
 224 /**
 225  * This function after validating parity bit, also remove it from data pair.
 226  * The first byte doesn't pass parity, we replace it with a solid blank
 227  * and process the pair.
 228  * If the second byte doesn't pass parity, it returns INVALIDDATA
 229  * user can ignore the whole pair and pass the other pair.
 230  */
 231 static int validate_cc_data_pair (uint8_t *cc_data_pair)
 232 {
 233     uint8_t cc_valid = (*cc_data_pair & 4) >>2;
 234     uint8_t cc_type = *cc_data_pair & 3;
 235
 236     if (!cc_valid)
 237         return AVERROR_INVALIDDATA;
 238
 239     // if EIA-608 data then verify parity.
 240     if (cc_type==0 || cc_type==1) {
 241         if (!parity_table[cc_data_pair[2]]) {
 242             return AVERROR_INVALIDDATA;
 243         }
 244         if (!parity_table[cc_data_pair[1]]) {
 245             cc_data_pair[1]=0x7F;
 246         }
 247     }
 248
 249     //Skip non-data
 250     if( (cc_data_pair[0] == 0xFA || cc_data_pair[0] == 0xFC || cc_data_pair[0] == 0xFD )
 251          && (cc_data_pair[1] & 0x7F) == 0 && (cc_data_pair[2] & 0x7F) == 0)
 252         return AVERROR_PATCHWELCOME;
 253
 254     //skip 708 data
 255     if(cc_type == 3 || cc_type == 2 )
 256         return AVERROR_PATCHWELCOME;
 257
 258     /* remove parity bit */
 259     cc_data_pair[1] &= 0x7F;
 260     cc_data_pair[2] &= 0x7F;
 261
 262
 263     return 0;
 264
 265 }
 266
 267 static struct Screen *get_writing_screen(CCaptionSubContext *ctx)
 268 {
 269     switch (ctx->mode) {
 270     case CCMODE_POPON:
 271         // use Inactive screen
 272         return ctx->screen + !ctx->active_screen;
 273     case CCMODE_PAINTON:
 274     case CCMODE_ROLLUP_2:
 275     case CCMODE_ROLLUP_3:
 276     case CCMODE_ROLLUP_4:
 277     case CCMODE_TEXT:
 278         // use active screen
 279         return ctx->screen + ctx->active_screen;
 280     }
 281     /* It was never an option */
 282     return NULL;
 283 }
 284
 285 static void roll_up(CCaptionSubContext *ctx)
 286 {
 287     struct Screen *screen;
 288     int i, keep_lines;
 289
 290     if(ctx->mode == CCMODE_TEXT)
 291         return;
 292
 293     screen = get_writing_screen(ctx);
 294
 295     /* +1 signify cursor_row starts from 0
 296      * Can't keep lines less then row cursor pos
 297      */
 298     keep_lines = FFMIN(ctx->cursor_row + 1, ctx->rollup);
 299
 300     for( i = 0; i < ctx->cursor_row - keep_lines; i++ )
 301         UNSET_FLAG(screen->row_used, i);
 302
 303
 304     for( i = 0; i < keep_lines && screen->row_used; i++ ) {
 305         const int i_row = ctx->cursor_row - keep_lines + i + 1;
 306
 307         memcpy( screen->characters[i_row], screen->characters[i_row+1], SCREEN_COLUMNS );
 308         memcpy( screen->colors[i_row], screen->colors[i_row+1], SCREEN_COLUMNS);
 309         memcpy( screen->fonts[i_row], screen->fonts[i_row+1], SCREEN_COLUMNS);
 310         if(CHECK_FLAG(screen->row_used, i_row + 1))
 311             SET_FLAG(screen->row_used, i_row);
 312
 313     }
 314     UNSET_FLAG(screen->row_used, ctx->cursor_row);
 315
 316 }
 317
 318 static int reap_screen(CCaptionSubContext *ctx, int64_t pts)
 319 {
 320     int i;
 321     int ret = 0;
 322     struct Screen *screen = ctx->screen + ctx->active_screen;
 323     ctx->start_time = ctx->startv_time;
 324
 325     for( i = 0; screen->row_used && i < SCREEN_ROWS; i++)
 326     {
 327         if(CHECK_FLAG(screen->row_used,i)) {
 328             char *str = screen->characters[i];
 329             /* skip space */
 330             while (*str == ' ')
 331                 str++;
 332
 333             av_bprintf(&ctx->buffer, "%s\\N", str);
 334             ret = av_bprint_is_complete(&ctx->buffer);
 335             if( ret == 0) {
 336                 ret = AVERROR(ENOMEM);
 337                 break;
 338             }
 339         }
 340
 341     }
 342     if(screen->row_used && ctx->buffer.len >= 2 ) {
 343         ctx->buffer.len -= 2;
 344         ctx->buffer.str[ctx->buffer.len] = 0;
 345     }
 346     ctx->startv_time = pts;
 347     ctx->end_time = pts;
 348     return ret;
 349 }
 350
 351 static void handle_textattr( CCaptionSubContext *ctx, uint8_t hi, uint8_t lo )
 352 {
 353     int i = lo - 0x20;
 354     int ret;
 355     struct Screen *screen = get_writing_screen(ctx);
 356     char *row = screen->characters[ctx->cursor_row];
 357
 358     if( i >= 32)
 359         return;
 360
 361     ctx->cursor_color =  pac2_attribs[i][0];
 362     ctx->cursor_font = pac2_attribs[i][1];
 363
 364     SET_FLAG(screen->row_used,ctx->cursor_row);
 365     ret = write_char(ctx, row, ctx->cursor_column, ' ');
 366     if(ret == 0)
 367         ctx->cursor_column++;
 368 }
 369
 370 static void handle_pac( CCaptionSubContext *ctx, uint8_t hi, uint8_t lo )
 371 {
 372     static const int8_t row_map[] = {
 373         11, -1, 1, 2, 3, 4, 12, 13, 14, 15, 5, 6, 7, 8, 9, 10
 374     };
 375     const int index = ( (hi<<1) & 0x0e) | ( (lo>>5) & 0x01 );
 376     struct Screen *screen = get_writing_screen(ctx);
 377     char *row;
 378     int indent,i,ret;
 379
 380     if( row_map[index] <= 0 ) {
 381         av_log(ctx, AV_LOG_DEBUG,"Invalid pac index encountered\n");
 382         return;
 383     }
 384
 385     lo &= 0x1f;
 386
 387     ctx->cursor_row = row_map[index] - 1;
 388     ctx->cursor_color =  pac2_attribs[lo][0];
 389     ctx->cursor_font = pac2_attribs[lo][1];
 390     ctx->cursor_column = 0;
 391     indent = pac2_attribs[lo][2];
 392     row = screen->characters[ctx->cursor_row];
 393     for(i = 0;i < indent; i++) {
 394         ret = write_char(ctx, row, ctx->cursor_column, ' ');
 395         if(  ret == 0 )
 396             ctx->cursor_column++;
 397     }
 398
 399 }
 400
 401 /**
 402  * @param pts it is required to set end time
 403  */
 404 static int handle_edm(CCaptionSubContext *ctx,int64_t pts)
 405 {
 406     int ret = 0;
 407     struct Screen *screen = ctx->screen + ctx->active_screen;
 408
 409     reap_screen(ctx, pts);
 410     screen->row_used = 0;
 411     ctx->screen_changed = 1;
 412     return ret;
 413 }
 414
 415 static int handle_eoc(CCaptionSubContext *ctx, int64_t pts)
 416 {
 417     int ret;
 418     ret = handle_edm(ctx,pts);
 419     ctx->active_screen = !ctx->active_screen;
 420     ctx->cursor_column = 0;
 421     return ret;
 422 }
 423
 424 static void handle_delete_end_of_row( CCaptionSubContext *ctx, char hi, char lo)
 425 {
 426     struct Screen *screen = get_writing_screen(ctx);
 427     char *row = screen->characters[ctx->cursor_row];
 428     write_char(ctx, row, ctx->cursor_column, 0);
 429
 430 }
 431
 432 static void handle_char(CCaptionSubContext *ctx, char hi, char lo, int64_t pts)
 433 {
 434     struct Screen *screen = get_writing_screen(ctx);
 435     char *row = screen->characters[ctx->cursor_row];
 436     int ret;
 437
 438     SET_FLAG(screen->row_used,ctx->cursor_row);
 439
 440     ret = write_char(ctx, row, ctx->cursor_column, hi);
 441     if( ret == 0 )
 442         ctx->cursor_column++;
 443
 444     if(lo) {
 445         ret = write_char(ctx, row, ctx->cursor_column, lo);
 446         if ( ret == 0 )
 447             ctx->cursor_column++;
 448     }
 449     write_char(ctx, row, ctx->cursor_column, 0);
 450
 451     /* reset prev command since character can repeat */
 452     ctx->prev_cmd[0] = 0;
 453     ctx->prev_cmd[1] = 0;
 454     if (lo)
 455        ff_dlog(ctx, "(%c,%c)\n",hi,lo);
 456     else
 457        ff_dlog(ctx, "(%c)\n",hi);
 458 }
 459
 460 static int process_cc608(CCaptionSubContext *ctx, int64_t pts, uint8_t hi, uint8_t lo)
 461 {
 462     int ret = 0;
 463 #define COR3(var, with1, with2, with3)  ( (var) == (with1) ||  (var) == (with2) || (var) == (with3) )
 464     if ( hi == ctx->prev_cmd[0] && lo == ctx->prev_cmd[1]) {
 465     /* ignore redundant command */
 466     } else if ( (hi == 0x10 && (lo >= 0x40 || lo <= 0x5f)) ||
 467               ( (hi >= 0x11 && hi <= 0x17) && (lo >= 0x40 && lo <= 0x7f) ) ) {
 468         handle_pac(ctx, hi, lo);
 469     } else if ( ( hi == 0x11 && lo >= 0x20 && lo <= 0x2f ) ||
 470                 ( hi == 0x17 && lo >= 0x2e && lo <= 0x2f) ) {
 471         handle_textattr(ctx, hi, lo);
 472     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x20 ) {
 473     /* resume caption loading */
 474         ctx->mode = CCMODE_POPON;
 475     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x24 ) {
 476         handle_delete_end_of_row(ctx, hi, lo);
 477     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x25 ) {
 478         ctx->rollup = 2;
 479         ctx->mode = CCMODE_ROLLUP_2;
 480     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x26 ) {
 481         ctx->rollup = 3;
 482         ctx->mode = CCMODE_ROLLUP_3;
 483     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x27 ) {
 484         ctx->rollup = 4;
 485         ctx->mode = CCMODE_ROLLUP_4;
 486     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x29 ) {
 487     /* resume direct captioning */
 488         ctx->mode = CCMODE_PAINTON;
 489     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x2B ) {
 490     /* resume text display */
 491         ctx->mode = CCMODE_TEXT;
 492     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x2C ) {
 493     /* erase display memory */
 494         ret = handle_edm(ctx, pts);
 495     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x2D ) {
 496     /* carriage return */
 497         ff_dlog(ctx, "carriage return\n");
 498         reap_screen(ctx, pts);
 499         roll_up(ctx);
 500         ctx->screen_changed = 1;
 501         ctx->cursor_column = 0;
 502     } else if ( COR3(hi, 0x14, 0x15, 0x1C) && lo == 0x2F ) {
 503     /* end of caption */
 504         ff_dlog(ctx, "handle_eoc\n");
 505         ret = handle_eoc(ctx, pts);
 506     } else if (hi>=0x20) {
 507     /* Standard characters (always in pairs) */
 508         handle_char(ctx, hi, lo, pts);
 509     } else {
 510     /* Ignoring all other non data code */
 511         ff_dlog(ctx, "Unknown command 0x%hhx 0x%hhx\n", hi, lo);
 512     }
 513
 514     /* set prev command */
 515      ctx->prev_cmd[0] = hi;
 516      ctx->prev_cmd[1] = lo;
 517
 518 #undef COR3
 519     return ret;
 520
 521 }
 522
 523 static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
 524 {
 525     CCaptionSubContext *ctx = avctx->priv_data;
 526     AVSubtitle *sub = data;
 527     uint8_t *bptr = NULL;
 528     int len = avpkt->size;
 529     int ret = 0;
 530     int i;
 531
 532     if ( ctx->pktbuf->size < len) {
 533         ret = av_buffer_realloc(&ctx->pktbuf, len);
 534          if(ret < 0) {
 535             av_log(ctx, AV_LOG_WARNING, "Insufficient Memory of %d truncated to %d\n",len, ctx->pktbuf->size);
 536             len = ctx->pktbuf->size;
 537             ret = 0;
 538         }
 539     }
 540     memcpy(ctx->pktbuf->data, avpkt->data, len);
 541     bptr = ctx->pktbuf->data;
 542
 543
 544     for (i  = 0; i < len; i += 3) {
 545         uint8_t cc_type = *(bptr + i) & 3;
 546         if (validate_cc_data_pair( bptr + i) )
 547             continue;
 548         /* ignoring data field 1 */
 549         if(cc_type == 1)
 550             continue;
 551         else
 552             process_cc608(ctx, avpkt->pts, *(bptr + i + 1) & 0x7f, *(bptr + i + 2) & 0x7f);
 553         if(ctx->screen_changed && *ctx->buffer.str)
 554         {
 555             int start_time = av_rescale_q(ctx->start_time, avctx->time_base, (AVRational){ 1, 100 });
 556             int end_time = av_rescale_q(ctx->end_time, avctx->time_base, (AVRational){ 1, 100 });
 557             ff_dlog(ctx, "cdp writing data (%s)\n",ctx->buffer.str);
 558             ret = ff_ass_add_rect_bprint(sub, &ctx->buffer, start_time, end_time - start_time);
 559             if (ret < 0)
 560                 return ret;
 561             sub->pts = av_rescale_q(ctx->start_time, avctx->time_base, AV_TIME_BASE_Q);
 562             ctx->screen_changed = 0;
 563             av_bprint_clear(&ctx->buffer);
 564         }
 565     }
 566
 567     *got_sub = sub->num_rects > 0;
 568     return ret;
 569 }
 570
 571 static const AVOption options[] = {
 572     {NULL}
 573 };
 574
 575 static const AVClass ccaption_dec_class = {
 576     .class_name = "Closed caption Decoder",
 577     .item_name  = av_default_item_name,
 578     .option     = options,
 579     .version    = LIBAVUTIL_VERSION_INT,
 580 };
 581
 582 AVCodec ff_ccaption_decoder = {
 583     .name           = "cc_dec",
 584     .long_name      = NULL_IF_CONFIG_SMALL("Closed Caption (EIA-608 / CEA-708) Decoder"),
 585     .type           = AVMEDIA_TYPE_SUBTITLE,
 586     .id             = AV_CODEC_ID_EIA_608,
 587     .priv_data_size = sizeof(CCaptionSubContext),
 588     .init           = init_decoder,
 589     .close          = close_decoder,
 590     .decode         = decode,
 591     .priv_class     = &ccaption_dec_class,
 592 };