cinelerra-5.1/libzmpeg3/video/cc.C

   1 #include "../libzmpeg3.h"
   2
   3 zcc_t::
   4 cc_t(video_t *video)
   5  : svc(this)
   6 {
   7   this->video = video;
   8   reset();
   9 }
  10
  11 zcc_t::
  12 ~cc_t()
  13 {
  14 }
  15
  16 void zcc_t::
  17 reset()
  18 {
  19 //zmsg(" cc\n");
  20   frs_history = 0;
  21   text_cb = 0;
  22   font_size = fsz_normal;
  23   video->reset_subtitles();
  24   int sid = video->subtitle_track+1;
  25   if( sid <= 0 || sid > MX_SVC ) sid = 1;
  26   svc.reset(sid, this);
  27 }
  28
  29 void zcc_t::
  30 get_atsc_data(zbits_t *s)
  31 {
  32   /* xfer data to data[0], first byte = total size */
  33   /*   <dat[1]=isz,dat[2..isz+1]=input, ...,0> */
  34   int b = s->get_bits(8) & 0x1f;
  35   int len = b & 0x1f;
  36   uint8_t *dat = &data[0][0];
  37   dat[0] = 0;
  38   uint8_t *bp = dat+1;
  39   uint8_t *cp = bp+1;
  40 //zmsgs(" len=%d\n",len);
  41   s->get_bits(8); /* rsvd */
  42
  43   for( int i=0; i<len; ++i ) {
  44     int typ = s->get_bits(8);
  45     if( (typ & 0xf8) != 0xf8 ) return;
  46     int valid = typ & 0x04;
  47     int ch1 = s->get_bits(8);
  48     int ch2 = s->get_bits(8);
  49 //zmsgs("*** typ %02x  %02x %02x\n",typ,ch1,ch2);
  50     int isz = cp-bp - 1;
  51     switch( typ &= 0x03 ) {
  52     case 0x02: /* dvb_data */
  53       if( isz == 0 ) continue; /* missed start */
  54       break;
  55     case 0x03: /* dvb_start */
  56       if( isz > 0 ) { *bp = isz;  bp = cp++; }
  57       break;
  58     case 0x00: /* ntsc_f1 */
  59     case 0x01: /* ntsc_f2 */
  60       continue;
  61     }
  62     if( !valid ) continue;
  63     if( cp-dat+2 > 128 ) {
  64       zerr("closed caption data ovfl\n");
  65       return;
  66     }
  67     *cp++ = ch1;
  68     *cp++ = ch2;
  69   }
  70   /* terminate last recd */
  71   if( (*bp = cp-bp - 1) > 0 ) *cp++ = 0;
  72   /* dat[0] = total size */
  73   dat[0] = cp - dat;
  74 //zmsgs("***** size %d\n",dat[0]);
  75   if( s->get_bits(8) == 0xff ) decode();
  76 }
  77
  78 void zcc_t::
  79 decode()
  80 {
  81   int isz = *data[0];
  82 //zmsgs("seq %d, isz=%d, pict_type %c, pict_struct %3.3s %d\n",
  83 //  data[0][1]>>6,isz," IPBD"[video->pict_type],
  84 //  &"    TOP BTM FRM "[4*video->pict_struct],video->framenum);
  85   switch( video->pict_type ) {
  86   case pic_type_I:
  87   case pic_type_P:
  88     switch( video->pict_struct ) {
  89     case pics_TOP_FIELD:
  90       if( (frs_history & (frs_tf1 | frs_frm)) ) {
  91         decode(1);
  92         frs_history &= ~(frs_tf1 | frs_frm);
  93       }
  94       memcpy(&data[1],&data[0],isz);
  95       frs_history |= frs_tf1;
  96       break;
  97     case pics_BOTTOM_FIELD:
  98       if( (frs_history & frs_frm) ) {
  99         decode(1);
 100         frs_history &= ~frs_frm;
 101       }
 102       else if( (frs_history & frs_bf2) ) {
 103         decode(2);
 104         frs_history &= ~frs_bf2;
 105       }
 106       memcpy(&data[2],&data[1],isz);
 107       frs_history |= frs_bf2;
 108       break;
 109     case pics_FRAME_PICTURE:
 110       if( (frs_history & (frs_tf1 | frs_frm)) ) {
 111         decode(1);
 112         frs_history &= ~(frs_tf1 | frs_frm);
 113       }
 114       if( frs_history & frs_bf2 ) {
 115         decode(2);
 116         frs_history &= ~frs_bf2;
 117       }
 118       memcpy(&data[1],&data[0],isz);
 119       frs_history = frs_frm;
 120       break;
 121     }
 122     break;
 123   case pic_type_B:
 124     if( frs_history == frs_tf1 || frs_history == frs_bf2 )
 125       frs_history = 0;
 126     decode(0);
 127     break;
 128   }
 129   frs_history |= frs_prc;
 130   *data[0] = 0;
 131 }
 132
 133 void zcc_t::
 134 reorder()
 135 {
 136   if( frs_history ) {
 137     if( !(frs_history & frs_prc) )
 138       decode();
 139     frs_history &= ~frs_prc;
 140   }
 141 }
 142
 143 void zcc_t::
 144 decode(int k)
 145 {
 146   int isz;
 147   uint8_t *dat = &data[k][1];
 148   while( (isz = *dat++) > 0 ) {
 149     uint8_t *bp = dat;
 150     uint8_t b = *bp;
 151     int sz = 2 * (b & 0x03f);
 152 #if 0
 153     int seq = b >> 6;
 154     zmsgs("cc decode seq %d size %d/%d -",seq,isz,sz);
 155     int n = isz;
 156     for( int i=0; i<n; ++i ) printf(" %02x",dat[i]);
 157     printf("  ");
 158     for( int i=0; i<n; ++i ) printf(" %c",dat[i]>=0x20&&dat[i]<0x7f?dat[i]:'.');
 159     printf("\n");
 160 #endif
 161     if( sz > isz ) return;
 162     uint8_t *ep = sz + bp++;
 163     while( bp < ep ) {
 164       b = *bp++;
 165       if( !b ) continue;
 166       int svc_nr = b >> 5, blksz = b & 0x1f;
 167       if( svc_nr == 0x07 ) {
 168         if( bp >= ep ) break;
 169         svc_nr = *bp++;
 170         if( svc_nr < 7 || svc_nr > 63 ) break;
 171       }
 172       if( svc_nr == svc.id() && bp+blksz <= ep )
 173         svc.append(bp,blksz);
 174       bp += blksz;
 175     }
 176     dat += isz;
 177   }
 178   svc.decode();
 179 }
 180
 181 zsvc_t::
 182 svc_t(zcc_t *cc)
 183 {
 184   size = 0;
 185   bfrs = 0;
 186   sid = 1;
 187   this->cc = cc;
 188 };
 189
 190 zsvc_t::
 191 ~svc_t()
 192 {
 193   reset(sid, cc);
 194 }
 195
 196 void zsvc_t::
 197 reset(int sid, zcc_t *cc)
 198 {
 199 //zmsgs(" svc %d\n",sid);
 200   size = 0;
 201   this->sid = sid;
 202   int ctrk = sid-1;
 203   if( ctrk < 0 ) ctrk = MX_SVC-1;
 204   this->ctrk = ctrk;
 205   this->cc = cc;
 206   for( int sid=0; sid<MX_WIN; ++sid )
 207     win[sid].reset(sid, this);
 208   for( chr_t *bfr; (bfr=get_bfr()); ) delete [] bfr;
 209 //  win[0].default_window();
 210 //  curw = &win[0];
 211   curw = 0;
 212 }
 213
 214 zchr_t *zsvc_t::
 215 get_bfr()
 216 {
 217   chr_t *bfr = bfrs;
 218   if( bfr ) bfrs = *(chr_t **)bfr;
 219   return bfr;
 220 }
 221
 222 void zsvc_t::
 223 bfr_put(chr_t *&bfr)
 224 {
 225   if( !bfr ) return;
 226   *(chr_t **)bfr = bfrs;
 227   bfrs = bfr;
 228   bfr = 0;
 229 }
 230
 231 void zsvc_t::
 232 append(uint8_t *bp, int len)
 233 {
 234   int n = size+len;
 235   if( n > isizeof(data) ) n = isizeof(data);
 236   for( int i=size; i<n; data[i++]=*bp++);
 237   size = n;
 238 }
 239
 240 void zsvc_t::
 241 decode()
 242 {
 243   if( size == 0 ) return;
 244   bp = data;  ep = bp+size;  size = 0;
 245 //zmsgs(" size=%d,sid=%d\n",(int)(ep-bp),sid);
 246   while( bp < ep ) {
 247     int b = *bp++;
 248     if( (b&0x7f) >= 0x20 ) { // group G0/G1 ascii/latin chars
 249       if( curw && curw->st > st_unmap ) curw->store(b);
 250       continue;
 251     }
 252     if( b < 0x10 || b >= 0x80 ) { // group C0/C1
 253       if( command(b) ) break;
 254       continue;
 255     }
 256     if( b == 0x10 ) {  // ETX1 escape C2/C3, G2/G3
 257       if( bp >= ep ) break;
 258       b = *bp++;       // no valid codes, just skip rsvd bytes
 259       if( b < 0x08 ) continue;                 // 0x00-0x07 C2
 260       if( b < 0x10 ) { bp += 1; continue; }    // 0x08-0x0f C2
 261       if( b < 0x18 ) { bp += 2; continue; }    // 0x10-0x17 C2
 262       if( b < 0x20 ) { bp += 3;  continue; }   // 0x18-0x1f C2
 263       if( b < 0x80 ) continue;  /* misc */     // 0x20-0x7f G2
 264       if( b < 0x88 ) { bp += 4;  continue; }   // 0x80-0x87 C3
 265       if( b < 0x90 ) { bp += 5;  continue; }   // 0x88-0x8f C3
 266       continue;
 267     }
 268     int bb = b & 0x07;          // one byte >ETX1 0x11-0x17
 269     if( bp >= ep ) break;
 270     bb = (bb << 8) | *bp++;
 271     if( b >= 0x18 ) {           // two byte >=P16 0x18-0x20
 272       if( bp >= ep ) break;
 273       bb = (bb << 8) | *bp++;
 274     }
 275     if( curw && curw->st > st_unmap ) curw->store(bb);
 276   }
 277   render();
 278 }
 279
 280 int zsvc_t::
 281 render()
 282 {
 283   /* render dirty windows */
 284   for( int iw=0; iw<MX_WIN; ++iw ) {
 285     win_t *wp = &win[iw];
 286     if( wp->dirty ) {
 287       wp->render();
 288       wp->dirty = 0;
 289     }
 290   }
 291   return 0;
 292 }
 293
 294 int zsvc_t::
 295 command(int cmd)
 296 {
 297   if( cmd == 0x00 || cmd == 0x03 || // nuisance
 298       cmd == 0x8d || cmd == 0x8e ) return 0;
 299 #define CMD(fn,args...) return fn(args)
 300 //zmsgs("cmd %02x svc %d ",cmd,sid);
 301 //#define CMD(fn,args...) printf("%s\n",#fn); return fn(args)
 302   switch( cmd ) {
 303   case 0x03: CMD(ETX);      /* End of text, render */
 304   case 0x08: CMD(BS);       /* Backspace */
 305   case 0x0C: CMD(FF);       /* Form Feed */
 306   case 0x0D: CMD(CR);       /* Carriage Return */
 307   case 0x0E: CMD(HCR);      /* Horizontal Carriage Return */
 308   case 0x80 ... 0x87:
 309     CMD(CWx,cmd & 0x07);    /* SetCurrentWindow */
 310   case 0x88: CMD(CLW);      /* ClearWindows */
 311   case 0x89: CMD(DSW);      /* DisplayWindows */
 312   case 0x8A: CMD(HDW);      /* HideWindows */
 313   case 0x8B: CMD(TGW);      /* ToggleWindows */
 314   case 0x8C: CMD(DLW);      /* DeleteWindows */
 315   case 0x8D: CMD(DLY);      /* Delay */
 316   case 0x8E: CMD(DLC);      /* Delay Cancel */
 317   case 0x8F: CMD(RST);      /* Reset */
 318   case 0x90: CMD(SPA);      /* SetPenAttributes */
 319   case 0x91: CMD(SPC);      /* SetPenColor */
 320   case 0x92: CMD(SPL);      /* SetPenLocation */
 321   case 0x93 ... 0x96:
 322     CMD(RSVD);              /* reserved */
 323   case 0x97: CMD(SWA);      /* SetWindowAttributes */
 324   case 0x98 ... 0x9F:
 325     CMD(DFx,cmd & 0x07);    /* DFx DefineWindow */
 326   }
 327   zerrs("unkn %02x\n",cmd);
 328   return 1;
 329 }
 330
 331 static inline int RGB2Y(int r,int g,int b)
 332 {
 333   return ( 257*r+504*g+ 98*b+ 16500)/1000;
 334 }
 335
 336 static inline int RGB2Cr(int r,int g,int b)
 337 {
 338   return ( 439*r-368*g- 71*b+128500)/1000;
 339 }
 340
 341 static inline int RGB2Cb(int r,int g,int b)
 342 {
 343   return (-148*r-291*g+439*b+128500)/1000;
 344 }
 345
 346 uint32_t zsvc_t::
 347 pen_yuva(int color, int opacity)
 348 {
 349   int r, g, b, y, u, v, a;
 350   r = ((color>>4) & 0x03) * 255 / 3;
 351   g = ((color>>2) & 0x03) * 255 / 3;
 352   b = ((color>>0) & 0x03) * 255 / 3;
 353   a = 255;
 354   switch( opacity ) {
 355   case oty_transparent:  a =   0;  break;
 356   case oty_translucent:  a = 128;  break;
 357   case oty_flash:        a = 208;  break;
 358   case oty_solid:        a = 255;  break;
 359   }
 360   y = RGB2Y(r,g,b);
 361   u = RGB2Cr(r,g,b);
 362   v = RGB2Cb(r,g,b);
 363   return (y<<24) | (u<<16) | (v<<8) | (a<<0);
 364 }
 365
 366 static inline int put_utf8(unsigned int v, uint8_t *cp, int n)
 367 {
 368   if( v >= 0x80 ) {
 369     int l = v < 0x0800 ? 2 : v < 0x00010000 ? 3 :
 370       v < 0x00200000 ? 4 : v < 0x04000000 ? 5 : 6;
 371     if( l > n ) return -1;
 372     int m = 0xff00 >> l, i = l;
 373     *cp++ = (v>>(6*--i)) | m;
 374     for( ; --i>=0; ++cp ) *cp = ((v>>(6*i)) & 0x3f) | 0x80;
 375     return l;
 376   }
 377   if( n < 1 ) return -1;
 378   *cp = v;
 379   return 1;
 380 }
 381
 382 zwin_t::
 383 win_t()
 384 {
 385   bfr = 0;
 386   dirty = 0;
 387   subtitle = 0;
 388 }
 389
 390 zwin_t::
 391 ~win_t()
 392 {
 393   delete [] bfr;
 394   delete subtitle;
 395 }
 396
 397 void zwin_t::
 398 output_text()
 399 {
 400   if( st < st_visible ) return;
 401   end_frame = svc->cc->video->framenum;
 402   if( !svc->cc->text_cb ) return;
 403   if( !bfr ) return;
 404   char txt[1024];
 405   uint8_t *cp = (uint8_t *)txt, *ep = cp + sizeof(txt)-1;
 406   for( int iy=0; iy<ch; ++iy ) {
 407     if( iy && cp < ep ) *cp++ = '|';
 408     chr_t *bp = &bfr[iy * MX_CX];
 409     for( int ix=0; ix<cw && cp<ep; ++ix,++bp ) {
 410       if( !bp->glyph ) continue;
 411       int n = put_utf8(bp->glyph, cp, ep-cp);
 412       if( n < 0 ) break;
 413       cp += n;
 414     }
 415   }
 416   *cp = 0;
 417   svc->cc->text_cb(svc->sid, id, start_frame, end_frame, txt);
 418   start_frame = end_frame;
 419 }
 420
 421 void zwin_t::
 422 set_state(int8_t st)
 423 {
 424   if( this->st == st ) return;
 425 //zmsgs("win %d was %d, now %d %s\n", id, this->st, st,
 426 //  st==st_unmap ? "unmapped" : st==st_hidden ? "hidden" :
 427 //  st==st_visible ? "visible" : "err");
 428   output_text();
 429   if( this->st < st_visible && st >= st_visible )
 430     start_frame = svc->cc->video->framenum;
 431   this->st = st;
 432   dirty = 1;
 433 }
 434
 435 void zwin_t::
 436 reset(int i, zsvc_t *svc)
 437 {
 438   this->id = i;
 439   this->svc = svc;
 440 //zmsgs("win %d\n",id);
 441   scale = 1;
 442   cx = cy = cw = ch = 0;
 443   x = y = 0;
 444   pdir = dir_rt;
 445   sdir = dir_up;
 446   svc->bfr_put(bfr);
 447   st = st_unmap;
 448 }
 449
 450 int zwin_t::
 451 is_breakable(int b)
 452 {
 453   return b == ' ' || b == '-' || b == '\r';
 454 }
 455
 456 int zwin_t::
 457 wrap()
 458 {
 459   switch( pdir ) {
 460   case dir_rt: {
 461     chr_t line[MX_CX];  int ix = cx-1;
 462     chr_t *cp = &line[ix], *sp = cp;
 463     while( ix >= 0 ) {
 464       chr_t *bp = &bfr[cy*MX_CX + ix];
 465       if( is_breakable(bp->glyph) ) break;
 466       *cp-- = *bp;  bp->glyph = 0;  --ix;
 467     }
 468     if( ix >= 0 ) CR();
 469     for( ; cx<cw && cp<sp; ++cx )
 470       bfr[cy*MX_CX + cx] = *++cp;
 471     if( ix < 0 ) CR();
 472     break; }
 473
 474   case dir_lt: {
 475     chr_t line[MX_CX];  int ix = cx+1;
 476     chr_t *cp = &line[ix], *sp = cp;
 477     while( ix < cw ) {
 478       chr_t *bp = &bfr[cy*MX_CX + ix];
 479       if( is_breakable(bp->glyph) ) break;
 480       *cp++ = *bp;  bp->glyph = 0;  ++ix;
 481     }
 482     if( ix < cw ) CR();
 483     for( ; cx>=0 && cp>sp; --cx )
 484       bfr[cy*MX_CX + cx] = *--cp;
 485     if( ix >= cw ) CR();
 486     break; }
 487
 488   case dir_dn: {
 489     chr_t line[MX_CY];  int iy = cy-1;
 490     chr_t *cp = &line[iy], *sp = cp;
 491     while( iy >= 0 ) {
 492       chr_t *bp = &bfr[iy*MX_CX + cx];
 493       if( is_breakable(bp->glyph) ) break;
 494       *cp-- = *bp;  bp->glyph = 0;  --iy;
 495     }
 496     if( iy >= 0 ) CR();
 497     for( ; cy<ch && cp<sp; ++cy )
 498       bfr[cy*MX_CX + cx] = *++cp;
 499     if( iy < 0 ) CR();
 500     break; }
 501
 502   case dir_up: {
 503     chr_t line[MX_CY];  int iy = cy+1;
 504     chr_t *cp = &line[iy], *sp = cp;
 505     while( iy < ch ) {
 506       chr_t *bp = &bfr[iy*MX_CX + cx];
 507       if( is_breakable(bp->glyph) ) break;
 508       *cp++ = *bp;  bp->glyph = 0;  ++iy;
 509     }
 510     if( iy < ch ) CR();
 511     for( ; cy>=0 && cp>sp; --cy )
 512       bfr[cy*MX_CX + cx] = *--cp;
 513     if( iy >= ch ) CR();
 514     break; }
 515   }
 516
 517   return 0;
 518 }
 519
 520 int zwin_t::
 521 ovfl()
 522 {
 523   if( !col_lock && !resize(cx+1, ch) ) return 0;
 524   if( !row_lock ) return 1;
 525   if( wordwrap ) return wrap();
 526   return CR();
 527 }
 528
 529 int zwin_t::
 530 store(int b)
 531 {
 532 //zmsgs("%02x ** \"%c\" at %d,%d win %d\n",
 533 //  b, b>=0x20 && b<0x7f ? b : '.',cx,cy,id);
 534   if( !bfr ) return 1;
 535   switch( pdir ) {
 536   case dir_rt:  if( cx >= cw && ovfl() ) return 1;  break;
 537   case dir_lt:  if( cx < 0 && ovfl() )   return 1;  break;
 538   case dir_dn:  if( cy >= ch && ovfl() ) return 1;  break;
 539   case dir_up:  if( cy < 0 && ovfl() )   return 1;  break;
 540   }
 541   if( cx >= 0 && cx < cw && cy >= 0 && cy < ch ) {
 542     chr_t *chr = &bfr[cy*MX_CX + cx];
 543     chr->glyph = b;
 544     chr->fg_opacity = fg_opacity;
 545     chr->fg_color = fg_color;
 546     chr->bg_opacity = bg_opacity;
 547     chr->bg_color = bg_color;
 548     chr->pen_size = pen_size;
 549     chr->edge_color = edge_color;
 550     chr->italics = italics;
 551     chr->edge_type = edge_type;
 552     chr->underline = underline;
 553     chr->font_style = font_style;
 554     chr->font_size = svc->cc->font_size;
 555     chr->offset = offset;
 556     chr->text_tag = text_tag;
 557     dirty = 1;
 558   }
 559   switch( pdir ) {
 560   case dir_rt:  ++cx;  break;
 561   case dir_lt:  --cx;  break;
 562   case dir_dn:  ++cy;  break;
 563   case dir_up:  --cy;  break;
 564   }
 565   return 0;
 566 }
 567
 568 int zsvc_t::
 569 ETX() /* end of text */
 570 {
 571 //zmsgs("svc %d,win %d\n",sid, curw ? curw->id : -1);
 572 //  if( curw ) curw->render();
 573   return 0;
 574 }
 575
 576 int zwin_t::
 577 BS() /* Backspace */
 578 {
 579   switch( pdir ) {
 580   case dir_rt:  if( cx > 0 ) --cx;   break;
 581   case dir_lt:  if( cx < cw-1 ) ++cx;  break;
 582   case dir_dn:  if( cy > 0 ) --cy;   break;
 583   case dir_up:  if( cy < ch-1 ) ++cy;  break;
 584   }
 585   return 0;
 586 }
 587
 588 int zsvc_t::
 589 BS() /* Backspace */
 590 {
 591   if( !curw || curw->st == st_unmap ) return 0;
 592 //zmsgs("svc %d,win %d\n",sid,curw->id);
 593   return curw->BS();
 594 }
 595
 596 int zwin_t::
 597 FF() /* Form Feed */
 598 {
 599   int n = cw*sizeof(*bfr);
 600   for( int iy=0; iy<ch; ++iy )
 601     memset(&bfr[iy*MX_CX],0,n);
 602   cx = cy = 0;
 603   dirty = 1;
 604   return 0;
 605 }
 606
 607 int zsvc_t::
 608 FF() /* Form Feed */
 609 {
 610   if( !curw || curw->st == st_unmap ) return 0;
 611 //zmsgs("svc %d,win %d\n",sid,curw->id);
 612   return curw->FF();
 613 }
 614
 615 int zwin_t::
 616 CR() /* Carriage Return */
 617 {
 618   int n = (cw-1)*sizeof(*bfr);
 619   int m = cw*sizeof(*bfr);
 620   int scrolled = 0;
 621   switch( sdir ) {
 622   case dir_rt:
 623     cy = 0;
 624     if( cx > 0 ) { --cx;  break; }
 625     for( int i=0; i<ch; ++i ) {
 626       memmove(&bfr[i*MX_CX+1],&bfr[i*MX_CX],n);
 627       memset(&bfr[i*MX_CX],0,sizeof(*bfr));
 628     }
 629     cx = 0;
 630     scrolled = 1;
 631     break;
 632   case dir_lt:
 633     cy = 0;
 634     if( cx+1 < cw ) { ++cx;  break; }
 635     for( int i=0; i<ch; ++i ) {
 636       memmove(&bfr[i*MX_CX],&bfr[i*MX_CX+1],n);
 637       memset(&bfr[i*MX_CX+cw-1],0,sizeof(*bfr));
 638     }
 639     cx = cw-1;
 640     scrolled = 1;
 641     break;
 642   case dir_dn:
 643     cx = 0;
 644     if( cy > 0 ) { --cy;  break; }
 645     for( int i=ch; --i>0; )
 646       memmove(&bfr[i*MX_CX],&bfr[(i-1)*MX_CX],m);
 647     memset(&bfr[0],0,m);
 648     cy = 0;
 649     scrolled = 1;
 650     break;
 651   case dir_up:
 652     cx = 0;
 653     if( cy+1 < ch ) { ++cy;  break; }
 654     for( int i=1; i<ch; ++i )
 655       memmove(&bfr[(i-1)*MX_CX],&bfr[i*MX_CX],m);
 656     memset(&bfr[(ch-1)*MX_CX],0,m);
 657     cy = ch-1;
 658     scrolled = 1;
 659     break;
 660   }
 661   if( scrolled ) {
 662     output_text();
 663     dirty = 1;
 664   }
 665   return 0;
 666 }
 667
 668 int zsvc_t::
 669 CR() /* Carriage Return */
 670 {
 671   if( !curw || curw->st == st_unmap ) return 0;
 672 //zmsgs("svc %d,win %d\n",sid,curw->id);
 673   return curw->CR();
 674 }
 675
 676 int zwin_t::
 677 HCR() /* Horizontal Carriage Return */
 678 {
 679   switch( pdir ) {
 680   case dir_rt:
 681   case dir_lt:
 682     memset(&bfr[cy*MX_CX],0,cw*sizeof(*bfr));
 683     cy = pdir == dir_rt ? 0 : cw-1;
 684     dirty = 1;
 685     break;
 686   case dir_up:
 687   case dir_dn:
 688     for( int i=0; i<ch; ++i ) memset(&bfr[i*MX_CX+cx],0,sizeof(*bfr));
 689     cx = pdir == dir_dn ? 0 : ch-1;
 690     dirty = 1;
 691     break;
 692   }
 693   return 0;
 694 }
 695
 696 int zsvc_t::
 697 HCR() /* Horizontal Carriage Return */
 698 {
 699   if( !curw || curw->st == st_unmap ) return 0;
 700 //zmsgs("svc %d,win %d\n",sid,curw->id);
 701   return curw->HCR();
 702 }
 703
 704 int zsvc_t::
 705 CLW()  /* ClearWindows */
 706 {
 707   if( bp >= ep ) return 1;
 708   int map = *bp++;  // 1
 709 //zmsgs("map %02x svc %d\n",map,sid);
 710   for( int iw=0; iw<MX_WIN; ++iw ) {
 711     if( !(map & (1<<iw)) ) continue;
 712     win_t *wp = &win[iw];
 713     if( wp->st > st_unmap ) {
 714       wp->output_text();
 715 //zmsgs("  clear win %d\n",wp->id);
 716       int n = wp->cw*sizeof(*wp->bfr);
 717       for( int iy=0; iy<wp->ch; ++iy )
 718         memset(&wp->bfr[iy*MX_CX],0,n);
 719       wp->dirty = 1;
 720     }
 721   }
 722   return 0;
 723 }
 724
 725 int zsvc_t::
 726 DSW() /* DisplayWindows */
 727 {
 728   if( bp >= ep ) return 1;
 729   int map = *bp++;  // 1
 730 //zmsgs("map %02x svc %d\n",map,sid);
 731   for( int iw=0; iw<MX_WIN; ++iw ) {
 732     if( !(map & (1<<iw)) ) continue;
 733     win_t *wp = &win[iw];
 734     if( wp->st > st_unmap ) {
 735       wp->set_state(st_visible);
 736     }
 737   }
 738   return 0;
 739 }
 740
 741 int zsvc_t::
 742 HDW() /* HideWindows */
 743 {
 744   if( bp >= ep ) return 1;
 745   int map = *bp++;  // 1
 746 //zmsgs("map %02x svc %d\n",map,sid);
 747   for( int iw=0; iw<MX_WIN; ++iw ) {
 748     if( !(map & (1<<iw)) ) continue;
 749     win_t *wp = &win[iw];
 750     if( wp->st > st_unmap ) {
 751       wp->set_state(st_hidden);
 752     }
 753   }
 754   return 0;
 755 }
 756
 757 int zsvc_t::
 758 TGW() /* ToggleWindows */
 759 {
 760   if( bp >= ep ) return 1;
 761   int map = *bp++;  // 1
 762 //zmsgs("map %02x svc %d\n",map,sid);
 763   for( int iw=0; iw<MX_WIN; ++iw ) {
 764     if( !(map & (1<<iw)) ) continue;
 765     win_t *wp = &win[iw];
 766     if( wp->st > st_unmap ) {
 767       int8_t st = wp->st == st_visible ? st_hidden : st_visible;
 768       wp->set_state(st);
 769     }
 770   }
 771   return 0;
 772 }
 773
 774 int zsvc_t::
 775 DLW() /* DeleteWindows */
 776 {
 777   if( bp >= ep ) return 1;
 778   int map = *bp++;  // 1
 779 //zmsgs("map %02x svc %d\n",map,sid);
 780   for( int iw=0; iw<MX_WIN; ++iw ) {
 781     if( !(map & (1<<iw)) ) continue;
 782     win_t *wp = &win[iw];
 783     if( wp->st == st_unmap ) continue;
 784 //zmsgs("  delete %d\n",wp->id);
 785     wp->set_state(st_unmap);
 786     if( wp == curw ) curw = 0;
 787     bfr_put(wp->bfr);
 788   }
 789   return 0;
 790 }
 791
 792 int zsvc_t::
 793 DLY() /* delay */
 794 {
 795   if( bp >= ep ) return 1;
 796 //zmsgs(" svc %d (%d)\n",sid, *bp);
 797   ++bp;  // 1
 798   return 0;
 799 }
 800
 801 int zsvc_t::
 802 DLC() /* delay cancel */
 803 {
 804 //zmsg("\n");
 805   return 0;
 806 }
 807
 808 int zsvc_t::
 809 RST() /* Reset */
 810 {
 811 //zmsgs("svc %d\n",sid);
 812   reset(sid, cc);
 813   return 0;
 814 }
 815
 816 int zsvc_t::
 817 SPA() /* SetPenAttributes */
 818 {
 819   if( bp+2 > ep ) return 1;
 820   int b = *bp++;  // 1
 821   int text_tag = b>>4;
 822   int offset = (b>>2) & 0x03;
 823   int pen_size = b & 0x03;
 824   b = *bp++;  // 2
 825   int italics = b>>7;
 826   int underline = (b>>6) & 0x01;
 827   int edge_type = (b>>3) & 0x07;
 828   int font_style = b & 0x07;
 829   if( pen_size >= 3 ) return 0;
 830   if( offset >= 3 ) return 0;
 831   if( edge_type >= 6 ) return 0;
 832   win_t *wp = curw;
 833   if( wp && wp->st > st_unmap ) {
 834     wp->text_tag = text_tag;
 835     wp->offset = offset;
 836     wp->pen_size = pen_size;
 837     wp->italics = italics;
 838     wp->underline = underline;
 839     wp->edge_type = edge_type;
 840     wp->font_style = font_style;
 841 //zmsgs("txttag=%d,offset=%d,pen_size=%d,ital=%d,undl=%d,"
 842 //  "edge=%d,ftstyl=%d,win %d,svc %d\n",text_tag,offset,
 843 //  pen_size,italics,underline,edge_type,font_style,wp->id,sid);
 844   }
 845   return 0;
 846 }
 847
 848 int zsvc_t::
 849 SPC() /* SetPenColor */
 850 {
 851   if( bp+3 > ep ) return 1;
 852   int b = *bp++;  // 1
 853   int fg_opacity = b >> 6;
 854   int fg_color = b & 0x3f;
 855   b = *bp++;  // 2
 856   int bg_opacity = b >> 6;
 857   int bg_color = b & 0x3f;
 858   b = *bp++;  // 3
 859   int edge_color = b;
 860   win_t *wp = curw;
 861   if( wp && wp->st > st_unmap ) {
 862     wp->fg_opacity = fg_opacity;
 863     wp->fg_color = fg_color;
 864     wp->edge_color = edge_color;
 865     wp->bg_opacity = bg_opacity;
 866     wp->bg_color = bg_color;
 867     wp->fg_yuva = pen_yuva(fg_color,fg_opacity);
 868     wp->edge_yuva = pen_yuva(edge_color,fg_opacity);
 869     wp->bg_yuva = pen_yuva(bg_color,bg_opacity);
 870 //zmsgs("fgopc=%d,fgclr=%02x,bgopc=%d,bgclr=%02x,egclr=%02x,"
 871 //  "win %d,svc %d\n",fg_opacity,fg_color,bg_opacity,bg_color,
 872 //  edge_color,wp->id,sid);
 873   }
 874   return 0;
 875 }
 876
 877 int zsvc_t::
 878 SPL() /* SetPenLocation */
 879 {
 880   if( bp+2 > ep ) return 1;
 881   int b = *bp++;  // 1
 882   int row = b;
 883   b = *bp++;  // 2
 884   int column = b;
 885   if( row >= MX_CY ) return 0;
 886   if( column >= MX_CX ) return 0;
 887   win_t *wp = curw;
 888   if( wp && wp->st > st_unmap ) {
 889     if( column >= wp->cw || row >= wp->ch ) return 1;
 890     wp->cx = column;  wp->cy = row;
 891 //zmsgs("row=%d,col=%d,win %d,svc %d\n",row,column,wp->id,sid);
 892   }
 893   return 0;
 894 }
 895
 896 int zsvc_t::
 897 RSVD() /* reserved */
 898 {
 899 //zmsgs("sid %d\n",sid);
 900   return 0;
 901 }
 902
 903 int zsvc_t::
 904 SWA() /* SetWindowAttributes */
 905 {
 906   if( bp+4 > ep ) return 1;
 907   int b = *bp++;  // 1
 908   int fill_opacity = b>>6;
 909   int fill_color = b & 0x3f;
 910   b = *bp++;  // 2
 911   int border_color = b & 0x3f;
 912   int border_type = b>>6;
 913   b = *bp++;  // 3
 914   int wordwrap = (b>>6) & 0x01;
 915   border_type |= (b>>5) & 0x04;
 916   int print_direction = (b>>4) & 0x03;
 917   int scroll_direction = (b>>2) & 0x03;
 918   int justify = b & 0x03;
 919   b = *bp++;  // 4
 920   int effect_speed = b>>4;
 921   int effect_direction = (b>>2) & 0x3;
 922   int display_effect = b & 0x03;
 923   if( border_type >= 6 ) return 0;
 924   if( display_effect >= 3 ) return 0;
 925
 926   win_t *wp = curw;
 927   if( wp && wp->st > st_unmap ) {
 928     wp->fill_opacity = fill_opacity;
 929     wp->fill_color = fill_color;
 930     wp->border_color = border_color;
 931     wp->fill_yuva = pen_yuva(fill_color,fill_opacity);
 932     wp->border_yuva = pen_yuva(border_color,fill_opacity);
 933     wp->wordwrap = wordwrap;
 934     wp->pdir = print_direction;
 935     wp->sdir = scroll_direction;
 936     wp->justify = justify;
 937     wp->effect_speed = effect_speed;
 938     wp->effect_direction = effect_direction;
 939     wp->display_effect = display_effect;
 940     wp->dirty = 1;
 941 //zmsgs("fopc=%d,fclr=%02x,bclr=%02x,wrap=%d,pdir=%d,sdir=%d,just=%d"
 942 //  "espd=%d,edir=%d,deft=%d,win %d,svc %d\n",fill_opacity,fill_color,
 943 //  border_color,wordwrap,print_direction,scroll_direction,justify,
 944 //  effect_speed,effect_direction,display_effect,wp->id,sid);
 945   }
 946   return 0;
 947 }
 948
 949 int zsvc_t::
 950 CWx(int id) /* SetCurrentWindow */
 951 {
 952   win_t *wp = &win[id];
 953   curw = wp->st == st_unmap ? 0 : wp;
 954 //zmsgs("== win %d,svc %d\n",wp->id,sid);
 955   return 0;
 956 }
 957
 958 int zsvc_t::
 959 DFz(int id) /* DFx DefineWindow */
 960 {
 961   if( bp+6 > ep ) return 1;
 962   win_t *wp = &win[id];
 963   int b = *bp++; // 1
 964   int visible = (b>>5) & 0x01;
 965   int row_lock = (b>>4) & 0x01;
 966   int col_lock = (b>>3) & 0x01;
 967   int priority = b & 0x07;
 968   b = *bp++; // 2
 969   int anchor_relative = (b>>7) & 0x01;
 970   int anchor_vertical = b & 0x7f;
 971   b = *bp++; // 3
 972   int anchor_horizontal = b;
 973   b = *bp++; // 4
 974   int anchor_point = b>>4;
 975   int ch = (b & 0x0f) + 1;
 976   b = *bp++; // 5
 977   int cw = b + 1;
 978   b = *bp++; // 6
 979   int window_style = (b>>3) & 0x07;
 980   int pen_style = b & 0x07;
 981 //zmsgs("%dx%d vis=%d,rowlk=%d,collk=%d,pri=%d,an_rel=%d,\n"
 982 //  "an_hor=%d,an_vert=%d,an_pnt=%d,wsty=%d,psty=%d,win %d,svc %d\n",
 983 //  cw,ch,visible,row_lock,col_lock,priority,anchor_relative,
 984 //  anchor_horizontal,anchor_vertical,anchor_point,window_style,
 985 //  pen_style,wp->id,sid);
 986   if( anchor_relative ) {
 987     if( anchor_vertical >= 75 ) return -1;
 988     if( anchor_horizontal >= 210 ) return -1;
 989   }
 990   else {
 991     if( anchor_vertical >= 100 ) return -1;
 992     if( anchor_horizontal >= 100 ) return -1;
 993   }
 994   if( anchor_point >= 9 ) return -1;
 995   if( cw > MX_CX ) return -1;
 996   if( ch > MX_CY ) return -1;
 997
 998   wp->row_lock = row_lock;
 999   wp->col_lock = col_lock;
1000   wp->priority = priority;
1001   wp->anchor_relative = anchor_relative;
1002   wp->anchor_vertical = anchor_vertical;
1003   wp->anchor_horizontal = anchor_horizontal;
1004   wp->anchor_point = anchor_point;
1005   if( wp->st == st_unmap )
1006     wp->set_window_style(window_style);
1007   if( wp->st == st_unmap )
1008     wp->set_pen_style(pen_style);
1009   int bw = wp->border_type != edg_none ? bdr_width : 0;
1010   wp->bw = (bw+3) & ~4;  // yuv 422 macro pixels
1011   if( wp->st == st_unmap )
1012     wp->init(cw, ch);
1013   else
1014     wp->resize(cw, ch);
1015   wp->set_state(visible ? st_visible : st_hidden);
1016   curw = wp;
1017   wp->dirty = 1;
1018   int scale = cc->video->coded_picture_height/360;
1019   if( scale < 1 ) scale = 1;
1020   wp->scale = scale;
1021   return 0;
1022 }
1023
1024 int zsvc_t::
1025 DFx(int id) /* DFx DefineWindow wrapper */
1026 {
1027   int ret = DFz(id);
1028   if( ret < 0 ) {
1029     zmsgs("failed to validate cc win %d\n",id);
1030     ret = 0;
1031   }
1032   return ret;
1033 }
1034
1035 int zwin_t::
1036 init(int ncw, int nch)
1037 {
1038 //zmsgs("  init %d, %dx%d\n", id, ncw, nch);
1039   if( ncw > MX_CX ) return 1;
1040   if( nch > MX_CY ) return 1;
1041   bfr = svc->get_bfr();
1042   if( !bfr )
1043     bfr = new chr_t[MX_CX*MX_CY];
1044   cw = ncw;  ch = nch;
1045   int n = cw*sizeof(*bfr);
1046   for( int iy=0; iy<ch; ++iy )
1047     memset(&bfr[iy*MX_CX],0,n);
1048   text_tag = 0;
1049   cx = cy = 0;
1050   x = y = 0;
1051   return 0;
1052 }
1053
1054 int zwin_t::
1055 resize(int ncw, int nch)
1056 {
1057 //zmsgs("  resize %d, %dx%d %s\n", id, ncw, nch, cw!=ncw || ch!=nch ? "*" : "");
1058   if( ncw > MX_CX ) return 1;
1059   if( nch > MX_CY ) return 1;
1060   int dx = ncw-cw, dy = nch-ch;
1061   if( !dx && !dy ) return 0;
1062   int n = cw*sizeof(*bfr);
1063   switch( sdir ) {
1064   case dir_rt:
1065     if( dx > 0 ) { // scroll right, expanding
1066       int m = dx*sizeof(*bfr);
1067       for( int iy=0; iy<ch; ++iy ) {
1068         chr_t *bp = &bfr[iy*MX_CX], *cp = bp+dx;
1069         memmove(cp,bp,n);
1070         memset(bp,0,m);
1071       }
1072       dx = 0;
1073     }
1074     break;
1075   case dir_lt:
1076     if( dx < 0 ) { // scroll left, contracting
1077       for( int iy=0; iy<ch; ++iy ) {
1078         chr_t *bp = &bfr[iy*MX_CX], *cp = bp-dx;
1079         memmove(bp,cp,n);
1080       }
1081       dx = 0;
1082     }
1083     break;
1084   case dir_dn:
1085     if( dy > 0 ) { // scroll down, expanding
1086       for( int iy=ch; --iy>=dy; ) {
1087         chr_t *bp = &bfr[iy*MX_CX], *cp = bp-dy*MX_CX;
1088         memmove(bp,cp,n);
1089       }
1090       memset(&bfr[0],0,dy*n);
1091       dy = 0;
1092     }
1093     break;
1094   case dir_up:
1095     if( dy < 0 ) { // scroll up, contracting
1096       for( int iy=dy; iy>ch; ++iy ) {
1097         chr_t *bp = &bfr[iy*MX_CX], *cp = bp+dy*MX_CX;
1098         memmove(cp,bp,n);
1099       }
1100       dy = 0;
1101     }
1102     break;
1103   }
1104
1105   if( dx > 0 ) {
1106     int m = dx*sizeof(*bfr);
1107     for( int iy=0; iy<ch; ++iy ) {
1108       chr_t *bp = &bfr[iy*MX_CX] + cw;
1109       memset(bp,0,m);
1110     }
1111   }
1112   if( dy > 0 ) {
1113     n = ncw*sizeof(*bfr);
1114     for( int iy=ch; iy<nch; ++iy ) {
1115       chr_t *bp = &bfr[iy*MX_CX];
1116       memset(bp,0,n);
1117     }
1118   }
1119   cw = ncw;  ch = nch;
1120   return 0;
1121 }
1122
1123 void zwin_t::
1124 set_pen_style(int i)
1125 {
1126   pen_style = i > 0 ? i : 1;
1127   pen_size = psz_standard;
1128   font_style = pen_style <= 5 ? pen_style-1 : pen_style-3;
1129   offset = ofs_normal;
1130   italics = underline = 0;
1131   fg_opacity = oty_solid;
1132   fg_color = 0x3f;
1133   edge_type = pen_style <= 5 ? edg_none : edg_uniform;
1134   edge_color = 0x00;
1135   bg_opacity = pen_style <= 5 ? oty_solid : oty_transparent;
1136   bg_color = 0x00;
1137   fg_yuva = pen_yuva(fg_color,fg_opacity);
1138   edge_yuva = pen_yuva(edge_color,fg_opacity);
1139   bg_yuva = pen_yuva(bg_color,bg_opacity);
1140   text_tag = tag_dialog;
1141 }
1142
1143 void zwin_t::
1144 set_window_style(int i)
1145 {
1146   window_style = i > 0 ? i : 1;
1147   justify = ((0x48>>window_style) & 1) ? jfy_center : jfy_left;
1148   pdir = window_style < 7 ? dir_rt : dir_dn;
1149   sdir = window_style < 7 ? dir_up : dir_lt;
1150   wordwrap = (0x70>>window_style) & 1;
1151   display_effect = eft_snap;
1152   effect_speed = 0;
1153   effect_direction = dir_rt;
1154   fill_opacity = oty_solid;
1155   fill_color = 0x00;
1156   border_type = edg_none;
1157   border_color = 0x00;
1158   fill_yuva = pen_yuva(fill_color,fill_opacity);
1159   border_yuva = pen_yuva(border_color,fill_opacity);
1160 }
1161
1162 #if 0
1163 void zwin_t::
1164 default_window()
1165 {
1166   if( !bfr ) return;
1167   row_lock = col_lock = 0;
1168   priority = 0;
1169   anchor_relative = 0;
1170   anchor_vertical = 24;
1171   anchor_horizontal = 12;
1172   anchor_point = 0;
1173   set_window_style(1);
1174   set_pen_style(1);
1175   text_tag = 0;
1176   ch = 1;  cw = 32;
1177   int n = cw*sizeof(*bfr);
1178   for( int iy=0; iy<ch; ++iy)
1179     memset(&bfr[iy*MX_CX],0,n);
1180   cx = cy = 0;
1181   st = st_visible;
1182 }
1183 #endif
1184
1185 void zwin_t::
1186 print_buffer()
1187 {
1188   if( !bfr ) return;
1189   zmsgs("bfr %d\n",id);
1190   for( int iy=0; iy<ch; ++iy ) {
1191     int ofs = iy*MX_CX;
1192     for( int ix=0; ix<cw; ++ix ) {
1193       int b = bfr[ofs++].glyph;
1194       printf("%c", b>=0x20 && b<0x7f ? b : '.');
1195     }
1196     printf("\n");
1197   }
1198 }
1199
1200 void zwin_t::
1201 put_chr(chr_t *chr)
1202 {
1203   if( !subtitle ) return;
1204   uint16_t bb = chr->glyph;
1205   bitfont_t *font = chr_font(chr, scale);
1206   if( bb >= font->nch ) return;
1207 //zmsgs("%02x \"%c\" at %d,%d in %d\n",bb,bb>=0x20&&bb<0x7f?bb:'.',x,y,id);
1208   int ww = subtitle->w - 2*bw;
1209   int hh = subtitle->h - 2*bw;
1210   int dx = 0, dy = 0;
1211   bitfont_t::bitchar_t *cp = &font->chrs[bb];
1212   uint8_t *bmap = cp->bitmap;
1213   if( bmap || cp->ch == ' ' ) {
1214     /* cell origin = (x,y) addressed (0,0) to (x2,y2) */
1215     /* char data box (x0,y0) to (x1,y1), may exceed cell box */
1216     int x0, ix0, y0, iy0;
1217     int x1, x2, y1, y2;
1218     x0 = ix0 = cp->left;
1219     y0 = iy0 = font->imy - cp->ascent;
1220     x1 = cp->right;
1221     y1 = font->imy + cp->decent;
1222     x2 = font->idx;  y2 = font->idy;
1223     if( bmap ) {
1224       switch( pdir ) {
1225       case dir_rt:  x2 = dx = cp->right;  break;
1226       case dir_lt:  x2 = dx = cp->left;   break;
1227       case dir_dn:  y2 = dy = cp->decent;  break;
1228       case dir_up:  y2 = dy = cp->ascent;  break;
1229       }
1230     }
1231     else { /* blank */
1232       switch( pdir ) {
1233       case dir_rt: case dir_lt:  dx = font->idx;  break;
1234       case dir_dn: case dir_up:  dy = font->idy;  break;
1235       }
1236     }
1237     if( x+x0 < 0 ) x0 = -x;
1238     if( y+y0 < 0 ) y0 = -y;
1239     int mx = ww - x;
1240     if( x0 > mx ) x0 = mx;
1241     if( x1 > mx ) x1 = mx;
1242     if( x2 > mx ) x2 = mx;
1243     int my = hh - y;
1244     if( y0 > my ) y0 = my;
1245     if( y1 > my ) y1 = my;
1246     if( y2 > my ) y2 = my;
1247
1248     class pix_t {  /* address char cell */
1249       uint8_t *image_y, *image_u, *image_v, *image_a;
1250       uint8_t *img_y, *img_u, *img_v, *img_a;  int w;
1251     public:
1252       void set_line(int n) {
1253         int ofs = w * n;
1254         img_y = image_y + ofs;
1255         img_u = image_u + ofs;
1256         img_v = image_v + ofs;
1257         img_a = image_a + ofs;
1258       }
1259       pix_t(subtitle_t *subtitle, int x, int y) {
1260         w = subtitle->w;
1261         int ofs = y*w + x;
1262         image_y = subtitle->image_y + ofs;
1263         image_u = subtitle->image_u + ofs;
1264         image_v = subtitle->image_v + ofs;
1265         image_a = subtitle->image_a + ofs;
1266       }
1267       void write(int i, uint32_t yuva) {
1268         img_y[i] = yuva >> 24;
1269         img_u[i] = yuva >> 16;
1270         img_v[i] = yuva >> 8;
1271         img_a[i] = yuva >> 0;
1272       }
1273       void fill_box(uint32_t yuva, int x0,int y0, int x1,int y1) {
1274         if( x0 >= x1 ) return;
1275         while( y0 < y1 ) {
1276           set_line(y0++);
1277           for( int ix=x0; ix<x1; ++ix ) write(ix,yuva);
1278         }
1279       }
1280     } pix(subtitle, x+bw, y+bw); /* origin inside border */
1281     /* dont fill left of cell */
1282     pix.fill_box(bg_yuva,  0, 0, x2,y0);  /* fill top */
1283     pix.fill_box(bg_yuva,  0,y0, x0,y1);  /* fill left */
1284     pix.fill_box(bg_yuva, x1,y0, x2,y1);  /* fill right */
1285     pix.fill_box(bg_yuva,  0,y1, x2,y2);  /* fill bottom */
1286
1287     int wsz = (cp->right-cp->left+7) / 8;
1288     int rx = x0 - ix0;
1289     int ry = y0 - iy0;
1290     /* render char box */
1291     for( int iy=y0; iy<y1; ++iy,++ry ) {
1292       pix.set_line(iy);
1293       uint8_t *row = &bmap[ry*wsz];
1294       int i = rx, ix = x0;
1295       /* dont render bg left of cell */
1296       while( ix < 0 ) {
1297         if( ((row[i>>3] >> (i&7)) & 1) ) pix.write(ix, fg_yuva);
1298         ++ix;  ++i;
1299       }
1300       /* render fg/bg inside of cell */
1301       while( ix < x1 ) {
1302         pix.write(ix, ((row[i>>3] >> (i&7)) & 1) ? fg_yuva : bg_yuva);
1303         ++ix;  ++i;
1304       }
1305     }
1306     if( chr->underline ) {
1307       int uy0 = font->imy;
1308       if( uy0 < y2 ) {
1309         int uy1 = uy0 + (y2+23)/24;
1310         if( uy1 > y2 ) uy1 = y2;
1311         pix.fill_box(fg_yuva, 0,uy0, x2,uy1);
1312       }
1313     }
1314   }
1315   else {
1316     /* no bitmap and not blank */
1317     switch( pdir ) {
1318     case dir_rt:  dx = font->idx;  dy = 0;  break;
1319     case dir_lt:  dx = font->idy;  dy = 0;  break;
1320     case dir_dn:  dx = 0;  dy = font->idy;  break;
1321     case dir_up:  dx = 0;  dy = font->idy;  break;
1322     }
1323   }
1324   x += dx;  y += dy;
1325 }
1326
1327 void zwin_t::
1328 hbar(int x, int y, int ww, int hh, int lm, int rm, int clr)
1329 {
1330 /* w,h = widget dims, ww,hh = bar dims */
1331 /* x,y = widget coord, lm,rm = lt/rt miter, clr = color */
1332   int w = subtitle->w;
1333   int h = subtitle->h;
1334   if( y < 0 ) { hh += y;  y = 0; }
1335   if( y+hh > h ) hh = h - y;
1336   uint32_t yuva = border_yuva;
1337   for( int ih=hh; --ih>=0; ++y ) {
1338     int iw = ww, ix = x;
1339     if( ix < 0 ) { iw += ix;  ix = 0; }
1340     if( ix+iw > w ) iw = w - ix;
1341     int ofs = w*y + ix;
1342     uint8_t *img_y = &subtitle->image_y[ofs];
1343     uint8_t *img_u = &subtitle->image_u[ofs];
1344     uint8_t *img_v = &subtitle->image_v[ofs];
1345     uint8_t *img_a = &subtitle->image_a[ofs];
1346     while( --iw >= 0 ) {
1347       *img_y = clr;         ++img_y;
1348       *img_u = yuva >> 16;  ++img_u;
1349       *img_v = yuva >> 8;   ++img_v;
1350       *img_a = yuva >> 0;   ++img_a;
1351     }
1352     x += lm;  ww -= lm-rm;
1353   }
1354 }
1355
1356 void zwin_t::
1357 vbar(int x, int y, int ww, int hh, int tm, int bm, int clr)
1358 {
1359 /* w,h = widget dims, ww,hh = bar dims */
1360 /* x,y = widget coord, lm,rm = lt/rt miter, clr = color */
1361   int w = subtitle->w;
1362   int h = subtitle->h;
1363   if( x < 0 ) { ww += x;  x = 0; }
1364   if( x+ww > w ) ww = w - x;
1365   uint32_t yuva = border_yuva;
1366   for( int iw=ww; --iw>=0; ++x ) {
1367     int ih = hh, iy = y;
1368     if( iy < 0 ) { ih += iy;  iy = 0; }
1369     if( iy+ih > h ) ih = h - iy;
1370     int ofs = w*iy + x;
1371     uint8_t *img_y = &subtitle->image_y[ofs];
1372     uint8_t *img_u = &subtitle->image_u[ofs];
1373     uint8_t *img_v = &subtitle->image_v[ofs];
1374     uint8_t *img_a = &subtitle->image_a[ofs];
1375     while( --ih >= 0 ) {
1376       *img_y = clr;         img_y += w;
1377       *img_u = yuva >> 16;  img_u += w;
1378       *img_v = yuva >> 8;   img_v += w;
1379       *img_a = yuva >> 0;   img_a += w;
1380     }
1381     y += tm;  hh -= tm-bm;
1382   }
1383 }
1384
1385 void zwin_t::
1386 border(int ilt, int olt, int irt, int ort,
1387        int iup, int oup, int idn, int odn)
1388 {
1389 /* i/o = inside/outside + lt/rt/up/dn = colors */
1390   if( !bw || !subtitle ) return;
1391   int w = subtitle->w;
1392   int h = subtitle->h;
1393   int sbw = bw * scale;
1394   int zo = sbw / 2;  // outside width
1395   int zi = sbw - zo;  // inside width
1396   hbar(0,0,w,zo,1,-1,oup);
1397   hbar(zo,zo,w-2*zo,zi,1,-1,iup);
1398   hbar(sbw-1,h-sbw,w-2*sbw+2,zi,-1,1,idn);
1399   hbar(zo-1,h-zo,w-2*zo+2,zo,-1,1,odn);
1400   vbar(0,1,zo,h-2,1,-1,olt);
1401   vbar(zo,zo+1,zi,h-2*zo-2,1,-1,ilt);
1402   vbar(w-sbw,sbw,zi,h-2*sbw,-1,1,irt);
1403   vbar(w-zo,zo,zo,h-2*zo,-1,1,ort);
1404 }
1405
1406 void zwin_t::
1407 render()
1408 {
1409   if( st < st_visible || !bfr ) {
1410     if( subtitle ) subtitle->draw = -1;
1411     return;
1412   }
1413   /* get bounding box */
1414   int wd = 2*bw;
1415   int ht = 2*bw;
1416   int fw = 0, fh = 0, zz = 0;
1417   switch( pdir ) {
1418   case dir_rt:
1419   case dir_lt:
1420     for( int iy=0; iy<ch; ++iy ) {
1421       int ww = 0;
1422       for( int ix=0; ix<cw; ++ix ) {
1423         chr_t *chr = &bfr[iy*MX_CX + ix];
1424         bitfont_t *font = chr_font(chr, scale);
1425         if( font->idy > fh ) fh = font->idy;
1426         int b = chr->glyph;
1427         if( b >= font->nch ) continue;
1428         bitfont_t::bitchar_t *cp = &font->chrs[b];
1429         int sz = !cp->bitmap ? font->idx :
1430           pdir == dir_rt ? cp->right : cp->left;
1431         ww += sz;
1432       }
1433       if( ww > zz ) zz = ww;
1434     }
1435     wd += zz;
1436     ht += ch * fh;
1437     break;
1438   case dir_up:
1439   case dir_dn:
1440     for( int ix=0; ix<cw; ++ix ) {
1441       int hh = 0;
1442       for( int iy=0; iy<ch; ++iy ) {
1443         chr_t *chr = &bfr[iy*MX_CX + ix];
1444         bitfont_t *font = chr_font(chr, scale);
1445         if( font->idx > fw ) fw = font->idx;
1446         int b = chr->glyph;
1447         if( b >= font->nch ) continue;
1448         bitfont_t::bitchar_t *cp = &font->chrs[b];
1449         int sz = !cp->bitmap ? font->idy :
1450           pdir == dir_dn ? cp->decent : cp->ascent;
1451         hh += sz;
1452       }
1453       if( hh > zz ) zz = hh;
1454     }
1455     wd += cw * fw;
1456     ht += zz;
1457     break;
1458   }
1459   video_t *video = svc->cc->video;
1460 //zmsgs(" an_horz=%d, an_vert=%d, an_rela=%d, %dx%d\n",
1461 //  anchor_horizontal, anchor_vertical, anchor_relative,
1462 //  video->coded_picture_width, video->coded_picture_height);
1463   int ax = ((anchor_horizontal+10) * video->coded_picture_width) / 200;
1464   int ay = ((anchor_vertical+10) * video->coded_picture_height) / 100;
1465   if( anchor_relative ) { ax += ax; ay += ay; }
1466   switch( anchor_point ) {
1467   case 0x00:                            break;  /* nw */
1468   case 0x01:  ax -= wd/2;               break;  /* n */
1469   case 0x02:  ax -= wd;                 break;  /* ne */
1470   case 0x03:  ax -= wd;    ay -= ht/2;  break;  /* e */
1471   case 0x04:  ax -= wd;    ay -= ht;    break;  /* se */
1472   case 0x05:  ax -= wd/2;  ay -= ht;    break;  /* s */
1473   case 0x06:               ay -= ht;    break;  /* sw */
1474   case 0x07:               ay -= ht/2;  break;  /* w */
1475   case 0x08:  ax -= wd/2;  ay -= ht/2;  break;  /* center */
1476   }
1477
1478   zmpeg3_t *src = video->src;
1479   strack_t *strack = src->create_strack(svc->ctrk, video);
1480   if( !subtitle )
1481     subtitle = new subtitle_t(id, wd, ht);
1482   if( subtitle->done < 0 ) {
1483     if( strack->append_subtitle(subtitle,0) ) {
1484       delete subtitle;  subtitle = 0;
1485       return;
1486     }
1487   }
1488   subtitle->set_image_size(wd, ht);
1489   subtitle->x1 = ax;  subtitle->x2 = ax + wd;
1490   subtitle->y1 = ay;  subtitle->y2 = ay + ht;
1491   subtitle->draw = 1;
1492   subtitle->frame_time = video->frame_time;
1493 //print_buffer();
1494   uint8_t yy = fill_yuva >> 24;
1495   uint8_t uu = fill_yuva >> 16;
1496   uint8_t vv = fill_yuva >> 8;
1497   uint8_t aa = fill_yuva >> 0;
1498   aa = 0xff - aa;  // this is probably wrong
1499   int w = subtitle->w;
1500   int h = subtitle->h;
1501   int sz = w * h;
1502   memset(subtitle->image_y, yy, sz);
1503   memset(subtitle->image_u, uu, sz);
1504   memset(subtitle->image_v, vv, sz);
1505   memset(subtitle->image_a, aa, sz);
1506   yy = border_yuva >> 24;
1507   int hi_y, lo_y;
1508   if( (hi_y = yy + 0x60) > 0xff ) hi_y = 0xff;
1509   if( (lo_y = yy - 0x60) < 0x10 ) lo_y = 0x10;
1510   switch( border_type ) {
1511   case 0x01: /* raised */
1512     border(hi_y, yy, hi_y, yy, hi_y, yy, hi_y, yy);
1513     break;
1514   case 0x02: /* depressed */
1515     border(lo_y, yy, lo_y, yy, lo_y, yy, lo_y, yy);
1516     break;
1517   case 0x03: /* uniform */
1518     border(yy, yy, yy, yy, yy, yy, yy, yy);
1519     break;
1520   case 0x04: /* shadowl */
1521     border(lo_y, lo_y, hi_y, hi_y, hi_y, lo_y, hi_y, lo_y);
1522     break;
1523   case 0x05: /* shadowr */
1524     border(hi_y, hi_y, lo_y, lo_y, hi_y, lo_y, hi_y, lo_y);
1525     break;
1526   default:
1527   case 0x00: /* none */
1528     break;
1529   }
1530   /* render character data */
1531   switch( pdir ) {
1532   case dir_rt:
1533     for( int iy=0; iy<ch; ++iy ) {
1534       x = 0;  y = iy * fh;
1535       chr_t *bp = &bfr[iy * MX_CX];
1536       for( int ix=0; ix<cw; ++ix, ++bp ) {
1537         put_chr(bp);
1538       }
1539     }
1540     break;
1541   case dir_lt:
1542     for( int iy=0; iy<ch; ++iy ) {
1543       x = w;  y = iy * fh;
1544       chr_t *bp = &bfr[iy*MX_CX + cw];
1545       for( int ix=cw; --ix>=0; )
1546         put_chr(--bp);
1547     }
1548     break;
1549   case dir_dn:
1550     for( int ix=0; ix<cw; ++ix ) {
1551       x = ix * fw;  y = 0;
1552       chr_t *bp = &bfr[ix];
1553       for( int iy=0; iy<ch; ++iy, bp+=MX_CX )
1554         put_chr(bp);
1555     }
1556     break;
1557   case dir_up:
1558     for( int ix=0; ix<cw; ++ix ) {
1559       x = ix * fw;  y = h;
1560       chr_t *bp = &bfr[ch*MX_CX - cw + ix];
1561       for( int iy=ch; --iy>=0; ) {
1562         put_chr(bp -= MX_CX);
1563       }
1564     }
1565     break;
1566   }
1567 }
1568