home *** CD-ROM | disk | FTP | other *** search
/ Spidla DivX / DivX.bin / LocoCodec / lococodec.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2003-04-27  |  44.0 KB  |  1,198 lines
  1. //
  2. // lococodec v0.1 based on:
  3. //
  4. // Huffyuv v2.1.1, by Ben Rudiak-Gould.
  5. // http://www.math.berkeley.edu/~benrg/huffyuv.html
  6. //
  7. // Based on MSYUV sample code, which is:
  8. // Copyright (c) 1993 Microsoft Corporation.
  9. // All Rights Reserved.
  10. //
  11. // Changes copyright 2000 Ben Rudiak-Gould, and distributed under
  12. // the terms of the GNU General Public License, v2 or later.  See
  13. // http://www.gnu.org/copyleft/gpl.html.
  14. //
  15. // I edit these files in 10-point Verdana, a proportionally-spaced font.
  16. // You may notice formatting oddities if you use a monospaced font.
  17. //
  18.  
  19.  
  20. extern "C" {
  21. #include "loco.h"
  22. }
  23.  
  24. #include "lococodec.h"
  25. #include "lococodec_a.h"
  26. #include "resource.h"
  27.  
  28. #include <crtdbg.h>
  29.  
  30. #include <stdio.h>
  31.  
  32. #include <commctrl.h>
  33.  
  34. TCHAR szDescription[] = TEXT("LOCO Codec Version 0.2"); // Moh
  35. TCHAR szName[]        = TEXT("lococodec");
  36.  
  37. #define VERSION         0x00000002      // 0.2; version number changes when file format changes
  38.  
  39.  
  40. /********************************************************************
  41. ********************************************************************/
  42.  
  43. // these tables are generated at runtime from the data in tables.cpp
  44.  
  45.  
  46. CodecInst *encode_table_owner, *decode_table_owner;
  47.  
  48. /********************************************************************
  49. ********************************************************************/
  50.  
  51. void Msg(const char fmt[], ...) {
  52.   static int debug = GetPrivateProfileInt("debug", "log", 0, INI_FILE);
  53.   if (!debug) return;
  54.  
  55.   DWORD written;
  56.   char buf[2000];
  57.   va_list val;
  58.   
  59.   va_start(val, fmt);
  60.   wvsprintf(buf, fmt, val);
  61.  
  62.   const COORD _80x50 = {80,5000};
  63.   static BOOL startup = (AllocConsole(), SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), _80x50));
  64.   WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), buf, lstrlen(buf), &written, 0);
  65. }
  66.  
  67.  
  68. int AppFlags() {
  69.   static int flags = -1;
  70.   if (flags < 0) {
  71.     flags = 0;
  72.     TCHAR apppath[MAX_PATH];
  73.     if (GetModuleFileName(NULL, apppath, MAX_PATH)) {
  74.       TCHAR* appname = strrchr(apppath, '\\');
  75.       appname = appname ? appname+1 : apppath;
  76.       Msg("App name is %s; ", appname);
  77.       if (!lstrcmpi(appname, TEXT("premiere.exe")))
  78.         flags = 1;
  79.       if (!lstrcmpi(appname, TEXT("veditor.exe")))
  80.         flags = 1;
  81.       if (!lstrcmpi(appname, TEXT("avi2mpg2_vfw.exe")))
  82.         flags = 1;
  83.       if (!lstrcmpi(appname, TEXT("bink.exe")))
  84.         flags = 1;
  85.       if (!lstrcmpi(appname, TEXT("afterfx.exe")))
  86.         flags = 2;
  87.       // new flag for ccesp/ccesp trial for buggy YUY2 handling - bastel
  88.       if (!lstrcmpi(appname, TEXT("cctsp.exe")) || !lstrcmpi(appname, TEXT("cctspt.exe")))
  89.         flags = 4;
  90.       Msg("flags=%d\n", flags);
  91.     }
  92.   }
  93.   return flags;
  94. }
  95.  
  96. bool SuggestRGB() {
  97.   return !!GetPrivateProfileInt("debug", "rgboutput", AppFlags()&1, INI_FILE);
  98. }
  99.  
  100. bool AllowRGBA() {
  101.   return !!GetPrivateProfileInt("general", "enable_rgba", AppFlags()&2, INI_FILE);
  102. }
  103.  
  104. // ignore top-down (i.e. negative height) - bastel
  105. bool IgnoreTopDown() {
  106.   return !!GetPrivateProfileInt("debug", "ignore_topdown", AppFlags()&4, INI_FILE);
  107. }
  108.  
  109.  
  110. /********************************************************************
  111. ********************************************************************/
  112.  
  113. CodecInst* Open(ICOPEN* icinfo) {
  114.   if (icinfo && icinfo->fccType != ICTYPE_VIDEO)
  115.       return NULL;
  116.  
  117.   CodecInst* pinst = new CodecInst();
  118.  
  119.   if (icinfo) icinfo->dwError = pinst ? ICERR_OK : ICERR_MEMORY;
  120.   
  121.   return pinst;
  122. }
  123.  
  124. DWORD Close(CodecInst* pinst) {
  125. //    delete pinst;       // this caused problems when deleting at app close time
  126.     return 1;
  127. }
  128.  
  129. /********************************************************************
  130. ********************************************************************/
  131.  
  132. enum {
  133.   methodAsRGB=0, 
  134.   methodConvertToYUY2=-1
  135. };
  136.  
  137. static inline int GetLocoOutputType(LPBITMAPINFOHEADER lpbi) {
  138.   if (lpbi->biCompression == FOURCC_LOCO && lpbi->biSize > sizeof(BITMAPINFOHEADER)+sizeof(int)*1) {
  139.     int output_type = *((int*)((char*)lpbi + sizeof(BITMAPINFOHEADER) + sizeof(int)*1));
  140.     if (output_type)
  141.       return output_type;
  142.   }
  143.   return 0;
  144. }
  145.  
  146. static inline int GetBitCount(LPBITMAPINFOHEADER lpbi) {
  147.   return lpbi->biBitCount;
  148. }
  149.  
  150. struct MethodName { int method; const char* name; };
  151.  
  152. MethodName rgb_method_names[] = {
  153.   { methodAsRGB, "As RGB (not recommended)" },
  154.   { methodConvertToYUY2, "Convert to YUY2" }
  155. };
  156.  
  157. MethodName max_losses[] = {
  158.     { 0, "0" },
  159.     { 1, "1" },
  160.     { 2, "2" },
  161.     { 3, "3" },
  162.     { 4, "4" },
  163.     { 5, "5" }
  164. };
  165.  
  166. struct { UINT item; UINT tip; } item2tip[] = {
  167.     { IDC_RGBMETHOD,        IDS_TIP_METHOD_RGB        },
  168.     { IDC_IS_INTERLACED,    IDS_TIP_SOURCE_IS_INTERLACED    },
  169.     { IDC_RGBOUTPUT,        IDS_TIP_RGB_ONLY        },
  170.     { IDC_RGBA,                IDS_TIP_RGBA_COMPR        },
  171.     { IDC_SWAPFIELDS,        IDS_TIP_SWAPFIELDS        },
  172.     { IDC_LOG,                IDS_TIP_LOG                },
  173.     { IDC_FULL_SIZE_BUFFER,    IDS_TIP_FULL_SIZE_BUFFER},
  174.     { IDC_MAX_LOSS,    IDS_TIP_MAX_LOSS},
  175.     { 0,0 }
  176. };
  177.  
  178.  
  179.  
  180. /********************************************************************
  181. ********************************************************************/
  182.  
  183. BOOL CodecInst::QueryAbout() { return TRUE; }
  184.  
  185. BOOL CodecInst::QueryConfigure() { return TRUE; }
  186.  
  187. static BOOL CALLBACK AboutDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  188.   if (uMsg == WM_COMMAND) {
  189.     switch (LOWORD(wParam)) {
  190.     case IDOK:
  191.       EndDialog(hwndDlg, 0);
  192.       break;
  193.     case IDC_HOMEPAGE:
  194.       ShellExecute(NULL, NULL, "http://www.math.berkeley.edu/~benrg/huffyuv.html", NULL, NULL, SW_SHOW);
  195.       break;
  196.     case IDC_EMAIL:
  197.       ShellExecute(NULL, NULL, "mailto:mrezaei@sourceforge.net", NULL, NULL, SW_SHOW);
  198.       break;
  199.     }
  200.   }
  201.   return FALSE;
  202. }
  203.  
  204.  
  205. // add a tooltip to a tooltip control, might be buggy, though - bastel
  206. int AddTooltip(HWND tooltip, HWND client, UINT stringid)
  207. {
  208.     HINSTANCE ghThisInstance=(HINSTANCE)GetWindowLong(client, GWL_HINSTANCE);
  209.  
  210.     TOOLINFO                ti;            // struct specifying info about tool in tooltip control
  211.     static unsigned int        uid    = 0;    // for ti initialization
  212.     RECT                    rect;        // for client area coordinates
  213.     TCHAR                    buf[2000];    // a static buffer is sufficent, TTM_ADDTOOL seems to copy it
  214.  
  215.     // load the string manually, passing the id directly to TTM_ADDTOOL truncates the message :(
  216.     if ( !LoadString(ghThisInstance, stringid, buf, 2000) ) return -1;
  217.  
  218.     // get coordinates of the main client area
  219.     GetClientRect(client, &rect);
  220.     
  221.     // initialize members of the toolinfo structure
  222.     ti.cbSize        = sizeof(TOOLINFO);
  223.     ti.uFlags        = TTF_SUBCLASS;
  224.     ti.hwnd            = client;
  225.     ti.hinst        = ghThisInstance;        // not necessary if lpszText is not a resource id
  226.     ti.uId            = uid;
  227.     ti.lpszText        = buf;
  228.  
  229.     // Tooltip control will cover the whole window
  230.     ti.rect.left    = rect.left;    
  231.     ti.rect.top        = rect.top;
  232.     ti.rect.right    = rect.right;
  233.     ti.rect.bottom    = rect.bottom;
  234.     
  235.     // send a addtool message to the tooltip control window
  236.     SendMessage(tooltip, TTM_ADDTOOL, 0, (LPARAM) (LPTOOLINFO) &ti);    
  237.     return uid++;
  238. } 
  239.  
  240. // create a tooltip control over the entire window area - bastel
  241. HWND CreateTooltip(HWND hwnd)
  242. {
  243.     // initialize common controls
  244.     INITCOMMONCONTROLSEX    iccex;        // struct specifying control classes to register
  245.     iccex.dwICC        = ICC_WIN95_CLASSES;
  246.     iccex.dwSize    = sizeof(INITCOMMONCONTROLSEX);
  247.     InitCommonControlsEx(&iccex);
  248.  
  249.  
  250.     HINSTANCE    ghThisInstance=(HINSTANCE)GetWindowLong(hwnd, GWL_HINSTANCE);
  251.     HWND        hwndTT;                    // handle to the tooltip control
  252.  
  253.     // create a tooltip window
  254.     hwndTT = CreateWindowEx(WS_EX_TOPMOST, TOOLTIPS_CLASS, NULL, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,
  255.                             CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  256.                             hwnd, NULL, ghThisInstance, NULL);
  257.     
  258.     SetWindowPos(hwndTT, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
  259.  
  260.     // set some timeouts so tooltips appear fast and stay long (32767 seems to be a limit here)
  261.     SendMessage(hwndTT, TTM_SETDELAYTIME, (WPARAM)(DWORD)TTDT_INITIAL, (LPARAM)10);
  262.     SendMessage(hwndTT, TTM_SETDELAYTIME, (WPARAM)(DWORD)TTDT_AUTOPOP, (LPARAM)30*1000);
  263.  
  264.     return hwndTT;
  265. }
  266.  
  267.  
  268. static BOOL CALLBACK ConfigureDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  269.   if (uMsg == WM_INITDIALOG) {
  270.  
  271.  
  272.     HWND hctlRGBMethod = GetDlgItem(hwndDlg, IDC_RGBMETHOD);
  273.     int rgbmethod = GetPrivateProfileInt("general", "rgbmethod", methodConvertToYUY2, INI_FILE);
  274.     for (int j = 0; j < sizeof(rgb_method_names)/sizeof(rgb_method_names[0]); ++j) {
  275.       SendMessage(hctlRGBMethod, CB_ADDSTRING, 0, (LPARAM)rgb_method_names[j].name);
  276.       if (rgb_method_names[j].method == rgbmethod)
  277.         SendMessage(hctlRGBMethod, CB_SETCURSEL, j, 0);
  278.     }
  279.  
  280.     HWND    hctlMaxLoss    = GetDlgItem(hwndDlg, IDC_MAX_LOSS);
  281.     int        maxLoss            = GetPrivateProfileInt("general", "max_loss", 0, INI_FILE);
  282.     char    temp[12]            = {0};
  283.     bool    dupe                = false;
  284.   int k;
  285.  
  286.     _snprintf(temp, 11, "%d", maxLoss);
  287.     SendMessage(hctlMaxLoss, CB_LIMITTEXT, 11, 0);
  288.     for (k = 0; k < sizeof(max_losses)/sizeof(max_losses[0]); k++) {
  289.         SendMessage(hctlMaxLoss, CB_ADDSTRING, 0, (LPARAM)max_losses[k].name);
  290.         if ( max_losses[k].method==maxLoss ) dupe=true;
  291.     }
  292.     if ( !dupe) SendMessage(hctlMaxLoss, CB_ADDSTRING, 0, (LPARAM)temp);
  293.     SendMessage(hctlMaxLoss, CB_SETCURSEL, SendMessage(hctlMaxLoss, CB_FINDSTRINGEXACT, -1, (LPARAM)temp), 0);
  294.  
  295.  
  296.     CheckDlgButton(hwndDlg, IDC_IS_INTERLACED,
  297.       GetPrivateProfileInt("general", "source_interlaced", false, INI_FILE) ? BST_CHECKED : BST_UNCHECKED);
  298.     CheckDlgButton(hwndDlg, IDC_RGBOUTPUT,
  299.       GetPrivateProfileInt("debug", "rgboutput", false, INI_FILE) ? BST_CHECKED : BST_UNCHECKED);
  300.     CheckDlgButton(hwndDlg, IDC_RGBA,
  301.       GetPrivateProfileInt("general", "enable_rgba", false, INI_FILE) ? BST_CHECKED : BST_UNCHECKED);
  302.     CheckDlgButton(hwndDlg, IDC_SWAPFIELDS,
  303.       GetPrivateProfileInt("debug", "decomp_swap_fields", false, INI_FILE) ? BST_CHECKED : BST_UNCHECKED);
  304.     CheckDlgButton(hwndDlg, IDC_LOG,
  305.       GetPrivateProfileInt("debug", "log", false, INI_FILE) ? BST_CHECKED : BST_UNCHECKED);
  306.     CheckDlgButton(hwndDlg, IDC_FULL_SIZE_BUFFER,
  307.       GetPrivateProfileInt("debug", "full_size_buffer", FULL_SIZE_BUFFER, INI_FILE) ? BST_CHECKED : BST_UNCHECKED);
  308.  
  309.  
  310.     // create a tooltip window and add tooltips - bastel
  311.     HWND hwndTip = CreateTooltip(hwndDlg);
  312.     for (int l=0; item2tip[l].item; l++ )
  313.         AddTooltip(hwndTip, GetDlgItem(hwndDlg, item2tip[l].item),    item2tip[l].tip);
  314.     SendMessage(hwndTip, TTM_SETMAXTIPWIDTH, 0, (LPARAM)(INT)350);    // ah well this is totally wrong but works
  315.   }
  316.  
  317.   else if (uMsg == WM_COMMAND) {
  318.  
  319.     switch (LOWORD(wParam)) {
  320.  
  321.     case IDOK:
  322.       {
  323.         char methodstring[4];
  324.         wsprintf(methodstring, "%d",
  325.           rgb_method_names[SendMessage(GetDlgItem(hwndDlg, IDC_RGBMETHOD), CB_GETCURSEL, 0, 0)].method);
  326.         WritePrivateProfileString("general", "rgbmethod", methodstring, INI_FILE);
  327.       }
  328.       WritePrivateProfileString("general", "source_interlaced",
  329.         (IsDlgButtonChecked(hwndDlg, IDC_IS_INTERLACED) == BST_CHECKED) ? "1" : "0", INI_FILE);
  330.       WritePrivateProfileString("debug", "rgboutput",
  331.         (IsDlgButtonChecked(hwndDlg, IDC_RGBOUTPUT) == BST_CHECKED) ? "1" : NULL, INI_FILE);
  332.       WritePrivateProfileString("general", "enable_rgba",
  333.         (IsDlgButtonChecked(hwndDlg, IDC_RGBA) == BST_CHECKED) ? "1" : NULL, INI_FILE);
  334.       WritePrivateProfileString("debug", "decomp_swap_fields",
  335.         (IsDlgButtonChecked(hwndDlg, IDC_SWAPFIELDS) == BST_CHECKED) ? "1" : "0", INI_FILE);
  336.       WritePrivateProfileString("debug", "log",
  337.         (IsDlgButtonChecked(hwndDlg, IDC_LOG) == BST_CHECKED) ? "1" : "0", INI_FILE);
  338.       WritePrivateProfileString("debug", "full_size_buffer",
  339.         (IsDlgButtonChecked(hwndDlg, IDC_FULL_SIZE_BUFFER) == BST_CHECKED) ? "1" : "0", INI_FILE);
  340.  
  341.         
  342.       // write max loss setting. accept only if numeric and 0 < ft <= 100
  343.         {
  344.             char    temp[12]= {0};
  345.             char*    endp    = 0;
  346.             SendMessage(GetDlgItem(hwndDlg, IDC_MAX_LOSS), WM_GETTEXT, 11, (LPARAM)temp);
  347.             int max_loss    = strtoul(temp, &endp, 10);
  348.             if ( strchr(" \t\r\n", *endp) && max_loss>=0 && max_loss<=100 ) {
  349.                 // could pass old temp, but this way whitespace is removed
  350.                 _snprintf(temp, 11, "%d", max_loss);        
  351.                 WritePrivateProfileString("general", "max_loss", temp, INI_FILE);
  352.             }
  353.       }
  354.  
  355.     case IDCANCEL:
  356.       EndDialog(hwndDlg, 0);
  357.       break;
  358.  
  359.     default:
  360.       return AboutDialogProc(hwndDlg, uMsg, wParam, lParam);    // handle email and home-page buttons
  361.     }
  362.   }
  363.   return FALSE;
  364. }
  365.  
  366. DWORD CodecInst::About(HWND hwnd) {
  367.   DialogBox(hmoduleLocoCodec, MAKEINTRESOURCE(IDD_ABOUT), hwnd, AboutDialogProc);
  368.   return ICERR_OK;
  369. }
  370.  
  371. DWORD CodecInst::Configure(HWND hwnd) {
  372.   DialogBox(hmoduleLocoCodec, MAKEINTRESOURCE(IDD_CONFIGURE), hwnd, ConfigureDialogProc);
  373.   return ICERR_OK;
  374. }
  375.  
  376.  
  377.  
  378. /********************************************************************
  379. ********************************************************************/
  380.  
  381.  
  382. // we have no state information which needs to be stored
  383.  
  384. DWORD CodecInst::GetState(LPVOID pv, DWORD dwSize) { return 0; }
  385.  
  386. DWORD CodecInst::SetState(LPVOID pv, DWORD dwSize) { return 0; }
  387.  
  388.  
  389. DWORD CodecInst::GetInfo(ICINFO* icinfo, DWORD dwSize) {
  390.   if (icinfo == NULL)
  391.     return sizeof(ICINFO);
  392.  
  393.   if (dwSize < sizeof(ICINFO))
  394.     return 0;
  395.  
  396.   icinfo->dwSize            = sizeof(ICINFO);
  397.   icinfo->fccType           = ICTYPE_VIDEO;
  398.   icinfo->fccHandler        = FOURCC_LOCO;
  399.   icinfo->dwFlags           = 0;
  400.  
  401.   icinfo->dwVersion         = VERSION;
  402.   icinfo->dwVersionICM      = ICVERSION;
  403.   MultiByteToWideChar(CP_ACP, 0, szDescription, -1, icinfo->szDescription, sizeof(icinfo->szDescription)/sizeof(WCHAR));
  404.   MultiByteToWideChar(CP_ACP, 0, szName, -1, icinfo->szName, sizeof(icinfo->szName)/sizeof(WCHAR));
  405.  
  406.   return sizeof(ICINFO);
  407. }
  408.  
  409.  
  410. /********************************************************************
  411. ********************************************************************/
  412.  
  413.  
  414. struct PrintBitmapType {
  415.   char s[32];
  416.   PrintBitmapType(LPBITMAPINFOHEADER lpbi) {
  417.     if (!lpbi)
  418.       strcpy(s,  "(null)");
  419.     else {
  420.       *(DWORD*)s = lpbi->biCompression;
  421.       s[4] = 0;
  422.       if (!isalnum(s[0]) || !isalnum(s[1]) || !isalnum(s[2]) || !isalnum(s[3]))
  423.         wsprintfA(s, "%x", lpbi->biCompression);
  424.       wsprintfA(strchr(s, 0), ", %d bits", GetBitCount(lpbi));
  425.       if (lpbi->biCompression == FOURCC_LOCO && GetLocoOutputType(lpbi))
  426.         wsprintfA(strchr(s, 0), ", output_type %d", GetLocoOutputType(lpbi));
  427.     }
  428.   }
  429. };
  430.  
  431.  
  432. // fast clipping of values to unsigned char range
  433.  
  434. static unsigned char clip[896];
  435.  
  436. static void InitClip() {
  437.   memset(clip, 0, 320);
  438.   for (int i=0; i<256; ++i) clip[i+320] = i;
  439.   memset(clip+320+256, 255, 320);
  440. }
  441.  
  442. static inline unsigned char Clip(int x)
  443.   { return clip[320 + ((x+0x8000) >> 16)]; }
  444.  
  445.  
  446. /********************************************************************
  447. ********************************************************************/
  448.  
  449.  
  450.  
  451. // 0=unknown, -1=compressed YUY2, -2=compressed RGB, -3=compressed RGBA, 1=YUY2, 2=UYVY, 3=RGB 24-bit, 4=RGB 32-bit
  452. static int GetBitmapType(LPBITMAPINFOHEADER lpbi) {
  453.   if (!lpbi)
  454.     return BITMAP_TYPE_UNKNOWN;
  455.   const int fourcc = lpbi->biCompression;
  456.   if (fourcc == FOURCC_VYUY || fourcc == FOURCC_YUY2)
  457.     return BITMAP_TYPE_YUY2;
  458.   if (fourcc == FOURCC_UYVY)
  459.     return BITMAP_TYPE_UYVY;
  460.   if (fourcc == FOURCC_YV12)
  461.     return BITMAP_TYPE_YV12;
  462.   const int bitcount = GetBitCount(lpbi);
  463.   if (fourcc == 0 || fourcc == ' BID')
  464.     return (bitcount == 24) ? BITMAP_TYPE_RGB : (bitcount == 32) ? BITMAP_TYPE_RGBA : 0;
  465.   if (fourcc == FOURCC_LOCO)
  466.   {
  467.       return GetLocoOutputType(lpbi);
  468.   }
  469.   return 0;
  470. }
  471.  
  472.  
  473. static bool CanCompress(LPBITMAPINFOHEADER lpbiIn) {
  474.   int intype = GetBitmapType(lpbiIn);
  475.   return (intype == BITMAP_TYPE_YUY2 || intype == BITMAP_TYPE_UYVY 
  476.       || intype == BITMAP_TYPE_RGB || intype == BITMAP_TYPE_YV12 || (intype == BITMAP_TYPE_RGBA && AllowRGBA()));
  477. }
  478.  
  479.  
  480. static bool CanCompress(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  481.   if (!lpbiOut) return CanCompress(lpbiIn);
  482.  
  483.   int intype = GetBitmapType(lpbiIn);
  484.   int outtype = GetBitmapType(lpbiOut);
  485.  
  486.   switch (intype) {
  487.     case BITMAP_TYPE_YUY2: case BITMAP_TYPE_UYVY:
  488.       return (outtype == BITMAP_TYPE_COMPRESSED_YUY2);
  489.     case BITMAP_TYPE_RGB:
  490.       return (outtype == BITMAP_TYPE_YUY2 || outtype == BITMAP_TYPE_COMPRESSED_YUY2 
  491.           || outtype == BITMAP_TYPE_COMPRESSED_RGB);
  492.     case BITMAP_TYPE_RGBA:
  493.       return (outtype == BITMAP_TYPE_COMPRESSED_RGBA && AllowRGBA());
  494.     case BITMAP_TYPE_YV12:
  495.       return (outtype == BITMAP_TYPE_COMPRESSED_YV12);
  496.     default:
  497.       return false;
  498.   }
  499. }
  500.  
  501.  
  502. /********************************************************************
  503. ********************************************************************/
  504.  
  505.  
  506.  
  507. #define HUFFTABLE_CLASSIC_YUV ((const unsigned char*)-1)
  508. #define HUFFTABLE_CLASSIC_RGB ((const unsigned char*)-2)
  509. #define HUFFTABLE_CLASSIC_YUV_CHROMA ((const unsigned char*)-3)
  510.  
  511.  
  512.  
  513. DWORD CodecInst::CompressQuery(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  514.   Msg("CompressQuery: input = %s, output = %s\n", &PrintBitmapType(lpbiIn), &PrintBitmapType(lpbiOut));
  515.   return CanCompress(lpbiIn, lpbiOut) ? ICERR_OK : ICERR_BADFORMAT;
  516. }
  517.  
  518. #define EXTRA_INFO_SIZE        sizeof(int)*4
  519. #define EXTRA_INFO_VERSION    2
  520.  
  521. DWORD CodecInst::CompressGetFormat(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  522.   if (!CanCompress(lpbiIn))
  523.     return ICERR_BADFORMAT;
  524.  
  525.   int intype = GetBitmapType(lpbiIn);
  526.  
  527.   bool compress_as_yuy2 = (intype == BITMAP_TYPE_YUY2 || intype == BITMAP_TYPE_UYVY);
  528.   int output_type = 0;
  529.   if (!compress_as_yuy2 && (intype == BITMAP_TYPE_RGB || intype == BITMAP_TYPE_RGBA)) {
  530.     int method = GetPrivateProfileInt("general", "rgbmethod", methodConvertToYUY2, INI_FILE);
  531.     if (method==methodConvertToYUY2)
  532.       {
  533.         compress_as_yuy2 = true;
  534.       }
  535.       else
  536.       {
  537.           if (intype == BITMAP_TYPE_RGB) output_type = BITMAP_TYPE_COMPRESSED_RGB;
  538.           if (intype == BITMAP_TYPE_RGBA) output_type = BITMAP_TYPE_COMPRESSED_RGBA;
  539.       }
  540.   }
  541.  
  542.   if (compress_as_yuy2)
  543.       output_type = BITMAP_TYPE_COMPRESSED_YUY2;
  544.   if (intype == BITMAP_TYPE_YV12) output_type = BITMAP_TYPE_COMPRESSED_YV12;
  545.  
  546.   int total_size = sizeof(BITMAPINFOHEADER)+EXTRA_INFO_SIZE;
  547.   if (!lpbiOut)
  548.     return total_size;
  549.  
  550.   int real_bit_count = (intype==BITMAP_TYPE_RGBA) ? 32 : (compress_as_yuy2 || intype == BITMAP_TYPE_YV12) ? 16 : 24;
  551.   max_loss = GetPrivateProfileInt("general", "max_loss", 0, INI_FILE);
  552.   source_interlaced = GetPrivateProfileInt("general", "source_interlaced", 0, INI_FILE) == 1 ? true : false;
  553.  
  554.   *lpbiOut = *lpbiIn;
  555.   lpbiOut->biSize = total_size;
  556.   lpbiOut->biCompression = FOURCC_LOCO;
  557.   lpbiOut->biClrImportant = lpbiOut->biClrUsed = 0;
  558.   lpbiOut->biPlanes = 1;
  559.   lpbiOut->biBitCount = max(24, real_bit_count);
  560.   int* extra_data = (int*)((unsigned char*)lpbiOut + sizeof(BITMAPINFOHEADER));
  561.   extra_data[0] = EXTRA_INFO_VERSION;
  562.   extra_data[1] = output_type;
  563.   extra_data[2] = max_loss;
  564.   extra_data[3] = source_interlaced ? 1 : 0;
  565.   return ICERR_OK;
  566. }
  567.  
  568.  
  569. const unsigned char* GetEmbeddedHuffmanTable(LPBITMAPINFOHEADER lpbi) {
  570.   if (lpbi->biSize == sizeof(BITMAPINFOHEADER) && !(lpbi->biBitCount&7))
  571.     return lpbi->biBitCount>=24 ? HUFFTABLE_CLASSIC_RGB : HUFFTABLE_CLASSIC_YUV;
  572.   else
  573.     return (const unsigned char*)lpbi + sizeof(BITMAPINFOHEADER) + ((lpbi->biBitCount&7) ? 0 : 4);
  574. }
  575.  
  576.  
  577. DWORD CodecInst::CompressBegin(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  578.   Msg("CompressBegin: input = %s, output = %s\n", &PrintBitmapType(lpbiIn), &PrintBitmapType(lpbiOut));
  579.  
  580.   if (!CanCompress(lpbiIn, lpbiOut))
  581.     return ICERR_BADFORMAT;
  582.  
  583.   CompressEnd();  // free resources if necessary
  584.  
  585.   int intype = GetBitmapType(lpbiIn);
  586.   int outtype = GetLocoOutputType(lpbiOut);
  587.  
  588.   // load field threshold - bastel
  589.   source_interlaced = GetPrivateProfileInt("general", "source_interlaced", 0, INI_FILE) == 1 ? true : false;
  590.   max_loss = GetPrivateProfileInt("general", "max_loss", 0, INI_FILE);
  591.   Msg("CompressBegin: source interlaced  %s\n",
  592.       source_interlaced ? "yes" : "no");
  593.  
  594.   // allocate buffer if compressing RGB->YUY2->HFYU
  595.   if (outtype == BITMAP_TYPE_COMPRESSED_YUY2 && intype == BITMAP_TYPE_RGB)
  596.     yuy2_buffer = new unsigned char[lpbiIn->biWidth * lpbiIn->biHeight * 2 + 4];
  597.  
  598.   InitClip();
  599.  
  600.   return ICERR_OK;
  601. }
  602.  
  603. DWORD CodecInst::CompressGetSize(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  604.   // Assume 24 bpp worst-case for YUY2 input, 40 bpp for RGB.
  605.   // The actual worst case is 43/51 bpp currently, but this is exceedingly improbable
  606.   // (probably impossible with real captured video)
  607.   // bastel: never say impossible. try to capture static noise with the original huffyuv and be surprised.
  608.   //         virtualdub has a workaround for it. avi_io not. anyway, i don't think it slows down processing.
  609.   //         if you think it does you can still enable the old behaviour. full buffer costs memory, though :)
  610.   int fullsize = GetPrivateProfileInt("debug", "full_size_buffer", FULL_SIZE_BUFFER, INI_FILE);
  611.   return fullsize    ? ((lpbiIn->biWidth * lpbiIn->biHeight * ((GetBitmapType(lpbiIn) <= 2) ? 43 : 51)) + 7) / 8
  612.                     :    lpbiIn->biWidth * lpbiIn->biHeight * ((GetBitmapType(lpbiIn) <= 2) ? 3 : 5);
  613. }
  614.  
  615.  
  616. template<typename T> static inline T* Align8(T* ptr) { return (T*)((unsigned(ptr)+7)&~7); }
  617.  
  618.  
  619. DWORD CodecInst::Compress(ICCOMPRESS* icinfo, DWORD dwSize) {
  620.  
  621.   if (icinfo->lpckid)
  622.     *icinfo->lpckid = FOURCC_LOCO;
  623.   *icinfo->lpdwFlags = AVIIF_KEYFRAME;
  624.  
  625.   int intype = GetBitmapType(icinfo->lpbiInput);
  626.   int outtype = GetLocoOutputType(icinfo->lpbiOutput);
  627.  
  628.   if (outtype < 0) {    // compressing (as opposed to converting RGB->YUY2)
  629.  
  630.  
  631.     unsigned char* in = (unsigned char*)icinfo->lpInput;
  632.     unsigned long* out = (unsigned long*)icinfo->lpOutput;
  633.  
  634.     unsigned long* out_end = out;
  635.  
  636.     if (outtype == BITMAP_TYPE_COMPRESSED_YUY2) {    // compressing to LOCOYUY2 (4:2:2 YUV)
  637.       int rowsize = icinfo->lpbiInput->biWidth * 2;
  638.       int yStep = 1;
  639. #ifdef LATER
  640.       if (icinfo->lpbiInput->biHeight > field_threshold) yStep = 2;    // if image is interlaced, double stride so fields are treated separately
  641. #endif
  642.       unsigned char* yuy2in = in;
  643.  
  644.       if (intype == BITMAP_TYPE_RGB) {    // RGB24->YUY2->LOCOYUY2
  645.         ConvertRGB24toYUY2(in, yuy2_buffer, icinfo->lpbiInput->biWidth, icinfo->lpbiInput->biHeight);
  646.         yuy2in = yuy2_buffer;
  647.       }
  648.       if (intype==BITMAP_TYPE_UYVY) {    // UYVY->LOCOYUY2
  649.           
  650.         // first Y
  651.         out_end = (unsigned long *)loco_codec_compress_lossy(yuy2in, (unsigned char *)out_end, icinfo->lpbiInput->biHeight, rowsize,
  652.               1, 2, 0, yStep, max_loss);
  653.         // then U:
  654.         out_end = (unsigned long *)loco_codec_compress_lossy(yuy2in, (unsigned char *)out_end, icinfo->lpbiInput->biHeight, rowsize,
  655.               0, 4, 0, yStep, max_loss);
  656.         // then V:
  657.         out_end = (unsigned long *)loco_codec_compress_lossy(yuy2in, (unsigned char *)out_end, icinfo->lpbiInput->biHeight, rowsize,
  658.               2, 4, 0, yStep, max_loss);
  659.         
  660.       } else {    // YUY2->HFYU16
  661.         // first Y
  662.         out_end = (unsigned long *)loco_codec_compress_lossy(yuy2in, (unsigned char *)out_end, icinfo->lpbiInput->biHeight, rowsize,
  663.               0, 2, 0, yStep, max_loss);
  664.         // then U:
  665.         out_end = (unsigned long *)loco_codec_compress_lossy(yuy2in, (unsigned char *)out_end, icinfo->lpbiInput->biHeight, rowsize,
  666.               1, 4, 0, yStep, max_loss);
  667.         // then V:
  668.         out_end = (unsigned long *)loco_codec_compress_lossy(yuy2in, (unsigned char *)out_end, icinfo->lpbiInput->biHeight, rowsize,
  669.               3, 4, 0, yStep, max_loss);
  670.         
  671.       }
  672.     }
  673.     else if (outtype == BITMAP_TYPE_COMPRESSED_YV12)    // compressing to LOCO YV12
  674.       {
  675.       int rowsize = icinfo->lpbiInput->biWidth;
  676.       int yStep = 1;
  677.       unsigned long* out_temp;
  678.       // Y:
  679.         out_end = (unsigned long *)loco_codec_compress(in, (unsigned char *)out_end, 
  680.         icinfo->lpbiInput->biHeight, rowsize, 0, 1, 0, yStep);
  681.       out_temp = out_end;
  682.       rowsize = icinfo->lpbiInput->biWidth >> 1;
  683.       // V:
  684.       in += icinfo->lpbiInput->biHeight*icinfo->lpbiInput->biWidth; 
  685.       out_end = (unsigned long *)loco_codec_compress(in,
  686.         (unsigned char *)out_end, icinfo->lpbiInput->biHeight >> 1, rowsize, 0, 1, 0, yStep);
  687.       // U:
  688.       in += (icinfo->lpbiInput->biHeight*icinfo->lpbiInput->biWidth) >> 2; 
  689.       out_end = (unsigned long *)loco_codec_compress(in,
  690.         (unsigned char *)out_end, icinfo->lpbiInput->biHeight >> 1, rowsize, 0, 1, 0, yStep);
  691.     }
  692.     else if (outtype == BITMAP_TYPE_COMPRESSED_RGB) {    // compressing to LOCO RGB24
  693.       int xStep = 3;
  694.       int rowsize = icinfo->lpbiInput->biWidth * xStep;
  695.       int size = rowsize * icinfo->lpbiInput->biHeight;
  696.       int yStep = 1;
  697. #ifdef LATER
  698.       if (icinfo->lpbiInput->biHeight > field_threshold) stride *= 2;    // if image is interlaced, double stride so fields are treated separately
  699. #endif
  700.  
  701.       out_end = (unsigned long *)loco_codec_compress_lossy(in, (unsigned char *)out_end, 
  702.         icinfo->lpbiInput->biHeight, rowsize, 0, xStep, 0, yStep, max_loss);
  703.  
  704.       out_end = (unsigned long *)loco_codec_compress_lossy(in, (unsigned char *)out_end, 
  705.         icinfo->lpbiInput->biHeight, rowsize, 1, xStep, 0, yStep, max_loss);
  706.  
  707.       out_end = (unsigned long *)loco_codec_compress_lossy(in, (unsigned char *)out_end, 
  708.         icinfo->lpbiInput->biHeight, rowsize, 2, xStep, 0, yStep, max_loss);
  709.  
  710.  
  711.     }
  712.     else if (outtype == BITMAP_TYPE_COMPRESSED_RGBA) {    // compressing to LOCO RGBA
  713.       int xStep = 4;
  714.       int rowsize = icinfo->lpbiInput->biWidth * xStep;
  715.       int size = rowsize * icinfo->lpbiInput->biHeight;
  716.       int yStep = 1;
  717. #ifdef LATER
  718.       if (icinfo->lpbiInput->biHeight > field_threshold) stride *= 2;    // if image is interlaced, double stride so fields are treated separately
  719. #endif
  720.       out_end = (unsigned long *)loco_codec_compress_lossy(in, (unsigned char *)out_end, 
  721.         icinfo->lpbiInput->biHeight, rowsize, 0, xStep, 0, yStep, max_loss);
  722.  
  723.       out_end = (unsigned long *)loco_codec_compress_lossy(in, (unsigned char *)out_end, 
  724.         icinfo->lpbiInput->biHeight, rowsize, 1, xStep, 0, yStep, max_loss);
  725.  
  726.       out_end = (unsigned long *)loco_codec_compress_lossy(in, (unsigned char *)out_end, 
  727.         icinfo->lpbiInput->biHeight, rowsize, 2, xStep, 0, yStep, max_loss);
  728.  
  729.       out_end = (unsigned long *)loco_codec_compress_lossy(in, (unsigned char *)out_end, 
  730.         icinfo->lpbiInput->biHeight, rowsize, 3, xStep, 0, yStep, max_loss);
  731.     }
  732.     icinfo->lpbiOutput->biSizeImage = DWORD(out_end) - DWORD(out);
  733.     return ICERR_OK;
  734.   }
  735.   else if (outtype == 1) {    // RGB24->YUY2
  736.     ConvertRGB24toYUY2((unsigned char*)icinfo->lpInput, (unsigned char*)icinfo->lpOutput,
  737.       icinfo->lpbiInput->biWidth, icinfo->lpbiInput->biHeight);
  738.     icinfo->lpbiOutput->biSizeImage = (icinfo->lpbiOutput->biWidth * icinfo->lpbiOutput->biHeight * GetBitCount(icinfo->lpbiOutput)) >> 3;
  739.     return ICERR_OK;
  740.   }
  741.   else
  742.     return ICERR_BADFORMAT;
  743. }
  744.  
  745.  
  746. void CodecInst::ConvertRGB24toYUY2(const unsigned char* src, unsigned char* dst, int width, int height) {
  747.   const int cyb = int(0.114*219/255*65536+0.5);
  748.   const int cyg = int(0.587*219/255*65536+0.5);
  749.   const int cyr = int(0.299*219/255*65536+0.5);
  750.  
  751.   for (int row = 0; row < height; ++row) {
  752.     const unsigned char* rgb = src + width * 3 * (height-1-row);
  753.     unsigned char* yuv = dst + width * 2 * row;
  754.     for (int col = 0; col < width; col += 2) {
  755.       // y1 and y2 can't overflow
  756.       int y1 = (cyb*rgb[0] + cyg*rgb[1] + cyr*rgb[2] + 0x108000) >> 16;
  757.       yuv[0] = y1;
  758.       int y2 = (cyb*rgb[3] + cyg*rgb[4] + cyr*rgb[5] + 0x108000) >> 16;
  759.       yuv[2] = y2;
  760.       int scaled_y = (y1+y2 - 32) * int(255.0/219.0*32768+0.5);
  761.       int b_y = ((rgb[0]+rgb[3]) << 15) - scaled_y;
  762.       yuv[1] = Clip((b_y >> 10) * int(1/2.018*1024+0.5) + 0x800000);  // u
  763.       int r_y = ((rgb[2]+rgb[5]) << 15) - scaled_y;
  764.       yuv[3] = Clip((r_y >> 10) * int(1/1.596*1024+0.5) + 0x800000);  // v
  765.       yuv += 4;
  766.       rgb += 6;
  767.     }
  768.   }
  769. }
  770.  
  771.  
  772. DWORD CodecInst::CompressEnd() {
  773.   if (yuy2_buffer) {
  774.     delete[] yuy2_buffer;
  775.     yuy2_buffer = 0;
  776.   }
  777.   if (median_buffer) {
  778.     delete[] median_buffer;
  779.     median_buffer = 0;
  780.   }
  781.   if (rgb_buffer) {
  782.     delete[] rgb_buffer;
  783.     rgb_buffer = 0;
  784.   }
  785.   return ICERR_OK;
  786. }
  787.  
  788.  
  789. /********************************************************************
  790. ********************************************************************/
  791.  
  792. static bool CanDecompress(LPBITMAPINFOHEADER lpbiIn) {
  793.   int intype = GetBitmapType(lpbiIn);
  794.   if (intype < 0) // one of our compressed formats
  795.     return true;
  796.   else
  797.     return (intype == BITMAP_TYPE_YUY2 || intype == BITMAP_TYPE_UYVY);
  798. }
  799.  
  800.  
  801. static bool CanDecompress(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  802.   if (!lpbiOut)
  803.     return CanDecompress(lpbiIn);
  804.  
  805.   // ccesp sets negative output height with YUY2 - a request for a top-down bitmap.
  806.   // but what it really wants is a bottom-up bitmap. this is fine with huffyuv, so we change it. - bastel
  807.   lpbiOut->biHeight = IgnoreTopDown() ? abs(lpbiOut->biHeight) : lpbiOut->biHeight;
  808.  
  809.   Msg("CanDecompress %d %d %d %d\n",lpbiOut->biWidth,lpbiIn->biWidth ,lpbiOut->biHeight,lpbiIn->biHeight);
  810.   // must be 1:1 (no stretching)
  811.   if (lpbiOut && (lpbiOut->biWidth != lpbiIn->biWidth || lpbiOut->biHeight != lpbiIn->biHeight))
  812.     return false;
  813.  
  814.   int intype = GetBitmapType(lpbiIn);
  815.   int outtype = GetBitmapType(lpbiOut);
  816.  
  817.   Msg("CanDecompress: input = %d, output = %d\n", intype,outtype);
  818.  
  819.   switch (intype) {
  820.     case BITMAP_TYPE_COMPRESSED_YUY2:
  821.       // YUY2, RGB-24, RGB-32 output for compressed YUY2
  822.       return (outtype == BITMAP_TYPE_YUY2 || outtype == BITMAP_TYPE_RGB);
  823.     case BITMAP_TYPE_COMPRESSED_RGB: case BITMAP_TYPE_YUY2: case BITMAP_TYPE_UYVY:
  824.       // RGB-24, RGB-32 output only for YUY2/UYVY and compressed RGB
  825.       return (outtype == BITMAP_TYPE_RGB);
  826.     case BITMAP_TYPE_COMPRESSED_RGBA:
  827.       // RGB-32 output for compressed RGBA
  828.       return (outtype == BITMAP_TYPE_RGBA);
  829.     case BITMAP_TYPE_COMPRESSED_YV12:
  830.       return (outtype == BITMAP_TYPE_YV12 || outtype == BITMAP_TYPE_YUY2
  831.         || outtype == BITMAP_TYPE_RGB );
  832.     default:
  833.       return false;
  834.   }
  835. }
  836.  
  837. /********************************************************************
  838. ********************************************************************/
  839.  
  840.  
  841. DWORD CodecInst::DecompressQuery(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  842.   Msg("DecompressQuery: input = %s, output = %s\n", &PrintBitmapType(lpbiIn), &PrintBitmapType(lpbiOut));
  843.   return CanDecompress(lpbiIn, lpbiOut) ? ICERR_OK : ICERR_BADFORMAT;
  844. }
  845.  
  846.  
  847. // This function should return "the output format which preserves the most
  848. // information."  However, I now provide the option to return RGB format
  849. // instead, since some programs treat the default format as the ONLY format.
  850.  
  851. DWORD CodecInst::DecompressGetFormat(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  852.  
  853.   Msg("DecompressGetFormat: input = %s, output = %s\n", &PrintBitmapType(lpbiIn), &PrintBitmapType(lpbiOut));
  854.   // if lpbiOut == NULL, then return the size required to hold an output format struct
  855.   if (lpbiOut == NULL)
  856.     return sizeof(BITMAPINFOHEADER);
  857.  
  858.   if (!CanDecompress(lpbiIn))
  859.     return ICERR_BADFORMAT;
  860.  
  861.   *lpbiOut = *lpbiIn;
  862.   lpbiOut->biSize = sizeof(BITMAPINFOHEADER);
  863.   lpbiOut->biPlanes = 1;
  864.  
  865.   int intype = GetBitmapType(lpbiIn);
  866.   if (intype == BITMAP_TYPE_COMPRESSED_RGBA) {
  867.     lpbiOut->biBitCount = 32;   // RGBA
  868.     lpbiOut->biCompression = 0;
  869.     lpbiOut->biSizeImage = lpbiIn->biWidth * lpbiIn->biHeight * 4;
  870.   } else if (intype == BITMAP_TYPE_COMPRESSED_RGB || intype == BITMAP_TYPE_YUY2 || 
  871.       intype == BITMAP_TYPE_UYVY || SuggestRGB()) {
  872.     lpbiOut->biBitCount = 24;   // RGB
  873.     lpbiOut->biCompression = 0;
  874.     lpbiOut->biSizeImage = lpbiIn->biWidth * lpbiIn->biHeight * 3;
  875.   } else if (intype == BITMAP_TYPE_COMPRESSED_YV12) {
  876.     lpbiOut->biBitCount = 12;       // YV12
  877.     lpbiOut->biCompression = FOURCC_YV12;
  878.     lpbiOut->biSizeImage = lpbiIn->biWidth * lpbiIn->biHeight * 3/2;
  879.   }
  880.   else  {
  881.     lpbiOut->biBitCount = 16;       // YUY2
  882.     lpbiOut->biCompression = FOURCC_YUY2;
  883.     lpbiOut->biSizeImage = lpbiIn->biWidth * lpbiIn->biHeight * 2;
  884.   }
  885.   Msg("DecompressGetFormat: input = %s, output = %s\n", &PrintBitmapType(lpbiIn), &PrintBitmapType(lpbiOut));
  886.  
  887.   return ICERR_OK;
  888. }
  889.  
  890.  
  891.  
  892.  
  893. DWORD CodecInst::DecompressBegin(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  894.   Msg("DecompressBegin: input = %s, output = %s\n", &PrintBitmapType(lpbiIn), &PrintBitmapType(lpbiOut));
  895.  
  896.   DecompressEnd();  // free resources if necessary
  897.  
  898.   if (!CanDecompress(lpbiIn, lpbiOut))
  899.     return ICERR_BADFORMAT;
  900.  
  901.   // ccesp keeps the in CanDecompress() overwritten output height atm,
  902.   // so we are gonna have postive height in CodecInst::Decompress().
  903.   // but to be sure it is stored in the instance here and accessed in CodecInst::Decompress() - bastel
  904.   ignoretopdown = IgnoreTopDown();
  905.   Msg("DecompressBegin: Top-Down output requests are %s.\n",
  906.       ignoretopdown ? "converted to bottum-up" : "processed normal");
  907.  
  908.   decompressing = true;
  909.  
  910.   int intype = GetBitmapType(lpbiIn);
  911.   int outtype = GetBitmapType(lpbiOut);
  912.  
  913.   int sourceInterlacedInt = *((int*)((char*)(lpbiIn) + sizeof(BITMAPINFOHEADER) + sizeof(int)*3));
  914.  
  915.   source_interlaced = (sourceInterlacedInt == 1) ? true : false;
  916.   Msg("DecompressBegin: source interlaced =  %s\n",
  917.       source_interlaced ? "yes" : "no");
  918.  
  919.   // allocate buffer if decompressing HFYU->YUY2->RGB
  920.   if ((intype == BITMAP_TYPE_COMPRESSED_YUY2 || intype == BITMAP_TYPE_COMPRESSED_YV12)
  921.       && (outtype == BITMAP_TYPE_RGB || outtype == BITMAP_TYPE_RGBA))
  922.     decompress_yuy2_buffer = new unsigned char[lpbiIn->biWidth * lpbiIn->biHeight * 2];
  923.  
  924.   InitClip();
  925.  
  926.   swapfields = !!GetPrivateProfileInt("debug", "decomp_swap_fields", false, INI_FILE);
  927.  
  928.   return ICERR_OK;
  929. }
  930.  
  931.  
  932. static DWORD ConvertYUY2toRGB(LPBITMAPINFOHEADER lpbiOutput, void* _src, void* _dst) {
  933.   const unsigned char* src = (const unsigned char*)_src;
  934.   unsigned char* dst = (unsigned char*)_dst;
  935.   int stride = lpbiOutput->biWidth * 2;
  936.   const unsigned char* src_end = src + stride*lpbiOutput->biHeight;
  937.   if (lpbiOutput->biBitCount == 32)
  938.     mmx_YUY2toRGB32(src, dst, src_end, stride);
  939.   else
  940.     mmx_YUY2toRGB24(src, dst, src_end, stride);
  941.   return ICERR_OK;
  942. }
  943.  
  944. static DWORD ConvertUYVYtoRGB(LPBITMAPINFOHEADER lpbiOutput, void* _src, void* _dst) {
  945.   const unsigned char* src = (const unsigned char*)_src;
  946.   unsigned char* dst = (unsigned char*)_dst;
  947.   int stride = lpbiOutput->biWidth * 2;
  948.   const unsigned char* src_end = src + stride*lpbiOutput->biHeight;
  949.   if (lpbiOutput->biBitCount == 32)
  950.     mmx_UYVYtoRGB32(src, dst, src_end, stride);
  951.   else
  952.     mmx_UYVYtoRGB24(src, dst, src_end, stride);
  953.   return ICERR_OK;
  954. }
  955.  
  956.  
  957. static void ExpandYV12toYUY2Interlaced(LPBITMAPINFOHEADER lpbiOutput, void* src) {
  958.  
  959.   int i,j;
  960.   int rowsize = lpbiOutput->biWidth << 1;
  961.   unsigned char *dest_row;
  962.   unsigned char *src_row;
  963.  
  964.   i = lpbiOutput->biHeight-1;
  965.   dest_row = (unsigned char *) src;
  966.   dest_row += rowsize * (i); // this is odd.
  967.   src_row = (unsigned char *) src;
  968.   src_row += rowsize * ((i >> 1) & (~1));
  969.   // copy the last 2 lines. they can't be averaged.
  970.   for(j=1;j<rowsize;j+=2)
  971.   {
  972.     dest_row[j] = src_row[j];
  973.   }
  974.   dest_row -= rowsize;
  975.   src_row -= rowsize;
  976.   for(j=1;j<rowsize;j+=2)
  977.   {
  978.     dest_row[j] = src_row[j];
  979.   }
  980.  
  981.   dest_row -= rowsize;
  982.   dest_row -= rowsize;
  983.  
  984.   for(i=lpbiOutput->biHeight-4;i > 1;i-=4)
  985.   {
  986.     for(j=1;j<rowsize;j+=2)
  987.     {
  988.       dest_row[j] = dest_row[j - (rowsize << 1)] = src_row[j+rowsize]; 
  989.       dest_row[j+rowsize] = dest_row[j-rowsize] = src_row[j];
  990.     }
  991.     dest_row -= rowsize << 2;
  992.     src_row -= rowsize;
  993.     src_row -= rowsize;
  994.   }
  995.  
  996.  
  997. }
  998.  
  999. static void ExpandYV12toYUY2(LPBITMAPINFOHEADER lpbiOutput, void* src) {
  1000.  
  1001.   int i,j;
  1002.   int rowsize = lpbiOutput->biWidth << 1;
  1003.   unsigned char *dest_row;
  1004.   unsigned char *src_row;
  1005.  
  1006.   i = lpbiOutput->biHeight-1;
  1007.   dest_row = (unsigned char *) src;
  1008.   dest_row += rowsize * (i); // this is odd.
  1009.   src_row = (unsigned char *) src;
  1010.   src_row += rowsize * (i >> 1);
  1011.  
  1012.   for(i=lpbiOutput->biHeight-1;i > 0;i-=2)
  1013.   {
  1014.     for(j=1;j<rowsize;j+=2)
  1015.     {
  1016.       dest_row[j] = dest_row[j - rowsize] = src_row[j]; 
  1017.     }
  1018.     dest_row -= rowsize << 1;
  1019.     src_row -= rowsize;
  1020.   }
  1021.  
  1022. }
  1023.  
  1024. DWORD CodecInst::Decompress(ICDECOMPRESS* icinfo, DWORD dwSize) {
  1025.  
  1026.   // If you insert a Huffyuv-compressed AVI to a Premiere project and then
  1027.   // drag it on to the timeline, the following dialogue occurs:
  1028.   //
  1029.   // 1. Premiere calls ICDecompressBegin, asking Huffyuv to decompress
  1030.   //    to a bitmap with different dimensions than the compressed frame.
  1031.   //
  1032.   // 2. Huffyuv can't resize, so it returns ICERR_BADFORMAT.
  1033.   //
  1034.   // 3. Premiere calls ICDecompress without making another call to
  1035.   //    ICDecompressBegin.
  1036.   //
  1037.   // Therefore I now check for this case and compensate for Premiere's
  1038.   // negligence by making the DecompressBegin call myself.
  1039.  
  1040.   if (!decompressing) {
  1041.     DWORD retval = DecompressBegin(icinfo->lpbiInput, icinfo->lpbiOutput);
  1042.     if (retval != ICERR_OK)
  1043.       return retval;
  1044.   }
  1045.  
  1046.   // we change a top-down output request to a bottom-up one here. - bastel
  1047.   // (imho it should be possible to always do this, this code should never be reached with a negative height)
  1048.   if ( ignoretopdown ) icinfo->lpbiOutput->biHeight = abs(icinfo->lpbiOutput->biHeight);
  1049.  
  1050.   icinfo->lpbiOutput->biSizeImage = (icinfo->lpbiOutput->biWidth * icinfo->lpbiOutput->biHeight * icinfo->lpbiOutput->biBitCount) >> 3;
  1051.   int maxLoss = *((int*)((char*)(icinfo->lpbiInput) + sizeof(BITMAPINFOHEADER) + sizeof(int)*2));
  1052.   int extraVersion = *((int*)((char*)(icinfo->lpbiInput) + sizeof(BITMAPINFOHEADER)));
  1053.   if (extraVersion == 1) maxLoss = 0;
  1054.  
  1055.   int intype = GetBitmapType(icinfo->lpbiInput);
  1056.   if (intype < 0) {
  1057.     int outtype = GetBitmapType(icinfo->lpbiOutput);
  1058.  
  1059.     unsigned char* in = (unsigned char*)icinfo->lpInput;
  1060.     unsigned char* out = (unsigned char*)icinfo->lpOutput;
  1061.     unsigned char* in_end = in;
  1062.     unsigned char* out_end = out;
  1063.  
  1064.     if (intype == BITMAP_TYPE_COMPRESSED_YUY2) {   // decompressing LOCO YUY2
  1065.       int rowsize = icinfo->lpbiOutput->biWidth * 2;
  1066.       int yStep = 1;
  1067. #ifdef LATER
  1068.       if (icinfo->lpbiOutput->biHeight > field_threshold) stride *= 2;      // if image is interlaced, double stride so fields are treated separately
  1069. #endif
  1070.  
  1071.       unsigned char* yuy2 = (outtype == BITMAP_TYPE_RGB || outtype == BITMAP_TYPE_RGBA) ? decompress_yuy2_buffer : out;
  1072.     //memset((void *) yuy2, 128, icinfo->lpbiOutput->biHeight*icinfo->lpbiOutput->biWidth*2);
  1073.  
  1074.       // first Y
  1075.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)yuy2, icinfo->lpbiOutput->biHeight, rowsize,
  1076.             0, 2, 0, yStep, maxLoss);
  1077.       // then U:
  1078.  
  1079.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)yuy2, icinfo->lpbiInput->biHeight, rowsize,
  1080.             1, 4, 0, yStep, maxLoss);
  1081.  
  1082.   // then V:
  1083.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)yuy2, icinfo->lpbiInput->biHeight, rowsize,
  1084.             3, 4, 0, yStep, maxLoss);
  1085.  
  1086.       if (outtype == BITMAP_TYPE_RGB || outtype == BITMAP_TYPE_RGBA)    // LOCO YUY2->RGB
  1087.         ConvertYUY2toRGB(icinfo->lpbiOutput, yuy2, out);
  1088.     }
  1089.     else if (intype == BITMAP_TYPE_COMPRESSED_YV12)  // decompressing LOCO YV12
  1090.     {
  1091.       if (outtype == BITMAP_TYPE_YV12)
  1092.       {
  1093.         int rowsize = icinfo->lpbiOutput->biWidth;
  1094.         int yStep = 1;
  1095.         // first Y
  1096.         in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, icinfo->lpbiOutput->biHeight, rowsize,
  1097.               0, 1, 0, yStep, maxLoss);
  1098.  
  1099.         // then U:
  1100.         out_end += rowsize*icinfo->lpbiInput->biHeight;
  1101.         rowsize = icinfo->lpbiInput->biWidth >> 1;
  1102.  
  1103.         in_end = (unsigned char *)loco_codec_decompress(in_end, 
  1104.           (unsigned char *)out_end, icinfo->lpbiInput->biHeight >> 1, rowsize, 0, 1, 0, yStep, maxLoss);
  1105.  
  1106.         out_end += (rowsize*icinfo->lpbiInput->biHeight) >> 1;
  1107.  
  1108.         // then V:
  1109.         in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, 
  1110.           icinfo->lpbiInput->biHeight >> 1, rowsize, 0, 1, 0, yStep, maxLoss);
  1111.         #ifdef GREY
  1112.           memset(out+icinfo->lpbiOutput->biWidth*icinfo->lpbiInput->biHeight,128,(rowsize*icinfo->lpbiInput->biHeight)* sizeof(char));
  1113.         #endif
  1114.       }
  1115.       else if (outtype == BITMAP_TYPE_YUY2 || outtype == BITMAP_TYPE_RGB)
  1116.       {
  1117.         int rowsize = icinfo->lpbiOutput->biWidth << 1;
  1118.         int yStep = 1;
  1119.         // first Y
  1120.         unsigned char* yuy2 = (outtype == BITMAP_TYPE_RGB || outtype == BITMAP_TYPE_RGBA) ? decompress_yuy2_buffer : out;
  1121.   
  1122.         in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)yuy2, 
  1123.             icinfo->lpbiOutput->biHeight, rowsize, 0, 2, 0, yStep, maxLoss);
  1124.  
  1125.         // then V:
  1126.         in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)yuy2, 
  1127.             icinfo->lpbiOutput->biHeight >> 1, rowsize, 3, 4, 0, yStep, maxLoss);
  1128.         
  1129.         // then U:
  1130.         in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)yuy2, 
  1131.             icinfo->lpbiOutput->biHeight >> 1, rowsize, 1, 4, 0, yStep, maxLoss);
  1132.  
  1133.         if (source_interlaced) ExpandYV12toYUY2Interlaced(icinfo->lpbiOutput, yuy2);
  1134.         else ExpandYV12toYUY2(icinfo->lpbiOutput, yuy2);
  1135.  
  1136.         if (outtype == BITMAP_TYPE_RGB || outtype == BITMAP_TYPE_RGBA)    // LOCO YUY2->RGB
  1137.           ConvertYUY2toRGB(icinfo->lpbiOutput, yuy2, out);
  1138.       }
  1139.     }
  1140.     else if (intype == BITMAP_TYPE_COMPRESSED_RGB) { // LOCO RGB24
  1141.       int rowsize = icinfo->lpbiOutput->biWidth * 3;
  1142.       int yStep = 1;
  1143.  
  1144.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, 
  1145.         icinfo->lpbiOutput->biHeight, rowsize, 0, 3, 0, yStep, maxLoss);
  1146.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, 
  1147.         icinfo->lpbiOutput->biHeight, rowsize, 1, 3, 0, yStep, maxLoss);
  1148.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, 
  1149.         icinfo->lpbiOutput->biHeight, rowsize, 2, 3, 0, yStep, maxLoss);
  1150.     }
  1151.     else if (intype == BITMAP_TYPE_COMPRESSED_RGBA) {    // LOCO RGB32
  1152.       int rowsize = icinfo->lpbiOutput->biWidth * 4;
  1153.       int yStep = 1;
  1154.  
  1155.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, 
  1156.         icinfo->lpbiOutput->biHeight, rowsize, 0, 4, 0, yStep, maxLoss);
  1157.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, 
  1158.         icinfo->lpbiOutput->biHeight, rowsize, 1, 4, 0, yStep, maxLoss);
  1159.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, 
  1160.         icinfo->lpbiOutput->biHeight, rowsize, 2, 4, 0, yStep, maxLoss);
  1161.       in_end = (unsigned char *)loco_codec_decompress(in_end, (unsigned char *)out_end, 
  1162.         icinfo->lpbiOutput->biHeight, rowsize, 3, 4, 0, yStep, maxLoss);
  1163.     }
  1164.  
  1165.     if (swapfields && source_interlaced)
  1166.       asm_SwapFields(out, out+icinfo->lpbiOutput->biSizeImage,
  1167.        (icinfo->lpbiOutput->biWidth * icinfo->lpbiOutput->biBitCount) >> 3);
  1168.  
  1169.     return ICERR_OK;
  1170.   }
  1171.   else if (intype == BITMAP_TYPE_YUY2) {   // YUY2->RGB
  1172.     return ConvertYUY2toRGB(icinfo->lpbiOutput, icinfo->lpInput, icinfo->lpOutput);
  1173.   }
  1174.   else if (intype == BITMAP_TYPE_UYVY) {   // UYVY->RGB
  1175.     return ConvertUYVYtoRGB(icinfo->lpbiOutput, icinfo->lpInput, icinfo->lpOutput);
  1176.   }
  1177.   else
  1178.     return ICERR_BADFORMAT;
  1179. }
  1180.  
  1181.  
  1182. // palette-mapped output only
  1183. DWORD CodecInst::DecompressGetPalette(LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) {
  1184.   return ICERR_BADFORMAT;
  1185. }
  1186.  
  1187.  
  1188. DWORD CodecInst::DecompressEnd() {
  1189.   if (decompress_yuy2_buffer) {
  1190.     delete[] decompress_yuy2_buffer;
  1191.     decompress_yuy2_buffer = 0;
  1192.   }
  1193.   decompressing = false;
  1194.   return ICERR_OK;
  1195. }
  1196.  
  1197.  
  1198.