src/subtitles/draw_item.cpp

   1 #include "stdafx.h"
   2 #include "draw_item.h"
   3 #include <vector>
   4 #include <algorithm>
   5 #include <boost/shared_ptr.hpp>
   6 #include "xy_overlay_paint_machine.h"
   7 #include "xy_clipper_paint_machine.h"
   8
   9 using namespace std;
  10
  11 //////////////////////////////////////////////////////////////////////////
  12 //
  13 // DrawItem
  14 //
  15 CRect DrawItem::GetDirtyRect()
  16 {
  17     CRect r;
  18     if(!switchpts || !fBody && !fBorder) return(r);
  19
  20     ASSERT(overlay_paint_machine);
  21     CRect overlay_rect = overlay_paint_machine->CalcDirtyRect();
  22
  23     // Remember that all subtitle coordinates are specified in 1/8 pixels
  24     // (x+4)>>3 rounds to nearest whole pixel.
  25     // ??? What is xsub, ysub, mOffsetX and mOffsetY ?
  26     int x = (xsub + overlay_rect.left + 4)>>3;
  27     int y = (ysub + overlay_rect.top + 4)>>3;
  28     int w = overlay_rect.Width()>>3;
  29     int h = overlay_rect.Height()>>3;
  30     r = clip_rect & CRect(x, y, x+w, y+h);
  31     r &= clipper->CalcDirtyRect();
  32     return r;
  33 }
  34
  35 CRect DrawItem::Draw( SubPicDesc& spd, DrawItem& draw_item, const CRect& clip_rect )
  36 {
  37     CRect result;
  38     SharedPtrGrayImage2 alpha_mask;
  39     draw_item.clipper->Paint(&alpha_mask);
  40
  41     SharedPtrOverlay overlay;
  42     ASSERT(draw_item.overlay_paint_machine);
  43     draw_item.overlay_paint_machine->Paint(&overlay);
  44
  45     const SharedPtrByte& alpha = Rasterizer::CompositeAlphaMask(spd, overlay, draw_item.clip_rect & clip_rect, alpha_mask.get(),
  46         draw_item.xsub, draw_item.ysub, draw_item.switchpts, draw_item.fBody, draw_item.fBorder,
  47         &result);
  48     Rasterizer::Draw(spd, overlay, result, alpha.get(),
  49         draw_item.xsub, draw_item.ysub, draw_item.switchpts, draw_item.fBody, draw_item.fBorder);
  50     return result;
  51 }
  52
  53 DrawItem* DrawItem::CreateDrawItem( const SharedPtrOverlayPaintMachine& overlay_paint_machine, const CRect& clipRect,
  54     const SharedPtrCClipperPaintMachine &clipper, int xsub, int ysub, const DWORD* switchpts, bool fBody, bool fBorder )
  55 {
  56     DrawItem* result = new DrawItem();
  57     result->overlay_paint_machine = overlay_paint_machine;
  58     result->clip_rect = clipRect;
  59     result->clipper = clipper;
  60     result->xsub = xsub;
  61     result->ysub = ysub;
  62
  63     memcpy(result->switchpts, switchpts, sizeof(result->switchpts));
  64     result->fBody = fBody;
  65     result->fBorder = fBorder;
  66     return result;
  67 }
  68
  69 //////////////////////////////////////////////////////////////////////////
  70 //
  71 // CompositeDrawItem
  72 //
  73
  74 CRect CompositeDrawItem::GetDirtyRect( CompositeDrawItem& item )
  75 {
  76     CRect result;
  77     if (item.shadow)
  78     {
  79         result |= item.shadow->GetDirtyRect();
  80     }
  81     if (item.outline)
  82     {
  83         result |= item.outline->GetDirtyRect();
  84     }
  85     if (item.body)
  86     {
  87         result |= *item.body->GetDirtyRect();
  88     }
  89     return result;
  90 }
  91
  92 struct GroupedDrawItems
  93 {
  94     CAtlList<SharedPtrDrawItem> draw_item_list;
  95     CRect clip_rect;
  96 };
  97
  98 //temporary data struct for the complex dirty rect splitting and draw item grouping algorithm
  99 struct CompositeDrawItemEx
 100 {
 101     CompositeDrawItem *item;
 102     CAtlList<int> rect_id_list;
 103 };
 104
 105
 106 typedef CAtlList<CompositeDrawItemEx*> PCompositeDrawItemExList;
 107 typedef CAtlArray<CompositeDrawItemEx> CompositeDrawItemExVec;
 108 typedef CAtlArray<CompositeDrawItemExVec> CompositeDrawItemExTree;
 109
 110 typedef ::boost::shared_ptr<PCompositeDrawItemExList> SharedPCompositeDrawItemExList;
 111
 112 class XyRectEx: public CRect
 113 {
 114 public:
 115     SharedPCompositeDrawItemExList item_ex_list;
 116
 117     void SetRect(const RECT& rect)
 118     {
 119         __super::operator=(rect);
 120     }
 121     void SetRect(
 122         _In_ int x1,
 123         _In_ int y1,
 124         _In_ int x2,
 125         _In_ int y2) throw()
 126     {
 127         __super::SetRect(x1,y1,x2,y2);
 128     }
 129 };
 130
 131 typedef CAtlList<XyRectEx> XyRectExList;
 132
 133 void MergeRects(const XyRectExList& input, XyRectExList* output);
 134 void CreateDrawItemExTree( CompositeDrawItemListList& input,
 135     CompositeDrawItemExTree *out_draw_item_ex_tree,
 136     XyRectExList *out_rect_ex_list );
 137
 138 void CompositeDrawItem::Draw( SubPicDesc& spd, CompositeDrawItemListList& compDrawItemListList )
 139 {
 140     CompositeDrawItemExTree draw_item_ex_tree;
 141     XyRectExList rect_ex_list;
 142     CreateDrawItemExTree(compDrawItemListList, &draw_item_ex_tree, &rect_ex_list);
 143
 144     XyRectExList grouped_rect_exs;
 145     MergeRects(rect_ex_list, &grouped_rect_exs);
 146
 147     CAtlArray<GroupedDrawItems> grouped_draw_items;
 148
 149     grouped_draw_items.SetCount(grouped_rect_exs.GetCount());
 150
 151     POSITION pos = grouped_rect_exs.GetHeadPosition();
 152     for(int rect_id=0;pos;rect_id++)
 153     {
 154         XyRectEx& item = grouped_rect_exs.GetNext(pos);
 155         grouped_draw_items.GetAt(rect_id).clip_rect = item;
 156         POSITION pos_item = item.item_ex_list->GetHeadPosition();
 157         while(pos_item)
 158         {
 159             CompositeDrawItemEx* draw_item_ex = item.item_ex_list->GetNext(pos_item);
 160             if( draw_item_ex->rect_id_list.GetTail() != rect_id )//wipe out repeated item. this safe since the list has a dummy item -1
 161                 draw_item_ex->rect_id_list.AddTail(rect_id);
 162         }
 163     }
 164     for (int i=0;i<draw_item_ex_tree.GetCount();i++)
 165     {
 166         CompositeDrawItemExVec &draw_item_ex_vec = draw_item_ex_tree[i];
 167         for (int j=0;j<draw_item_ex_vec.GetCount();j++)
 168         {
 169             CompositeDrawItemEx &draw_item_ex = draw_item_ex_vec[j];
 170             if (draw_item_ex.item->shadow)
 171             {
 172                 pos = draw_item_ex.rect_id_list.GetHeadPosition();;
 173                 draw_item_ex.rect_id_list.GetNext(pos);
 174                 while(pos)
 175                 {
 176                     int id = draw_item_ex.rect_id_list.GetNext(pos);
 177                     grouped_draw_items[id].draw_item_list.AddTail( draw_item_ex.item->shadow );
 178                 }
 179             }
 180         }
 181         for (int j=0;j<draw_item_ex_vec.GetCount();j++)
 182         {
 183             CompositeDrawItemEx &draw_item_ex = draw_item_ex_vec[j];
 184             if (draw_item_ex.item->outline)
 185             {
 186                 pos = draw_item_ex.rect_id_list.GetHeadPosition();;
 187                 draw_item_ex.rect_id_list.GetNext(pos);
 188                 while(pos)
 189                 {
 190                     int id = draw_item_ex.rect_id_list.GetNext(pos);
 191                     grouped_draw_items[id].draw_item_list.AddTail( draw_item_ex.item->outline );
 192                 }
 193             }
 194         }
 195         for (int j=0;j<draw_item_ex_vec.GetCount();j++)
 196         {
 197             CompositeDrawItemEx &draw_item_ex = draw_item_ex_vec[j];
 198             if (draw_item_ex.item->body)
 199             {
 200                 pos = draw_item_ex.rect_id_list.GetHeadPosition();;
 201                 draw_item_ex.rect_id_list.GetNext(pos);
 202                 while(pos)
 203                 {
 204                     int id = draw_item_ex.rect_id_list.GetNext(pos);
 205                     grouped_draw_items[id].draw_item_list.AddTail( draw_item_ex.item->body );
 206                 }
 207             }
 208         }
 209     }
 210
 211     for (int i=0;i<grouped_draw_items.GetCount();i++)
 212     {
 213         GroupedDrawItems& item = grouped_draw_items[i];
 214         pos = item.draw_item_list.GetHeadPosition();
 215         while(pos)
 216         {
 217             DrawItem::Draw(spd, *item.draw_item_list.GetNext(pos), item.clip_rect);
 218         }
 219     }
 220 }
 221
 222 void CreateDrawItemExTree( CompositeDrawItemListList& input,
 223     CompositeDrawItemExTree *out_draw_item_ex_tree,
 224     XyRectExList *out_rect_ex_list )
 225 {
 226     ASSERT(out_draw_item_ex_tree!=NULL && out_rect_ex_list!=NULL);
 227
 228     int list_count = input.GetCount();
 229     out_draw_item_ex_tree->SetCount(list_count);
 230     POSITION list_pos = input.GetHeadPosition();
 231     for (int list_id=0;list_id<list_count;list_id++)
 232     {
 233         CompositeDrawItemList& compDrawItemList = input.GetNext(list_pos);
 234         int count = compDrawItemList.GetCount();
 235         CompositeDrawItemExVec& out_draw_item_exs = out_draw_item_ex_tree->GetAt(list_id);
 236         out_draw_item_exs.SetCount(count);
 237         POSITION item_pos = compDrawItemList.GetHeadPosition();
 238         for (int item_id=0; item_id<count; item_id++ )
 239         {
 240             CompositeDrawItem& comp_draw_item = compDrawItemList.GetNext(item_pos);
 241             CompositeDrawItemEx& comp_draw_item_ex = out_draw_item_exs.GetAt(item_id);
 242             comp_draw_item_ex.item = &comp_draw_item;
 243             comp_draw_item_ex.rect_id_list.AddHead(-1);//dummy head
 244
 245             XyRectEx &rect_ex = out_rect_ex_list->GetAt(out_rect_ex_list->AddTail());
 246             rect_ex.item_ex_list.reset(new PCompositeDrawItemExList());
 247             rect_ex.item_ex_list->AddTail( &comp_draw_item_ex);
 248             rect_ex.SetRect( CompositeDrawItem::GetDirtyRect(comp_draw_item) );
 249         }
 250     }
 251 }
 252
 253 void MergeRects(const XyRectExList& input, XyRectExList* output)
 254 {
 255     int input_count = input.GetCount();
 256     if(output==NULL || input_count==0)
 257         return;
 258
 259     typedef CAtlList<XyRectEx> Segment;
 260
 261     struct BreakPoint
 262     {
 263         int x;
 264         const XyRectEx* rect;
 265
 266         inline bool operator<(const BreakPoint& breakpoint ) const
 267         {
 268             return (x < breakpoint.x);
 269         }
 270     };
 271
 272     std::vector<int> vertical_breakpoints(2*input_count);
 273     std::vector<BreakPoint> herizon_breakpoints(input_count);
 274
 275     POSITION pos = input.GetHeadPosition();
 276     for(int i=0; i<input_count; i++)
 277     {
 278         const XyRectEx& rect = input.GetNext(pos);
 279         vertical_breakpoints[2*i]=rect.top;
 280         vertical_breakpoints[2*i+1]=rect.bottom;
 281
 282         herizon_breakpoints[i].x = rect.left;
 283         herizon_breakpoints[i].rect = &rect;
 284     }
 285
 286     std::sort(vertical_breakpoints.begin(), vertical_breakpoints.end());
 287     std::sort(herizon_breakpoints.begin(), herizon_breakpoints.end());
 288
 289     CAtlArray<Segment> tempSegments;
 290     tempSegments.SetCount(vertical_breakpoints.size()-1);
 291     int prev = vertical_breakpoints[0], count = 0;
 292     for(int ptr = 1; ptr<vertical_breakpoints.size(); ptr++)
 293     {
 294         if(vertical_breakpoints[ptr] != prev)
 295         {
 296             Segment& seg = tempSegments[count];
 297             seg.AddTail();
 298             seg.GetTail().SetRect(INT_MIN, prev, INT_MIN, vertical_breakpoints[ptr]);
 299             seg.GetTail().item_ex_list.reset(new PCompositeDrawItemExList());
 300
 301             prev = vertical_breakpoints[ptr];
 302             count++;
 303         }
 304     }
 305
 306     for(int i=0; i<input_count; i++)
 307     {
 308         const XyRectEx& rect = *herizon_breakpoints[i].rect;
 309
 310         int start = 0, mid, end = count;
 311
 312         while(start<end)
 313         {
 314             mid = (start+end)>>1;
 315             if(tempSegments[mid].GetTail().top < rect.top)
 316             {
 317                 start = mid+1;
 318             }
 319             else
 320             {
 321                 end = mid;
 322             }
 323         }
 324         for(; start < count; start++)
 325         {
 326             CAtlList<XyRectEx>& cur_line = tempSegments[start];
 327             XyRectEx & item = cur_line.GetTail();
 328             if (item.top >= rect.bottom)
 329             {
 330                 break;
 331             }
 332             if (item.right<rect.left)
 333             {
 334                 cur_line.AddTail();
 335                 XyRectEx & new_item = cur_line.GetTail();
 336                 new_item.SetRect( rect.left, item.top, rect.right, item.bottom );
 337                 new_item.item_ex_list.reset(new PCompositeDrawItemExList());
 338                 new_item.item_ex_list->AddTailList( rect.item_ex_list.get() );
 339             }
 340             else
 341             {
 342                 if (item.right<rect.right)
 343                 {
 344                     item.right = rect.right;
 345                 }
 346                 item.item_ex_list->AddTailList( rect.item_ex_list.get() );
 347             }
 348         }
 349     }
 350
 351     for (int i=count-1;i>0;i--)
 352     {
 353         CAtlList<XyRectEx>& cur_line = tempSegments[i];
 354         CAtlList<XyRectEx>& upper_line = tempSegments[i-1];
 355
 356         POSITION pos_cur_line = cur_line.GetTailPosition();
 357         XyRectEx *cur_rect = &cur_line.GetPrev(pos_cur_line);
 358         if(cur_rect->top == upper_line.GetTail().bottom)
 359         {
 360             POSITION pos = upper_line.GetTailPosition();
 361             while(pos)
 362             {
 363                 XyRectEx& upper_rect = upper_line.GetPrev(pos);
 364                 while( upper_rect.right<cur_rect->right || upper_rect.left<cur_rect->left )
 365                 {
 366                     output->AddHead(*cur_rect);
 367                     //if(!cur_line.IsEmpty())
 368                     cur_rect = &cur_line.GetPrev(pos_cur_line);
 369                 }
 370                 if(!pos_cur_line)
 371                     break;
 372
 373                 if(upper_rect.right==cur_rect->right && upper_rect.left==cur_rect->left)
 374                 {
 375                     upper_rect.bottom = cur_rect->bottom;
 376                     upper_rect.item_ex_list->AddTailList( cur_rect->item_ex_list.get() );
 377                     //if(!cur_line.IsEmpty())
 378                     cur_rect = &cur_line.GetPrev(pos_cur_line);
 379                 }
 380                 //else if ( upper_rect.right>cur_rect.right || upper_rect.left>cur_rect.left )
 381             }
 382         }
 383         while(pos_cur_line)
 384         {
 385             output->AddHead(*cur_rect);
 386             cur_rect = &cur_line.GetPrev(pos_cur_line);
 387         }
 388     }
 389     if(count>0)
 390     {
 391         CAtlList<XyRectEx>& cur_line = tempSegments[0];
 392         POSITION pos_cur_line = cur_line.GetTailPosition();
 393         XyRectEx *cur_rect = &cur_line.GetPrev(pos_cur_line);
 394         while(pos_cur_line)
 395         {
 396             output->AddHead(*cur_rect);
 397             cur_rect = &cur_line.GetPrev(pos_cur_line);
 398         }
 399     }
 400 }
 401