libmenu/menu.c

   1
   2 #include "config.h"
   3 #include "mp_msg.h"
   4 #include "help_mp.h"
   5
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11
  12 #include "libvo/osd.h"
  13 #include "libvo/font_load.h"
  14 #include "libvo/sub.h"
  15 #include "osdep/keycodes.h"
  16 #include "asxparser.h"
  17 #include "stream/stream.h"
  18
  19 #include "libmpcodecs/img_format.h"
  20 #include "libmpcodecs/mp_image.h"
  21 #include "m_option.h"
  22 #include "m_struct.h"
  23 #include "menu.h"
  24
  25 extern menu_info_t menu_info_cmdlist;
  26 extern menu_info_t menu_info_pt;
  27 extern menu_info_t menu_info_filesel;
  28 extern menu_info_t menu_info_txt;
  29 extern menu_info_t menu_info_console;
  30 extern menu_info_t menu_info_pref;
  31 #ifdef HAS_DVBIN_SUPPORT
  32 extern menu_info_t menu_info_dvbsel;
  33 #endif
  34
  35
  36 menu_info_t* menu_info_list[] = {
  37   &menu_info_pt,
  38   &menu_info_cmdlist,
  39   &menu_info_filesel,
  40   &menu_info_txt,
  41   &menu_info_console,
  42 #ifdef HAS_DVBIN_SUPPORT
  43   &menu_info_dvbsel,
  44 #endif
  45   &menu_info_pref,
  46   NULL
  47 };
  48
  49 typedef struct menu_def_st {
  50   char* name;
  51   menu_info_t* type;
  52   void* cfg;
  53   char* args;
  54 } menu_def_t;
  55
  56 static struct MPContext *menu_ctx = NULL;
  57 static menu_def_t* menu_list = NULL;
  58 static int menu_count = 0;
  59
  60
  61 static int menu_parse_config(char* buffer) {
  62   char *element,*body, **attribs, *name;
  63   menu_info_t* minfo = NULL;
  64   int r,i;
  65   ASX_Parser_t* parser = asx_parser_new();
  66
  67   while(1) {
  68     r = asx_get_element(parser,&buffer,&element,&body,&attribs);
  69     if(r < 0) {
  70       mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_SyntaxErrorAtLine,parser->line);
  71       asx_parser_free(parser);
  72       return 0;
  73     } else if(r == 0) {
  74       asx_parser_free(parser);
  75       return 1;
  76     }
  77     // Has it a name ?
  78     name = asx_get_attrib("name",attribs);
  79     if(!name) {
  80       mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_MenuDefinitionsNeedANameAttrib,parser->line);
  81       free(element);
  82       if(body) free(body);
  83       asx_free_attribs(attribs);
  84       continue;
  85     }
  86
  87     // Try to find this menu type in our list
  88     for(i = 0, minfo = NULL ; menu_info_list[i] ; i++) {
  89       if(strcasecmp(element,menu_info_list[i]->name) == 0) {
  90         minfo = menu_info_list[i];
  91         break;
  92       }
  93     }
  94     // Got it : add this to our list
  95     if(minfo) {
  96       menu_list = realloc(menu_list,(menu_count+2)*sizeof(menu_def_t));
  97       menu_list[menu_count].name = name;
  98       menu_list[menu_count].type = minfo;
  99       menu_list[menu_count].cfg = m_struct_alloc(&minfo->priv_st);
 100       menu_list[menu_count].args = body;
 101       // Setup the attribs
 102       for(i = 0 ; attribs[2*i] ; i++) {
 103         if(strcasecmp(attribs[2*i],"name") == 0) continue;
 104         if(!m_struct_set(&minfo->priv_st,menu_list[menu_count].cfg,attribs[2*i], attribs[2*i+1]))
 105           mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_BadAttrib,attribs[2*i],attribs[2*i+1],
 106                  name,parser->line);
 107       }
 108       menu_count++;
 109       memset(&menu_list[menu_count],0,sizeof(menu_def_t));
 110     } else {
 111       mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_UnknownMenuType,element,parser->line);
 112       free(name);
 113       if(body) free(body);
 114     }
 115
 116     free(element);
 117     asx_free_attribs(attribs);
 118   }
 119
 120 }
 121
 122
 123 /// This will build the menu_defs list from the cfg file
 124 #define BUF_STEP 1024
 125 #define BUF_MIN 128
 126 #define BUF_MAX BUF_STEP*1024
 127 int menu_init(struct MPContext *mpctx, char* cfg_file) {
 128   char* buffer = NULL;
 129   int bl = BUF_STEP, br = 0;
 130   int f, fd;
 131 #ifndef HAVE_FREETYPE
 132   if(vo_font == NULL)
 133     return 0;
 134 #endif
 135   fd = open(cfg_file, O_RDONLY);
 136   if(fd < 0) {
 137     mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_CantOpenConfigFile,cfg_file);
 138     return 0;
 139   }
 140   buffer = malloc(bl);
 141   while(1) {
 142     int r;
 143     if(bl - br < BUF_MIN) {
 144       if(bl >= BUF_MAX) {
 145         mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_ConfigFileIsTooBig,BUF_MAX/1024);
 146         close(fd);
 147         free(buffer);
 148         return 0;
 149       }
 150       bl += BUF_STEP;
 151       buffer = realloc(buffer,bl);
 152     }
 153     r = read(fd,buffer+br,bl-br);
 154     if(r == 0) break;
 155     br += r;
 156   }
 157   if(!br) {
 158     mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_ConfigFileIsEmpty);
 159     return 0;
 160   }
 161   buffer[br-1] = '\0';
 162
 163   close(fd);
 164
 165   menu_ctx = mpctx;
 166   f = menu_parse_config(buffer);
 167   free(buffer);
 168   return f;
 169 }
 170
 171 // Destroy all this stuff
 172 void menu_unint(void) {
 173   int i;
 174   for(i = 0 ; menu_list && menu_list[i].name ; i++) {
 175     free(menu_list[i].name);
 176     m_struct_free(&menu_list[i].type->priv_st,menu_list[i].cfg);
 177     if(menu_list[i].args) free(menu_list[i].args);
 178   }
 179   free(menu_list);
 180   menu_count = 0;
 181 }
 182
 183 /// Default read_key function
 184 void menu_dflt_read_key(menu_t* menu,int cmd) {
 185   switch(cmd) {
 186   case KEY_UP:
 187     menu->read_cmd(menu,MENU_CMD_UP);
 188     break;
 189   case KEY_DOWN:
 190     menu->read_cmd(menu,MENU_CMD_DOWN);
 191     break;
 192   case KEY_LEFT:
 193     menu->read_cmd(menu,MENU_CMD_LEFT);
 194     break;
 195   case KEY_ESC:
 196     menu->read_cmd(menu,MENU_CMD_CANCEL);
 197     break;
 198   case KEY_RIGHT:
 199     menu->read_cmd(menu,MENU_CMD_RIGHT);
 200     break;
 201   case KEY_ENTER:
 202     menu->read_cmd(menu,MENU_CMD_OK);
 203     break;
 204   }
 205 }
 206
 207 menu_t* menu_open(char *name) {
 208   menu_t* m;
 209   int i;
 210
 211   for(i = 0 ; menu_list[i].name != NULL ; i++) {
 212     if(strcmp(name,menu_list[i].name) == 0)
 213       break;
 214   }
 215   if(menu_list[i].name == NULL) {
 216     mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_MenuNotFound,name);
 217     return NULL;
 218   }
 219   m = calloc(1,sizeof(menu_t));
 220   m->priv_st = &(menu_list[i].type->priv_st);
 221   m->priv = m_struct_copy(m->priv_st,menu_list[i].cfg);
 222   m->ctx = menu_ctx;
 223   if(menu_list[i].type->open(m,menu_list[i].args))
 224     return m;
 225   if(m->priv)
 226     m_struct_free(m->priv_st,m->priv);
 227   free(m);
 228   mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_MenuInitFailed,name);
 229   return NULL;
 230 }
 231
 232 void menu_draw(menu_t* menu,mp_image_t* mpi) {
 233   if(menu->show && menu->draw)
 234     menu->draw(menu,mpi);
 235 }
 236
 237 void menu_read_cmd(menu_t* menu,int cmd) {
 238   if(menu->read_cmd)
 239     menu->read_cmd(menu,cmd);
 240 }
 241
 242 void menu_close(menu_t* menu) {
 243   if(menu->close)
 244     menu->close(menu);
 245   if(menu->priv)
 246     m_struct_free(menu->priv_st,menu->priv);
 247   free(menu);
 248 }
 249
 250 void menu_read_key(menu_t* menu,int cmd) {
 251   if(menu->read_key)
 252     menu->read_key(menu,cmd);
 253   else
 254     menu_dflt_read_key(menu,cmd);
 255 }
 256
 257 ///////////////////////////// Helpers ////////////////////////////////////
 258
 259 typedef void (*draw_alpha_f)(int w,int h, unsigned char* src, unsigned char *srca, int srcstride, unsigned char* dstbase,int dststride);
 260
 261 inline static draw_alpha_f get_draw_alpha(uint32_t fmt) {
 262   switch(fmt) {
 263   case IMGFMT_BGR15:
 264   case IMGFMT_RGB15:
 265     return vo_draw_alpha_rgb15;
 266   case IMGFMT_BGR16:
 267   case IMGFMT_RGB16:
 268     return vo_draw_alpha_rgb16;
 269   case IMGFMT_BGR24:
 270   case IMGFMT_RGB24:
 271     return vo_draw_alpha_rgb24;
 272   case IMGFMT_BGR32:
 273   case IMGFMT_RGB32:
 274     return vo_draw_alpha_rgb32;
 275   case IMGFMT_YV12:
 276   case IMGFMT_I420:
 277   case IMGFMT_IYUV:
 278   case IMGFMT_YVU9:
 279   case IMGFMT_IF09:
 280   case IMGFMT_Y800:
 281   case IMGFMT_Y8:
 282     return vo_draw_alpha_yv12;
 283   case IMGFMT_YUY2:
 284     return vo_draw_alpha_yuy2;
 285   case IMGFMT_UYVY:
 286     return vo_draw_alpha_uyvy;
 287   }
 288
 289   return NULL;
 290 }
 291
 292 // return the real height of a char:
 293 static inline int get_height(int c,int h){
 294     int font;
 295     if ((font=vo_font->font[c])>=0)
 296         if(h<vo_font->pic_a[font]->h) h=vo_font->pic_a[font]->h;
 297     return h;
 298 }
 299
 300 static void render_txt(char *txt)
 301 {
 302   while (*txt) {
 303     int c = utf8_get_char((const char**)&txt);
 304     render_one_glyph(vo_font, c);
 305   }
 306 }
 307
 308 #ifdef USE_FRIBIDI
 309 #include <fribidi/fribidi.h>
 310 #include "libavutil/common.h"
 311 char *menu_fribidi_charset = NULL;
 312 int menu_flip_hebrew = 0;
 313 int menu_fribidi_flip_commas = 0;
 314
 315 static char *menu_fribidi(char *txt)
 316 {
 317   static int char_set_num = -1;
 318   static FriBidiChar *logical, *visual;
 319   static size_t buffer_size = 1024;
 320   static char *outputstr;
 321
 322   FriBidiCharType base;
 323   fribidi_boolean log2vis;
 324   size_t len;
 325
 326   if (menu_flip_hebrew) {
 327     len = strlen(txt);
 328     if (char_set_num == -1) {
 329       fribidi_set_mirroring (1);
 330       fribidi_set_reorder_nsm (0);
 331       char_set_num = fribidi_parse_charset("UTF-8");
 332       buffer_size = FFMAX(1024,len+1);
 333       logical = malloc(buffer_size);
 334       visual = malloc(buffer_size);
 335       outputstr = malloc(buffer_size);
 336     } else if (len+1 > buffer_size) {
 337       buffer_size = len+1;
 338       logical = realloc(logical, buffer_size);
 339       visual = realloc(visual, buffer_size);
 340       outputstr = realloc(outputstr, buffer_size);
 341     }
 342     len = fribidi_charset_to_unicode (char_set_num, txt, len, logical);
 343     base = menu_fribidi_flip_commas?FRIBIDI_TYPE_ON:FRIBIDI_TYPE_L;
 344     log2vis = fribidi_log2vis (logical, len, &base, visual, NULL, NULL, NULL);
 345     if (log2vis) {
 346       len = fribidi_remove_bidi_marks (visual, len, NULL, NULL, NULL);
 347       fribidi_unicode_to_charset (char_set_num, visual, len, outputstr);
 348       return outputstr;
 349     }
 350   }
 351   return txt;
 352 }
 353 #endif
 354
 355 void menu_draw_text(mp_image_t* mpi,char* txt, int x, int y) {
 356   draw_alpha_f draw_alpha = get_draw_alpha(mpi->imgfmt);
 357   int font;
 358
 359   if(!draw_alpha) {
 360     mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_UnsupportedOutformat);
 361     return;
 362   }
 363
 364 #ifdef USE_FRIBIDI
 365   txt = menu_fribidi(txt);
 366 #endif
 367   render_txt(txt);
 368
 369   while (*txt) {
 370     int c=utf8_get_char((const char**)&txt);
 371     if ((font=vo_font->font[c])>=0 && (x + vo_font->width[c] <= mpi->w) && (y + vo_font->pic_a[font]->h <= mpi->h))
 372       draw_alpha(vo_font->width[c], vo_font->pic_a[font]->h,
 373                  vo_font->pic_b[font]->bmp+vo_font->start[c],
 374                  vo_font->pic_a[font]->bmp+vo_font->start[c],
 375                  vo_font->pic_a[font]->w,
 376                  mpi->planes[0] + y * mpi->stride[0] + x * (mpi->bpp>>3),
 377                  mpi->stride[0]);
 378     x+=vo_font->width[c]+vo_font->charspace;
 379   }
 380
 381 }
 382
 383 void menu_draw_text_full(mp_image_t* mpi,char* txt,
 384                          int x, int y,int w, int h,
 385                          int vspace, int warp, int align, int anchor) {
 386   int need_w,need_h;
 387   int sy, ymin, ymax;
 388   int sx, xmin, xmax, xmid, xrmin;
 389   int ll = 0;
 390   int font;
 391   draw_alpha_f draw_alpha = get_draw_alpha(mpi->imgfmt);
 392
 393   if(!draw_alpha) {
 394     mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_UnsupportedOutformat);
 395     return;
 396   }
 397
 398 #ifdef USE_FRIBIDI
 399   txt = menu_fribidi(txt);
 400 #endif
 401   render_txt(txt);
 402
 403   if(x > mpi->w || y > mpi->h)
 404     return;
 405
 406   if(anchor & MENU_TEXT_VCENTER) {
 407     if(h <= 0) h = mpi->h;
 408     ymin = y - h/2;
 409     ymax = y + h/2;
 410   }  else if(anchor & MENU_TEXT_BOT) {
 411     if(h <= 0) h = mpi->h - y;
 412     ymin = y - h;
 413     ymax = y;
 414   } else {
 415     if(h <= 0) h = mpi->h - y;
 416     ymin = y;
 417     ymax = y + h;
 418   }
 419
 420   if(anchor & MENU_TEXT_HCENTER) {
 421     if(w <= 0) w = mpi->w;
 422     xmin = x - w/2;
 423     xmax = x + w/2;
 424   }  else if(anchor & MENU_TEXT_RIGHT) {
 425     if(w <= 0) w = mpi->w -x;
 426     xmin = x - w;
 427     xmax = x;
 428   } else {
 429     if(w <= 0) w = mpi->w -x;
 430     xmin = x;
 431     xmax = x + w;
 432   }
 433
 434   // How many space do we need to draw this ?
 435   menu_text_size(txt,w,vspace,warp,&need_w,&need_h);
 436
 437   // Find the first line
 438   if(align & MENU_TEXT_VCENTER)
 439     sy = ymin + ((h - need_h)/2);
 440   else if(align & MENU_TEXT_BOT)
 441     sy = ymax - need_h - 1;
 442   else
 443     sy = y;
 444
 445 #if 0
 446   // Find the first col
 447   if(align & MENU_TEXT_HCENTER)
 448     sx = xmin + ((w - need_w)/2);
 449   else if(align & MENU_TEXT_RIGHT)
 450     sx = xmax - need_w;
 451 #endif
 452
 453   xmid = xmin + (xmax - xmin) / 2;
 454   xrmin = xmin;
 455   // Clamp the bb to the mpi size
 456   if(ymin < 0) ymin = 0;
 457   if(xmin < 0) xmin = 0;
 458   if(ymax > mpi->h) ymax = mpi->h;
 459   if(xmax > mpi->w) xmax = mpi->w;
 460
 461   // Jump some the beginnig text if needed
 462   while(sy < ymin && *txt) {
 463     int c=utf8_get_char((const char**)&txt);
 464     if(c == '\n' || (warp && ll + vo_font->width[c] > w)) {
 465       ll = 0;
 466       sy += vo_font->height + vspace;
 467       if(c == '\n') continue;
 468     }
 469     ll += vo_font->width[c]+vo_font->charspace;
 470   }
 471   if(*txt == '\0') // Nothing left to draw
 472       return;
 473
 474   while(sy < ymax && *txt) {
 475     char* line_end = NULL;
 476     int n;
 477
 478     if(txt[0] == '\n') { // New line
 479       sy += vo_font->height + vspace;
 480       txt++;
 481       continue;
 482     }
 483
 484     // Get the length and end of this line
 485     for(n = 0, ll = 0 ; txt[n] != '\0' && txt[n] != '\n'  ; n++) {
 486       unsigned char c = txt[n];
 487       if(warp && ll + vo_font->width[c]  > w)  break;
 488       ll += vo_font->width[c]+vo_font->charspace;
 489     }
 490     line_end = &txt[n];
 491     ll -= vo_font->charspace;
 492
 493
 494     if(align & (MENU_TEXT_HCENTER|MENU_TEXT_RIGHT)) {
 495       // Too long line
 496       if(ll > xmax-xmin) {
 497         if(align & MENU_TEXT_HCENTER) {
 498           int mid = ll/2;
 499           // Find the middle point
 500           for(n--, ll = 0 ; n <= 0 ; n--) {
 501             ll += vo_font->width[(int)txt[n]]+vo_font->charspace;
 502             if(ll - vo_font->charspace > mid) break;
 503           }
 504           ll -= vo_font->charspace;
 505           sx = xmid + mid - ll;
 506         } else// MENU_TEXT_RIGHT)
 507           sx = xmax + vo_font->charspace;
 508
 509         // We are after the start point -> go back
 510         if(sx > xmin) {
 511           for(n-- ; n <= 0 ; n--) {
 512             unsigned char c = txt[n];
 513             if(sx - vo_font->width[c] - vo_font->charspace < xmin) break;
 514             sx -= vo_font->width[c]+vo_font->charspace;
 515           }
 516         } else { // We are before the start point -> go forward
 517           for( ; sx < xmin && (&txt[n]) != line_end ; n++) {
 518             unsigned char c = txt[n];
 519             sx += vo_font->width[c]+vo_font->charspace;
 520           }
 521         }
 522         txt = &txt[n]; // Jump to the new start char
 523       } else {
 524         if(align & MENU_TEXT_HCENTER)
 525           sx = xmid - ll/2;
 526         else
 527           sx = xmax - 1 - ll;
 528       }
 529     } else {
 530       for(sx = xrmin ;  sx < xmin && txt != line_end ; txt++) {
 531         unsigned char c = txt[n];
 532         sx += vo_font->width[c]+vo_font->charspace;
 533       }
 534     }
 535
 536     while(sx < xmax && txt != line_end) {
 537       int c=utf8_get_char((const char**)&txt);
 538       font = vo_font->font[c];
 539       if(font >= 0) {
 540         int cs = (vo_font->pic_a[font]->h - vo_font->height) / 2;
 541         if ((sx + vo_font->width[c] < xmax)  &&  (sy + vo_font->height < ymax) )
 542           draw_alpha(vo_font->width[c], vo_font->height,
 543                      vo_font->pic_b[font]->bmp+vo_font->start[c] +
 544                      cs * vo_font->pic_a[font]->w,
 545                      vo_font->pic_a[font]->bmp+vo_font->start[c] +
 546                      cs * vo_font->pic_a[font]->w,
 547                      vo_font->pic_a[font]->w,
 548                      mpi->planes[0] + sy * mpi->stride[0] + sx * (mpi->bpp>>3),
 549                      mpi->stride[0]);
 550         //      else
 551         //printf("Can't draw '%c'\n",c);
 552       }
 553       sx+=vo_font->width[c]+vo_font->charspace;
 554     }
 555     txt = line_end;
 556     if(txt[0] == '\0') break;
 557     sy += vo_font->height + vspace;
 558   }
 559 }
 560
 561 int menu_text_length(char* txt) {
 562   int l = 0;
 563   render_txt(txt);
 564   while (*txt) {
 565     int c=utf8_get_char((const char**)&txt);
 566     l += vo_font->width[c]+vo_font->charspace;
 567   }
 568   return l - vo_font->charspace;
 569 }
 570
 571 void menu_text_size(char* txt,int max_width, int vspace, int warp, int* _w, int* _h) {
 572   int l = 1, i = 0;
 573   int w = 0;
 574
 575   render_txt(txt);
 576   while (*txt) {
 577     int c=utf8_get_char((const char**)&txt);
 578     if(c == '\n' || (warp && i + vo_font->width[c] >= max_width)) {
 579       if(*txt)
 580         l++;
 581       i = 0;
 582       if(c == '\n') continue;
 583     }
 584     i += vo_font->width[c]+vo_font->charspace;
 585     if(i > w) w = i;
 586   }
 587
 588   *_w = w;
 589   *_h = (l-1) * (vo_font->height + vspace) + vo_font->height;
 590 }
 591
 592
 593 int menu_text_num_lines(char* txt, int max_width) {
 594   int l = 1, i = 0;
 595   render_txt(txt);
 596   while (*txt) {
 597     int c=utf8_get_char((const char**)&txt);
 598     if(c == '\n' || i + vo_font->width[c] > max_width) {
 599       l++;
 600       i = 0;
 601       if(c == '\n') continue;
 602     }
 603     i += vo_font->width[c]+vo_font->charspace;
 604   }
 605   return l;
 606 }
 607
 608 char* menu_text_get_next_line(char* txt, int max_width) {
 609   int i = 0;
 610   render_txt(txt);
 611   while (*txt) {
 612     int c=utf8_get_char((const char**)&txt);
 613     if(c == '\n') {
 614       txt++;
 615       break;
 616     }
 617     i += vo_font->width[c];
 618     if(i >= max_width)
 619       break;
 620     i += vo_font->charspace;
 621   }
 622   return txt;
 623 }
 624
 625
 626 void menu_draw_box(mp_image_t* mpi,unsigned char grey,unsigned char alpha, int x, int y, int w, int h) {
 627   draw_alpha_f draw_alpha = get_draw_alpha(mpi->imgfmt);
 628   int g;
 629
 630   if(!draw_alpha) {
 631     mp_msg(MSGT_GLOBAL,MSGL_WARN,MSGTR_LIBMENU_UnsupportedOutformat);
 632     return;
 633   }
 634
 635   if(x > mpi->w || y > mpi->h) return;
 636
 637   if(x < 0) w += x, x = 0;
 638   if(x+w > mpi->w) w = mpi->w-x;
 639   if(y < 0) h += y, y = 0;
 640   if(y+h > mpi->h) h = mpi->h-y;
 641
 642   g = ((256-alpha)*grey)>>8;
 643   if(g < 1) g = 1;
 644
 645   {
 646     int stride = (w+7)&(~7); // round to 8
 647     char pic[stride*h],pic_alpha[stride*h];
 648     memset(pic,g,stride*h);
 649     memset(pic_alpha,alpha,stride*h);
 650     draw_alpha(w,h,pic,pic_alpha,stride,
 651                mpi->planes[0] + y * mpi->stride[0] + x * (mpi->bpp>>3),
 652                mpi->stride[0]);
 653   }
 654
 655 }