00001 #include "stdafx.h"
00002 #include "MPEG2Dec.h"
00003
00004 int testint;
00005
00006 struct CPU {
00007 BOOL mmx;
00008 BOOL _3dnow;
00009 BOOL ssemmx;
00010 BOOL ssefpu;
00011 } cpu;
00012
00013 void CheckCPU()
00014 {
00015 __asm
00016 {
00017 mov eax, 1
00018 cpuid
00019 test edx, 0x00800000
00020 jz TEST_SSE
00021 mov [cpu.mmx], 1
00022 TEST_SSE:
00023 test edx, 0x02000000
00024 jz TEST_3DNOW
00025 mov [cpu.ssemmx], 1
00026 mov [cpu.ssefpu], 1
00027 TEST_3DNOW:
00028 mov eax, 0x80000001
00029 cpuid
00030 test edx, 0x80000000
00031 jz TEST_SSEMMX
00032 mov [cpu._3dnow], 1
00033 TEST_SSEMMX:
00034 test edx, 0x00400000
00035 jz TEST_END
00036 mov [cpu.ssemmx], 1
00037 TEST_END:
00038 }
00039 }
00040
00041
00042
00043 extern "C" void __fastcall MMX_IDCT(short *block);
00044 extern "C" void __fastcall SSEMMX_IDCT(short *block);
00045 extern void Initialize_FPU_IDCT(void);
00046 extern void FPU_IDCT(short *block);
00047 extern void Initialize_REF_IDCT(void);
00048 extern void REF_IDCT(short *block);
00049
00050
00051 static unsigned char default_intra_quantizer_matrix[64] =
00052 {
00053 8, 16, 19, 22, 26, 27, 29, 34,
00054 16, 16, 22, 24, 27, 29, 34, 37,
00055 19, 22, 26, 27, 29, 34, 34, 38,
00056 22, 22, 26, 27, 29, 34, 37, 40,
00057 22, 26, 27, 29, 32, 35, 40, 48,
00058 26, 27, 29, 32, 35, 40, 48, 58,
00059 26, 27, 29, 34, 38, 46, 56, 69,
00060 27, 29, 35, 38, 46, 56, 69, 83
00061 };
00062
00063
00064 static unsigned char scan[2][64] =
00065 {
00066 {
00067 0, 1, 8, 16, 9, 2, 3, 10,
00068 17, 24, 32, 25, 18, 11, 4, 5,
00069 12, 19, 26, 33, 40, 48, 41, 34,
00070 27, 20, 13, 6, 7, 14, 21, 28,
00071 35, 42, 49, 56, 57, 50, 43, 36,
00072 29, 22, 15, 23, 30, 37, 44, 51,
00073 58, 59, 52, 45, 38, 31, 39, 46,
00074 53, 60, 61, 54, 47, 55, 62, 63
00075 }
00076 ,
00077 {
00078 0, 8, 16, 24, 1, 9, 2, 10,
00079 17, 25, 32, 40, 48, 56, 57, 49,
00080 41, 33, 26, 18, 3, 11, 4, 12,
00081 19, 27, 34, 42, 50, 58, 35, 43,
00082 51, 59, 20, 28, 5, 13, 6, 14,
00083 21, 29, 36, 44, 52, 60, 37, 45,
00084 53, 61, 22, 30, 7, 15, 23, 31,
00085 38, 46, 54, 62, 39, 47, 55, 63
00086 }
00087 };
00088
00089
00090 static unsigned char Non_Linear_quantizer_scale[32] =
00091 {
00092 0, 1, 2, 3, 4, 5, 6, 7,
00093 8, 10, 12, 14, 16, 18, 20, 22,
00094 24, 28, 32, 36, 40, 44, 48, 52,
00095 56, 64, 72, 80, 88, 96, 104, 112
00096 };
00097
00098 #define ERROR_VALUE (-1)
00099
00100 typedef struct {
00101 char run, level, len;
00102 } DCTtab;
00103
00104 typedef struct {
00105 char val, len;
00106 } VLCtab;
00107
00108
00109 static VLCtab MVtab0[8] =
00110 {
00111 {ERROR_VALUE,0}, {3,3}, {2,2}, {2,2}, {1,1}, {1,1}, {1,1}, {1,1}
00112 };
00113
00114
00115 static VLCtab MVtab1[8] =
00116 {
00117 {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0}, {7,6}, {6,6}, {5,6}, {4,5}, {4,5}
00118 };
00119
00120
00121 static VLCtab MVtab2[12] =
00122 {
00123 {16,9}, {15,9}, {14,9}, {13,9},
00124 {12,9}, {11,9}, {10,8}, {10,8},
00125 {9,8}, {9,8}, {8,8}, {8,8}
00126 };
00127
00128
00129 static VLCtab CBPtab0[32] =
00130 {
00131 {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0},
00132 {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0},
00133 {62,5}, {2,5}, {61,5}, {1,5}, {56,5}, {52,5}, {44,5}, {28,5},
00134 {40,5}, {20,5}, {48,5}, {12,5}, {32,4}, {32,4}, {16,4}, {16,4},
00135 {8,4}, {8,4}, {4,4}, {4,4}, {60,3}, {60,3}, {60,3}, {60,3}
00136 };
00137
00138
00139 static VLCtab CBPtab1[64] =
00140 {
00141 {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0}, {ERROR_VALUE,0},
00142 {58,8}, {54,8}, {46,8}, {30,8},
00143 {57,8}, {53,8}, {45,8}, {29,8}, {38,8}, {26,8}, {37,8}, {25,8},
00144 {43,8}, {23,8}, {51,8}, {15,8}, {42,8}, {22,8}, {50,8}, {14,8},
00145 {41,8}, {21,8}, {49,8}, {13,8}, {35,8}, {19,8}, {11,8}, {7,8},
00146 {34,7}, {34,7}, {18,7}, {18,7}, {10,7}, {10,7}, {6,7}, {6,7},
00147 {33,7}, {33,7}, {17,7}, {17,7}, {9,7}, {9,7}, {5,7}, {5,7},
00148 {63,6}, {63,6}, {63,6}, {63,6}, {3,6}, {3,6}, {3,6}, {3,6},
00149 {36,6}, {36,6}, {36,6}, {36,6}, {24,6}, {24,6}, {24,6}, {24,6}
00150 };
00151
00152
00153 static VLCtab CBPtab2[8] =
00154 {
00155 {ERROR_VALUE,0}, {0,9}, {39,9}, {27,9}, {59,9}, {55,9}, {47,9}, {31,9}
00156 };
00157
00158
00159 static VLCtab MBAtab1[16] =
00160 {
00161 {ERROR_VALUE,0}, {ERROR_VALUE,0}, {7,5}, {6,5}, {5,4}, {5,4}, {4,4},
00162 {4,4}, {3,3}, {3,3}, {3,3}, {3,3}, {2,3}, {2,3}, {2,3}, {2,3}
00163 };
00164
00165
00166 static VLCtab MBAtab2[104] =
00167 {
00168 {33,11}, {32,11}, {31,11}, {30,11}, {29,11}, {28,11}, {27,11}, {26,11},
00169 {25,11}, {24,11}, {23,11}, {22,11}, {21,10}, {21,10}, {20,10}, {20,10},
00170 {19,10}, {19,10}, {18,10}, {18,10}, {17,10}, {17,10}, {16,10}, {16,10},
00171 {15,8}, {15,8}, {15,8}, {15,8}, {15,8}, {15,8}, {15,8}, {15,8},
00172 {14,8}, {14,8}, {14,8}, {14,8}, {14,8}, {14,8}, {14,8}, {14,8},
00173 {13,8}, {13,8}, {13,8}, {13,8}, {13,8}, {13,8}, {13,8}, {13,8},
00174 {12,8}, {12,8}, {12,8}, {12,8}, {12,8}, {12,8}, {12,8}, {12,8},
00175 {11,8}, {11,8}, {11,8}, {11,8}, {11,8}, {11,8}, {11,8}, {11,8},
00176 {10,8}, {10,8}, {10,8}, {10,8}, {10,8}, {10,8}, {10,8}, {10,8},
00177 {9,7}, {9,7}, {9,7}, {9,7}, {9,7}, {9,7}, {9,7}, {9,7},
00178 {9,7}, {9,7}, {9,7}, {9,7}, {9,7}, {9,7}, {9,7}, {9,7},
00179 {8,7}, {8,7}, {8,7}, {8,7}, {8,7}, {8,7}, {8,7}, {8,7},
00180 {8,7}, {8,7}, {8,7}, {8,7}, {8,7}, {8,7}, {8,7}, {8,7}
00181 };
00182
00183
00184 static VLCtab DClumtab0[32] =
00185 {
00186 {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
00187 {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
00188 {0, 3}, {0, 3}, {0, 3}, {0, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3},
00189 {4, 3}, {4, 3}, {4, 3}, {4, 3}, {5, 4}, {5, 4}, {6, 5}, {ERROR_VALUE, 0}
00190 };
00191
00192
00193 static VLCtab DClumtab1[16] =
00194 {
00195 {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6},
00196 {8, 7}, {8, 7}, {8, 7}, {8, 7}, {9, 8}, {9, 8}, {10,9}, {11,9}
00197 };
00198
00199
00200 static VLCtab DCchromtab0[32] =
00201 {
00202 {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2},
00203 {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
00204 {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
00205 {3, 3}, {3, 3}, {3, 3}, {3, 3}, {4, 4}, {4, 4}, {5, 5}, {ERROR_VALUE, 0}
00206 };
00207
00208
00209 static VLCtab DCchromtab1[32] =
00210 {
00211 {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
00212 {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
00213 {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7},
00214 {8, 8}, {8, 8}, {8, 8}, {8, 8}, {9, 9}, {9, 9}, {10,10}, {11,10}
00215 };
00216
00217
00218
00219
00220 static DCTtab DCTtabfirst[12] =
00221 {
00222 {0,2,4}, {2,1,4}, {1,1,3}, {1,1,3},
00223 {0,1,1}, {0,1,1}, {0,1,1}, {0,1,1},
00224 {0,1,1}, {0,1,1}, {0,1,1}, {0,1,1}
00225 };
00226
00227
00228
00229
00230 static DCTtab DCTtabnext[12] =
00231 {
00232 {0,2,4}, {2,1,4}, {1,1,3}, {1,1,3},
00233 {64,0,2}, {64,0,2}, {64,0,2}, {64,0,2},
00234 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2}
00235 };
00236
00237
00238
00239
00240 static DCTtab DCTtab0[60] =
00241 {
00242 {65,0,6}, {65,0,6}, {65,0,6}, {65,0,6},
00243 {2,2,7}, {2,2,7}, {9,1,7}, {9,1,7},
00244 {0,4,7}, {0,4,7}, {8,1,7}, {8,1,7},
00245 {7,1,6}, {7,1,6}, {7,1,6}, {7,1,6},
00246 {6,1,6}, {6,1,6}, {6,1,6}, {6,1,6},
00247 {1,2,6}, {1,2,6}, {1,2,6}, {1,2,6},
00248 {5,1,6}, {5,1,6}, {5,1,6}, {5,1,6},
00249 {13,1,8}, {0,6,8}, {12,1,8}, {11,1,8},
00250 {3,2,8}, {1,3,8}, {0,5,8}, {10,1,8},
00251 {0,3,5}, {0,3,5}, {0,3,5}, {0,3,5},
00252 {0,3,5}, {0,3,5}, {0,3,5}, {0,3,5},
00253 {4,1,5}, {4,1,5}, {4,1,5}, {4,1,5},
00254 {4,1,5}, {4,1,5}, {4,1,5}, {4,1,5},
00255 {3,1,5}, {3,1,5}, {3,1,5}, {3,1,5},
00256 {3,1,5}, {3,1,5}, {3,1,5}, {3,1,5}
00257 };
00258
00259
00260
00261
00262 static DCTtab DCTtab0a[252] =
00263 {
00264 {65,0,6}, {65,0,6}, {65,0,6}, {65,0,6},
00265 {7,1,7}, {7,1,7}, {8,1,7}, {8,1,7},
00266 {6,1,7}, {6,1,7}, {2,2,7}, {2,2,7},
00267 {0,7,6}, {0,7,6}, {0,7,6}, {0,7,6},
00268 {0,6,6}, {0,6,6}, {0,6,6}, {0,6,6},
00269 {4,1,6}, {4,1,6}, {4,1,6}, {4,1,6},
00270 {5,1,6}, {5,1,6}, {5,1,6}, {5,1,6},
00271 {1,5,8}, {11,1,8}, {0,11,8}, {0,10,8},
00272 {13,1,8}, {12,1,8}, {3,2,8}, {1,4,8},
00273 {2,1,5}, {2,1,5}, {2,1,5}, {2,1,5},
00274 {2,1,5}, {2,1,5}, {2,1,5}, {2,1,5},
00275 {1,2,5}, {1,2,5}, {1,2,5}, {1,2,5},
00276 {1,2,5}, {1,2,5}, {1,2,5}, {1,2,5},
00277 {3,1,5}, {3,1,5}, {3,1,5}, {3,1,5},
00278 {3,1,5}, {3,1,5}, {3,1,5}, {3,1,5},
00279 {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
00280 {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
00281 {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
00282 {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
00283 {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
00284 {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
00285 {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
00286 {1,1,3}, {1,1,3}, {1,1,3}, {1,1,3},
00287 {64,0,4}, {64,0,4}, {64,0,4}, {64,0,4},
00288 {64,0,4}, {64,0,4}, {64,0,4}, {64,0,4},
00289 {64,0,4}, {64,0,4}, {64,0,4}, {64,0,4},
00290 {64,0,4}, {64,0,4}, {64,0,4}, {64,0,4},
00291 {0,3,4}, {0,3,4}, {0,3,4}, {0,3,4},
00292 {0,3,4}, {0,3,4}, {0,3,4}, {0,3,4},
00293 {0,3,4}, {0,3,4}, {0,3,4}, {0,3,4},
00294 {0,3,4}, {0,3,4}, {0,3,4}, {0,3,4},
00295 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00296 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00297 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00298 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00299 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00300 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00301 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00302 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00303 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00304 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00305 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00306 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00307 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00308 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00309 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00310 {0,1,2}, {0,1,2}, {0,1,2}, {0,1,2},
00311 {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
00312 {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
00313 {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
00314 {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
00315 {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
00316 {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
00317 {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
00318 {0,2,3}, {0,2,3}, {0,2,3}, {0,2,3},
00319 {0,4,5}, {0,4,5}, {0,4,5}, {0,4,5},
00320 {0,4,5}, {0,4,5}, {0,4,5}, {0,4,5},
00321 {0,5,5}, {0,5,5}, {0,5,5}, {0,5,5},
00322 {0,5,5}, {0,5,5}, {0,5,5}, {0,5,5},
00323 {9,1,7}, {9,1,7}, {1,3,7}, {1,3,7},
00324 {10,1,7}, {10,1,7}, {0,8,7}, {0,8,7},
00325 {0,9,7}, {0,9,7}, {0,12,8}, {0,13,8},
00326 {2,3,8}, {4,2,8}, {0,14,8}, {0,15,8}
00327 };
00328
00329
00330
00331
00332 static DCTtab DCTtab1[8] =
00333 {
00334 {16,1,10}, {5,2,10}, {0,7,10}, {2,3,10},
00335 {1,4,10}, {15,1,10}, {14,1,10}, {4,2,10}
00336 };
00337
00338
00339
00340
00341 static DCTtab DCTtab1a[8] =
00342 {
00343 {5,2,9}, {5,2,9}, {14,1,9}, {14,1,9},
00344 {2,4,10}, {16,1,10}, {15,1,9}, {15,1,9}
00345 };
00346
00347
00348
00349
00350 static DCTtab DCTtab2[16] =
00351 {
00352 {0,11,12}, {8,2,12}, {4,3,12}, {0,10,12},
00353 {2,4,12}, {7,2,12}, {21,1,12}, {20,1,12},
00354 {0,9,12}, {19,1,12}, {18,1,12}, {1,5,12},
00355 {3,3,12}, {0,8,12}, {6,2,12}, {17,1,12}
00356 };
00357
00358
00359
00360
00361 static DCTtab DCTtab3[16] =
00362 {
00363 {10,2,13}, {9,2,13}, {5,3,13}, {3,4,13},
00364 {2,5,13}, {1,7,13}, {1,6,13}, {0,15,13},
00365 {0,14,13}, {0,13,13}, {0,12,13}, {26,1,13},
00366 {25,1,13}, {24,1,13}, {23,1,13}, {22,1,13}
00367 };
00368
00369
00370
00371
00372 static DCTtab DCTtab4[16] =
00373 {
00374 {0,31,14}, {0,30,14}, {0,29,14}, {0,28,14},
00375 {0,27,14}, {0,26,14}, {0,25,14}, {0,24,14},
00376 {0,23,14}, {0,22,14}, {0,21,14}, {0,20,14},
00377 {0,19,14}, {0,18,14}, {0,17,14}, {0,16,14}
00378 };
00379
00380
00381
00382
00383 static DCTtab DCTtab5[16] =
00384 {
00385 {0,40,15}, {0,39,15}, {0,38,15}, {0,37,15},
00386 {0,36,15}, {0,35,15}, {0,34,15}, {0,33,15},
00387 {0,32,15}, {1,14,15}, {1,13,15}, {1,12,15},
00388 {1,11,15}, {1,10,15}, {1,9,15}, {1,8,15}
00389 };
00390
00391
00392
00393
00394 static DCTtab DCTtab6[16] =
00395 {
00396 {1,18,16}, {1,17,16}, {1,16,16}, {1,15,16},
00397 {6,3,16}, {16,2,16}, {15,2,16}, {14,2,16},
00398 {13,2,16}, {12,2,16}, {11,2,16}, {31,1,16},
00399 {30,1,16}, {29,1,16}, {28,1,16}, {27,1,16}
00400 };
00401
00402
00403 static VLCtab PMBtab0[8] =
00404 {
00405 {ERROR_VALUE,0},
00406 {MACROBLOCK_MOTION_FORWARD,3},
00407 {MACROBLOCK_PATTERN,2}, {MACROBLOCK_PATTERN,2},
00408 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,1},
00409 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,1},
00410 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,1},
00411 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,1}
00412 };
00413
00414
00415 static VLCtab PMBtab1[8] =
00416 {
00417 {ERROR_VALUE,0},
00418 {MACROBLOCK_QUANT|MACROBLOCK_INTRA,6},
00419 {MACROBLOCK_QUANT|MACROBLOCK_PATTERN,5}, {MACROBLOCK_QUANT|MACROBLOCK_PATTERN,5},
00420 {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,5}, {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,5},
00421 {MACROBLOCK_INTRA,5}, {MACROBLOCK_INTRA,5}
00422 };
00423
00424
00425 static VLCtab BMBtab0[16] =
00426 {
00427 {ERROR_VALUE,0},
00428 {ERROR_VALUE,0},
00429 {MACROBLOCK_MOTION_FORWARD,4},
00430 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,4},
00431 {MACROBLOCK_MOTION_BACKWARD,3},
00432 {MACROBLOCK_MOTION_BACKWARD,3},
00433 {MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,3},
00434 {MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,3},
00435 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD,2},
00436 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD,2},
00437 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD,2},
00438 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD,2},
00439 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,2},
00440 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,2},
00441 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,2},
00442 {MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,2}
00443 };
00444
00445
00446 static VLCtab BMBtab1[8] =
00447 {
00448 {ERROR_VALUE,0},
00449 {MACROBLOCK_QUANT|MACROBLOCK_INTRA,6},
00450 {MACROBLOCK_QUANT|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,6},
00451 {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_PATTERN,6},
00452 {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,5},
00453 {MACROBLOCK_QUANT|MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD|MACROBLOCK_PATTERN,5},
00454 {MACROBLOCK_INTRA,5},
00455 {MACROBLOCK_INTRA,5}
00456 };
00457
00458
00459
00460
00461
00462 void CMPEG2Dec::Initialize_Buffer()
00463 {
00464 Rdptr = Rdbfr + BUFFER_SIZE;
00465 Rdmax = Rdptr;
00466
00467 if (SystemStream_Flag)
00468 {
00469 if (Rdptr >= Rdmax)
00470 Next_Packet();
00471 CurrentBfr = *Rdptr++ << 24;
00472
00473 if (Rdptr >= Rdmax)
00474 Next_Packet();
00475 CurrentBfr += *Rdptr++ << 16;
00476
00477 if (Rdptr >= Rdmax)
00478 Next_Packet();
00479 CurrentBfr += *Rdptr++ << 8;
00480
00481 if (Rdptr >= Rdmax)
00482 Next_Packet();
00483 CurrentBfr += *Rdptr++;
00484
00485 Fill_Next();
00486 }
00487 else
00488 {
00489 Fill_Buffer();
00490
00491 CurrentBfr = (*Rdptr << 24) + (*(Rdptr+1) << 16) + (*(Rdptr+2) << 8) + *(Rdptr+3);
00492 Rdptr += 4;
00493
00494 Fill_Next();
00495 }
00496
00497 BitsLeft = 32;
00498 }
00499
00500 unsigned int CMPEG2Dec::Get_Bits_All(unsigned int N)
00501 {
00502 N -= BitsLeft;
00503 Val = (CurrentBfr << (32 - BitsLeft)) >> (32 - BitsLeft);
00504
00505 if (N != 0)
00506 Val = (Val << N) + (NextBfr >> (32 - N));
00507
00508 CurrentBfr = NextBfr;
00509 BitsLeft = 32 - N;
00510 Fill_Next();
00511
00512 return Val;
00513 }
00514
00515 void CMPEG2Dec::Flush_Buffer_All(unsigned int N)
00516 {
00517 CurrentBfr = NextBfr;
00518 BitsLeft = BitsLeft + 32 - N;
00519 Fill_Next();
00520 }
00521
00522 void CMPEG2Dec::Next_Packet()
00523 {
00524 unsigned int code, Packet_Length, Packet_Header_Length;
00525
00526 for (;;)
00527 {
00528 code = Get_Short();
00529 code = (code<<16) + Get_Short();
00530
00531
00532 while ((code & 0xffffff00) != 0x00000100)
00533 code = (code<<8) + Get_Byte();
00534
00535 switch (code)
00536 {
00537 case PACK_START_CODE:
00538 Rdptr += 8;
00539 break;
00540
00541 case VIDEO_ELEMENTARY_STREAM:
00542 Packet_Length = Get_Short();
00543 Rdmax = Rdptr + Packet_Length;
00544
00545 code = Get_Byte();
00546
00547 if ((code & 0xc0)==0x80)
00548 {
00549 code = Get_Byte();
00550 Packet_Header_Length = Get_Byte();
00551
00552 Rdptr += Packet_Header_Length;
00553 return;
00554 }
00555 else
00556 Rdptr += Packet_Length-1;
00557 break;
00558
00559 default:
00560 if (code>=SYSTEM_START_CODE)
00561 {
00562 code = Get_Short();
00563 Rdptr += code;
00564 }
00565 break;
00566 }
00567 }
00568 }
00569
00570 void CMPEG2Dec::Fill_Buffer()
00571 {
00572 Read = _read(Infile[File_Flag], Rdbfr, BUFFER_SIZE);
00573
00574 if (Read < BUFFER_SIZE)
00575 Next_File();
00576
00577 if (KeyOp_Flag && (Rdbfr[20] & 0x10))
00578 {
00579 BufferOp(Rdbfr, lfsr0, lfsr1);
00580 Rdbfr[20] &= ~0x10;
00581 }
00582
00583 Rdptr = Rdbfr;
00584
00585 if (SystemStream_Flag)
00586 Rdmax -= BUFFER_SIZE;
00587 }
00588
00589 void CMPEG2Dec::Next_File()
00590 {
00591 if (File_Flag < File_Limit-1)
00592 File_Flag ++;
00593
00594 _lseeki64(Infile[File_Flag], 0, SEEK_SET);
00595 _read(Infile[File_Flag], Rdbfr + Read, BUFFER_SIZE - Read);
00596 }
00597
00598
00599 unsigned int CMPEG2Dec::Show_Bits(unsigned int N)
00600 {
00601 if (N <= BitsLeft)
00602 return (CurrentBfr << (32 - BitsLeft)) >> (32 - N);
00603 else
00604 {
00605 N -= BitsLeft;
00606 return (((CurrentBfr << (32 - BitsLeft)) >> (32 - BitsLeft)) << N) + (NextBfr >> (32 - N));
00607 }
00608 }
00609
00610 unsigned int CMPEG2Dec::Get_Bits(unsigned int N)
00611 {
00612 if (N < BitsLeft)
00613 {
00614 Val = (CurrentBfr << (32 - BitsLeft)) >> (32 - N);
00615 BitsLeft -= N;
00616 return Val;
00617 }
00618 else
00619 return Get_Bits_All(N);
00620 }
00621
00622 void CMPEG2Dec::Flush_Buffer(unsigned int N)
00623 {
00624 if (N < BitsLeft)
00625 BitsLeft -= N;
00626 else
00627 Flush_Buffer_All(N);
00628 }
00629
00630 void CMPEG2Dec::Fill_Next()
00631 {
00632 if (SystemStream_Flag && Rdptr>=Rdmax-4)
00633 {
00634 if (Rdptr >= Rdmax)
00635 Next_Packet();
00636 NextBfr = Get_Byte() << 24;
00637
00638 if (Rdptr >= Rdmax)
00639 Next_Packet();
00640 NextBfr += Get_Byte() << 16;
00641
00642 if (Rdptr >= Rdmax)
00643 Next_Packet();
00644 NextBfr += Get_Byte() << 8;
00645
00646 if (Rdptr >= Rdmax)
00647 Next_Packet();
00648 NextBfr += Get_Byte();
00649 }
00650 else if (Rdptr < Rdbfr+BUFFER_SIZE-4)
00651 {
00652 NextBfr = (*Rdptr << 24) + (*(Rdptr+1) << 16) + (*(Rdptr+2) << 8) + *(Rdptr+3);
00653 Rdptr += 4;
00654 }
00655 else
00656 {
00657 if (Rdptr >= Rdbfr+BUFFER_SIZE)
00658 Fill_Buffer();
00659 NextBfr = *Rdptr++ << 24;
00660
00661 if (Rdptr >= Rdbfr+BUFFER_SIZE)
00662 Fill_Buffer();
00663 NextBfr += *Rdptr++ << 16;
00664
00665 if (Rdptr >= Rdbfr+BUFFER_SIZE)
00666 Fill_Buffer();
00667 NextBfr += *Rdptr++ << 8;
00668
00669 if (Rdptr >= Rdbfr+BUFFER_SIZE)
00670 Fill_Buffer();
00671 NextBfr += *Rdptr++;
00672 }
00673 }
00674
00675 unsigned int CMPEG2Dec::Get_Byte()
00676 {
00677 while (Rdptr >= (Rdbfr + BUFFER_SIZE))
00678 {
00679 Read = _read(Infile[File_Flag], Rdbfr, BUFFER_SIZE);
00680
00681 if (Read < BUFFER_SIZE)
00682 Next_File();
00683
00684 if (KeyOp_Flag && (Rdbfr[20] & 0x10))
00685 {
00686 BufferOp(Rdbfr, lfsr0, lfsr1);
00687 Rdbfr[20] &= ~0x10;
00688 }
00689
00690 Rdptr -= BUFFER_SIZE;
00691 Rdmax -= BUFFER_SIZE;
00692 }
00693
00694 return *Rdptr++;
00695 }
00696
00697 unsigned int CMPEG2Dec::Get_Short()
00698 {
00699 unsigned int i = Get_Byte();
00700 return (i<<8) + Get_Byte();
00701 }
00702
00703 void CMPEG2Dec::next_start_code()
00704 {
00705 Flush_Buffer(BitsLeft & 7);
00706
00707 while (Show_Bits(24) != 1)
00708 Flush_Buffer(8);
00709 }
00710
00711
00712
00713
00714
00715 int CMPEG2Dec::Get_Hdr()
00716 {
00717 for (;;)
00718 {
00719
00720 next_start_code();
00721
00722 switch (Get_Bits(32))
00723 {
00724 case SEQUENCE_HEADER_CODE:
00725 sequence_header();
00726 break;
00727
00728 case GROUP_START_CODE:
00729 group_of_pictures_header();
00730 break;
00731
00732 case PICTURE_START_CODE:
00733 picture_header();
00734 return 1;
00735 }
00736 }
00737 }
00738
00739
00740
00741 void CMPEG2Dec::group_of_pictures_header()
00742 {
00743 int gop_hour;
00744 int gop_minute;
00745 int gop_sec;
00746 int gop_frame;
00747
00748 int drop_flag;
00749 int closed_gop;
00750 int broken_link;
00751
00752 drop_flag = Get_Bits(1);
00753 gop_hour = Get_Bits(5);
00754 gop_minute = Get_Bits(6);
00755 Flush_Buffer(1);
00756 gop_sec = Get_Bits(6);
00757 gop_frame = Get_Bits(6);
00758 closed_gop = Get_Bits(1);
00759 broken_link = Get_Bits(1);
00760
00761 extension_and_user_data();
00762 }
00763
00764
00765
00766 void CMPEG2Dec::picture_header()
00767 {
00768 int vbv_delay;
00769 int full_pel_forward_vector;
00770 int forward_f_code;
00771 int full_pel_backward_vector;
00772 int backward_f_code;
00773 int Extra_Information_Byte_Count;
00774
00775 temporal_reference = Get_Bits(10);
00776 picture_coding_type = Get_Bits(3);
00777 vbv_delay = Get_Bits(16);
00778
00779 if (picture_coding_type==P_TYPE || picture_coding_type==B_TYPE)
00780 {
00781 full_pel_forward_vector = Get_Bits(1);
00782 forward_f_code = Get_Bits(3);
00783 }
00784
00785 if (picture_coding_type==B_TYPE)
00786 {
00787 full_pel_backward_vector = Get_Bits(1);
00788 backward_f_code = Get_Bits(3);
00789 }
00790
00791 Extra_Information_Byte_Count = extra_bit_information();
00792 extension_and_user_data();
00793 }
00794
00795
00796 void CMPEG2Dec::sequence_header()
00797 {
00798 int frame_rate_code;
00799 int vbv_buffer_size;
00800 int aspect_ratio_information;
00801 int bit_rate_value;
00802
00803 int constrained_parameters_flag;
00804 int i;
00805
00806 horizontal_size = Get_Bits(12);
00807 vertical_size = Get_Bits(12);
00808 aspect_ratio_information = Get_Bits(4);
00809 frame_rate_code = Get_Bits(4);
00810 bit_rate_value = Get_Bits(18);
00811 Flush_Buffer(1);
00812 vbv_buffer_size = Get_Bits(10);
00813 constrained_parameters_flag = Get_Bits(1);
00814
00815 if (load_intra_quantizer_matrix = Get_Bits(1))
00816 {
00817 for (i=0; i<64; i++)
00818 intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
00819 }
00820 else
00821 {
00822 for (i=0; i<64; i++)
00823 intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
00824 }
00825
00826 if (load_non_intra_quantizer_matrix = Get_Bits(1))
00827 {
00828 for (i=0; i<64; i++)
00829 non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
00830 }
00831 else
00832 {
00833 for (i=0; i<64; i++)
00834 non_intra_quantizer_matrix[i] = 16;
00835 }
00836
00837
00838 for (i=0; i<64; i++)
00839 {
00840 chroma_intra_quantizer_matrix[i] = intra_quantizer_matrix[i];
00841 chroma_non_intra_quantizer_matrix[i] = non_intra_quantizer_matrix[i];
00842 }
00843 extension_and_user_data();
00844 }
00845
00846
00847
00848 int CMPEG2Dec::slice_header()
00849 {
00850 int slice_vertical_position_extension;
00851 int quantizer_scale_code;
00852 int slice_picture_id_enable = 0;
00853 int slice_picture_id = 0;
00854 int extra_information_slice = 0;
00855
00856 slice_vertical_position_extension = vertical_size>2800 ? Get_Bits(3) : 0;
00857
00858 quantizer_scale_code = Get_Bits(5);
00859 quantizer_scale = q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code] : quantizer_scale_code<<1;
00860
00861
00862
00863 if (Get_Bits(1))
00864 {
00865 Get_Bits(1);
00866
00867 slice_picture_id_enable = Get_Bits(1);
00868 slice_picture_id = Get_Bits(6);
00869
00870 extra_information_slice = extra_bit_information();
00871 }
00872
00873 return slice_vertical_position_extension;
00874 }
00875
00876
00877
00878 void CMPEG2Dec::extension_and_user_data()
00879 {
00880 int code, ext_ID;
00881
00882 next_start_code();
00883
00884 while ((code = Show_Bits(32))==EXTENSION_START_CODE || code==USER_DATA_START_CODE)
00885 {
00886 if (code==EXTENSION_START_CODE)
00887 {
00888 Flush_Buffer(32);
00889 ext_ID = Get_Bits(4);
00890
00891 switch (ext_ID)
00892 {
00893 case SEQUENCE_EXTENSION_ID:
00894 sequence_extension();
00895 break;
00896
00897 case SEQUENCE_DISPLAY_EXTENSION_ID:
00898 sequence_display_extension();
00899 break;
00900
00901 case QUANT_MATRIX_EXTENSION_ID:
00902 quant_matrix_extension();
00903 break;
00904
00905 case PICTURE_DISPLAY_EXTENSION_ID:
00906 picture_display_extension();
00907 break;
00908
00909 case PICTURE_CODING_EXTENSION_ID:
00910 picture_coding_extension();
00911 break;
00912
00913 case COPYRIGHT_EXTENSION_ID:
00914 copyright_extension();
00915 break;
00916 }
00917 next_start_code();
00918 }
00919 else
00920 {
00921 Flush_Buffer(32);
00922 next_start_code();
00923 }
00924 }
00925 }
00926
00927
00928
00929 void CMPEG2Dec::sequence_extension()
00930 {
00931 int profile_and_level_indication;
00932 int low_delay;
00933 int frame_rate_extension_n;
00934 int frame_rate_extension_d;
00935
00936 int horizontal_size_extension;
00937 int vertical_size_extension;
00938 int bit_rate_extension;
00939 int vbv_buffer_size_extension;
00940
00941 profile_and_level_indication = Get_Bits(8);
00942 progressive_sequence = Get_Bits(1);
00943 chroma_format = Get_Bits(2);
00944 horizontal_size_extension = Get_Bits(2);
00945 vertical_size_extension = Get_Bits(2);
00946 bit_rate_extension = Get_Bits(12);
00947 Flush_Buffer(1);
00948 vbv_buffer_size_extension = Get_Bits(8);
00949 low_delay = Get_Bits(1);
00950
00951 frame_rate_extension_n = Get_Bits(2);
00952 frame_rate_extension_d = Get_Bits(5);
00953
00954 horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0x0fff);
00955 vertical_size = (vertical_size_extension<<12) | (vertical_size&0x0fff);
00956 }
00957
00958
00959 void CMPEG2Dec::sequence_display_extension()
00960 {
00961 int video_format;
00962 int color_description;
00963 int color_primaries;
00964 int transfer_characteristics;
00965 int matrix_coefficients;
00966 int display_horizontal_size;
00967 int display_vertical_size;
00968
00969 video_format = Get_Bits(3);
00970 color_description = Get_Bits(1);
00971
00972 if (color_description)
00973 {
00974 color_primaries = Get_Bits(8);
00975 transfer_characteristics = Get_Bits(8);
00976 matrix_coefficients = Get_Bits(8);
00977 }
00978
00979 display_horizontal_size = Get_Bits(14);
00980 Flush_Buffer(1);
00981 display_vertical_size = Get_Bits(14);
00982 }
00983
00984
00985
00986 void CMPEG2Dec::quant_matrix_extension()
00987 {
00988 int i;
00989
00990 if (load_intra_quantizer_matrix = Get_Bits(1))
00991 for (i=0; i<64; i++)
00992 chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
00993 = intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
00994
00995 if (load_non_intra_quantizer_matrix = Get_Bits(1))
00996 for (i=0; i<64; i++)
00997 chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
00998 = non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
00999
01000 if (load_chroma_intra_quantizer_matrix = Get_Bits(1))
01001 for (i=0; i<64; i++)
01002 chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
01003
01004 if (load_chroma_non_intra_quantizer_matrix = Get_Bits(1))
01005 for (i=0; i<64; i++)
01006 chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
01007 }
01008
01009
01010
01011 void CMPEG2Dec::picture_display_extension()
01012 {
01013 int frame_center_horizontal_offset[3];
01014 int frame_center_vertical_offset[3];
01015
01016 int i;
01017 int number_of_frame_center_offsets;
01018
01019
01020
01021
01022
01023 if (progressive_sequence)
01024 {
01025 if (repeat_first_field)
01026 {
01027 if (top_field_first)
01028 number_of_frame_center_offsets = 3;
01029 else
01030 number_of_frame_center_offsets = 2;
01031 }
01032 else
01033 number_of_frame_center_offsets = 1;
01034 }
01035 else
01036 {
01037 if (picture_structure!=FRAME_PICTURE)
01038 number_of_frame_center_offsets = 1;
01039 else
01040 {
01041 if (repeat_first_field)
01042 number_of_frame_center_offsets = 3;
01043 else
01044 number_of_frame_center_offsets = 2;
01045 }
01046 }
01047
01048
01049 for (i=0; i<number_of_frame_center_offsets; i++)
01050 {
01051 frame_center_horizontal_offset[i] = Get_Bits(16);
01052 Flush_Buffer(1);
01053
01054 frame_center_vertical_offset[i] = Get_Bits(16);
01055 Flush_Buffer(1);
01056 }
01057 }
01058
01059
01060 void CMPEG2Dec::picture_coding_extension()
01061 {
01062 int chroma_420_type;
01063 int composite_display_flag;
01064 int v_axis;
01065 int field_sequence;
01066 int sub_carrier;
01067 int burst_amplitude;
01068 int sub_carrier_phase;
01069
01070 f_code[0][0] = Get_Bits(4);
01071 f_code[0][1] = Get_Bits(4);
01072 f_code[1][0] = Get_Bits(4);
01073 f_code[1][1] = Get_Bits(4);
01074
01075 intra_dc_precision = Get_Bits(2);
01076 picture_structure = Get_Bits(2);
01077 top_field_first = Get_Bits(1);
01078 frame_pred_frame_dct = Get_Bits(1);
01079 concealment_motion_vectors = Get_Bits(1);
01080 q_scale_type = Get_Bits(1);
01081 intra_vlc_format = Get_Bits(1);
01082 alternate_scan = Get_Bits(1);
01083 repeat_first_field = Get_Bits(1);
01084 chroma_420_type = Get_Bits(1);
01085 progressive_frame = Get_Bits(1);
01086 composite_display_flag = Get_Bits(1);
01087
01088 pf_current = progressive_frame;
01089
01090 if (composite_display_flag)
01091 {
01092 v_axis = Get_Bits(1);
01093 field_sequence = Get_Bits(3);
01094 sub_carrier = Get_Bits(1);
01095 burst_amplitude = Get_Bits(7);
01096 sub_carrier_phase = Get_Bits(8);
01097 }
01098 }
01099
01100
01101
01102 int CMPEG2Dec::extra_bit_information()
01103 {
01104 int Byte_Count = 0;
01105
01106 while (Get_Bits(1))
01107 {
01108 Flush_Buffer(8);
01109 Byte_Count ++;
01110 }
01111
01112 return(Byte_Count);
01113 }
01114
01115
01116
01117
01118 void CMPEG2Dec::copyright_extension()
01119 {
01120 int copyright_flag;
01121 int copyright_identifier;
01122 int original_or_copy;
01123 int copyright_number_1;
01124 int copyright_number_2;
01125 int copyright_number_3;
01126
01127 int reserved_data;
01128
01129 copyright_flag = Get_Bits(1);
01130 copyright_identifier = Get_Bits(8);
01131 original_or_copy = Get_Bits(1);
01132
01133
01134 reserved_data = Get_Bits(7);
01135
01136 Flush_Buffer(1);
01137 copyright_number_1 = Get_Bits(20);
01138 Flush_Buffer(1);
01139 copyright_number_2 = Get_Bits(22);
01140 Flush_Buffer(1);
01141 copyright_number_3 = Get_Bits(22);
01142 }
01143
01144
01145
01146
01147
01148 static const unsigned char cc_table[12] = {
01149 0, 0, 0, 0, 1, 2, 1, 2, 1, 2, 1, 2
01150 };
01151
01152 void CMPEG2Dec::Decode_Picture(int ref, unsigned char *dst, int pitch)
01153 {
01154 if (picture_structure==FRAME_PICTURE && Second_Field)
01155 Second_Field = 0;
01156
01157 if (picture_coding_type!=B_TYPE)
01158 {
01159 pf_forward = pf_backward;
01160 pf_backward = pf_current;
01161 }
01162
01163 Update_Picture_Buffers();
01164
01165 picture_data();
01166
01167 if (ref && (picture_structure==FRAME_PICTURE || Second_Field))
01168 {
01169 if (picture_coding_type==B_TYPE)
01170 assembleFrame(auxframe, pf_current, dst, pitch);
01171 else
01172 assembleFrame(forward_reference_frame, pf_forward, dst, pitch);
01173 }
01174
01175 if (picture_structure!=FRAME_PICTURE)
01176 Second_Field = !Second_Field;
01177 }
01178
01179
01180 void CMPEG2Dec::Update_Picture_Buffers()
01181 {
01182 int cc;
01183 unsigned char *tmp;
01184
01185 for (cc=0; cc<3; cc++)
01186 {
01187
01188 if (picture_coding_type==B_TYPE)
01189 current_frame[cc] = auxframe[cc];
01190 else
01191 {
01192 if (!Second_Field)
01193 {
01194
01195 tmp = forward_reference_frame[cc];
01196
01197
01198
01199
01200 forward_reference_frame[cc] = backward_reference_frame[cc];
01201
01202
01203 backward_reference_frame[cc] = tmp;
01204 }
01205
01206
01207
01208
01209 current_frame[cc] = backward_reference_frame[cc];
01210 }
01211
01212 if (picture_structure==BOTTOM_FIELD)
01213 current_frame[cc] += (cc==0) ? Coded_Picture_Width : Chroma_Width;
01214 }
01215 }
01216
01217
01218
01219 void CMPEG2Dec::picture_data()
01220 {
01221 int MBAmax;
01222
01223
01224 MBAmax = mb_width*mb_height;
01225
01226 if (picture_structure!=FRAME_PICTURE)
01227 MBAmax>>=1;
01228
01229 for (;;)
01230 if (slice(MBAmax)<0)
01231 return;
01232 }
01233
01234
01235
01236
01237
01238 int CMPEG2Dec::slice(int MBAmax)
01239 {
01240 int MBA = 0, MBAinc =0, macroblock_type, motion_type, dct_type, ret;
01241 int dc_dct_pred[3], PMV[2][2][2], motion_vertical_field_select[2][2], dmvector[2];
01242
01243 if ((ret=start_of_slice(&MBA, &MBAinc, dc_dct_pred, PMV))!=1)
01244 return ret;
01245
01246 for (;;)
01247 {
01248
01249 if (MBA>=MBAmax) return -1;
01250
01251 if (MBAinc==0)
01252 {
01253 if (!Show_Bits(23) || Fault_Flag)
01254 {
01255 resync:
01256 Fault_Flag = 0;
01257 return 0;
01258 }
01259 else
01260 {
01261
01262 MBAinc = Get_macroblock_address_increment();
01263 if (Fault_Flag) goto resync;
01264 }
01265 }
01266
01267 if (MBAinc==1)
01268 {
01269 if (!decode_macroblock(¯oblock_type, &motion_type, &dct_type, PMV,
01270 dc_dct_pred, motion_vertical_field_select, dmvector))
01271 goto resync;
01272 }
01273 else
01274
01275 skipped_macroblock(dc_dct_pred, PMV, &motion_type, motion_vertical_field_select, ¯oblock_type);
01276
01277
01278 motion_compensation(MBA, macroblock_type, motion_type, PMV,
01279 motion_vertical_field_select, dmvector, dct_type);
01280
01281
01282 MBA++; MBAinc--;
01283
01284 if (MBA>=MBAmax) return -1;
01285 }
01286 }
01287
01288
01289 void CMPEG2Dec::macroblock_modes(int *pmacroblock_type, int *pmotion_type,
01290 int *pmotion_vector_count, int *pmv_format,
01291 int *pdmv, int *pmvscale, int *pdct_type)
01292 {
01293 int macroblock_type, motion_type = 0, motion_vector_count;
01294 int mv_format, dmv, mvscale, dct_type;
01295
01296
01297 macroblock_type = Get_macroblock_type();
01298 if (Fault_Flag) return;
01299
01300
01301 if (macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD))
01302 {
01303 if (picture_structure==FRAME_PICTURE)
01304 motion_type = frame_pred_frame_dct ? MC_FRAME : Get_Bits(2);
01305 else
01306 motion_type = Get_Bits(2);
01307 }
01308 else if ((macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
01309 motion_type = (picture_structure==FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
01310
01311
01312 if (picture_structure==FRAME_PICTURE)
01313 {
01314 motion_vector_count = (motion_type==MC_FIELD) ? 2 : 1;
01315 mv_format = (motion_type==MC_FRAME) ? MV_FRAME : MV_FIELD;
01316 }
01317 else
01318 {
01319 motion_vector_count = (motion_type==MC_16X8) ? 2 : 1;
01320 mv_format = MV_FIELD;
01321 }
01322
01323 dmv = (motion_type==MC_DMV);
01324
01325
01326
01327
01328
01329 mvscale = (mv_format==MV_FIELD && picture_structure==FRAME_PICTURE);
01330
01331
01332 dct_type = (picture_structure==FRAME_PICTURE) && (!frame_pred_frame_dct)
01333 && (macroblock_type & (MACROBLOCK_PATTERN|MACROBLOCK_INTRA)) ? Get_Bits(1) : 0;
01334
01335
01336 *pmacroblock_type = macroblock_type;
01337 *pmotion_type = motion_type;
01338 *pmotion_vector_count = motion_vector_count;
01339 *pmv_format = mv_format;
01340 *pdmv = dmv;
01341 *pmvscale = mvscale;
01342 *pdct_type = dct_type;
01343 }
01344
01345
01346
01347
01348
01349
01350
01351
01352 void CMPEG2Dec::Add_Block(int count, int bx, int by, int dct_type, int addflag)
01353 {
01354 static const __int64 mmmask_128 = 0x0080008000800080;
01355
01356 int comp, cc, iincr, bxh, byh;
01357 unsigned char *rfp;
01358 short *Block_Ptr;
01359
01360 for (comp=0; comp<count; comp++)
01361 {
01362 Block_Ptr = block[comp];
01363 cc = cc_table[comp];
01364
01365 bxh = bx; byh = by;
01366
01367 if (cc==0)
01368 {
01369 if (picture_structure==FRAME_PICTURE)
01370 {
01371 if (dct_type)
01372 {
01373 rfp = current_frame[0] + Coded_Picture_Width*(by+((comp&2)>>1)) + bx + ((comp&1)<<3);
01374 iincr = Coded_Picture_Width<<1;
01375 }
01376 else
01377 {
01378 rfp = current_frame[0] + Coded_Picture_Width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
01379 iincr = Coded_Picture_Width;
01380 }
01381 }
01382 else
01383 {
01384 rfp = current_frame[0] + (Coded_Picture_Width<<1)*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
01385 iincr = Coded_Picture_Width<<1;
01386 }
01387 }
01388 else
01389 {
01390 if (chroma_format!=CHROMA444)
01391 bxh >>= 1;
01392 if (chroma_format==CHROMA420)
01393 byh >>= 1;
01394
01395 if (picture_structure==FRAME_PICTURE)
01396 {
01397 if (dct_type && chroma_format!=CHROMA420)
01398 {
01399
01400 rfp = current_frame[cc] + Chroma_Width*(byh+((comp&2)>>1)) + bxh + (comp&8);
01401 iincr = Chroma_Width<<1;
01402 }
01403 else
01404 {
01405
01406 rfp = current_frame[cc] + Chroma_Width*(byh+((comp&2)<<2)) + bxh + (comp&8);
01407 iincr = Chroma_Width;
01408 }
01409 }
01410 else
01411 {
01412
01413 rfp = current_frame[cc] + (Chroma_Width<<1)*(byh+((comp&2)<<2)) + bxh + (comp&8);
01414 iincr = Chroma_Width<<1;
01415 }
01416 }
01417
01418 if (addflag)
01419 {
01420 __asm
01421 {
01422 pxor mm0, mm0
01423 mov eax, [rfp]
01424 mov ebx, [Block_Ptr]
01425 mov edi, 8
01426 addon:
01427 movq mm2, [ebx+8]
01428
01429 movq mm3, [eax]
01430 movq mm4, mm3
01431
01432 movq mm1, [ebx]
01433 punpckhbw mm3, mm0
01434
01435 paddsw mm3, mm2
01436 packuswb mm3, mm0
01437
01438 punpcklbw mm4, mm0
01439 psllq mm3, 32
01440
01441 paddsw mm4, mm1
01442 packuswb mm4, mm0
01443
01444 por mm3, mm4
01445 add ebx, 16
01446
01447 dec edi
01448 movq [eax], mm3
01449
01450 add eax, [iincr]
01451 cmp edi, 0x00
01452 jg addon
01453 }
01454 }
01455 else
01456 {
01457 __asm
01458 {
01459 mov eax, [rfp]
01460 mov ebx, [Block_Ptr]
01461 mov edi, 8
01462
01463 pxor mm0, mm0
01464 movq mm7, [mmmask_128]
01465 addoff:
01466 movq mm3, [ebx+8]
01467 movq mm4, [ebx]
01468
01469 paddsw mm3, mm7
01470 paddsw mm4, mm7
01471
01472 packuswb mm3, mm0
01473 packuswb mm4, mm0
01474
01475 psllq mm3, 32
01476 por mm3, mm4
01477
01478 add ebx, 16
01479 dec edi
01480
01481 movq [eax], mm3
01482
01483 add eax, [iincr]
01484 cmp edi, 0x00
01485 jg addoff
01486 }
01487 }
01488 }
01489 }
01490
01491
01492 void CMPEG2Dec::Clear_Block(int count)
01493 {
01494 int comp;
01495 short *Block_Ptr;
01496
01497 for (comp=0; comp<count; comp++)
01498 {
01499 Block_Ptr = block[comp];
01500
01501 __asm
01502 {
01503 mov eax, [Block_Ptr];
01504 pxor mm0, mm0;
01505 movq [eax+0 ], mm0;
01506 movq [eax+8 ], mm0;
01507 movq [eax+16], mm0;
01508 movq [eax+24], mm0;
01509 movq [eax+32], mm0;
01510 movq [eax+40], mm0;
01511 movq [eax+48], mm0;
01512 movq [eax+56], mm0;
01513 movq [eax+64], mm0;
01514 movq [eax+72], mm0;
01515 movq [eax+80], mm0;
01516 movq [eax+88], mm0;
01517 movq [eax+96], mm0;
01518 movq [eax+104],mm0;
01519 movq [eax+112],mm0;
01520 movq [eax+120],mm0;
01521 }
01522 }
01523 }
01524
01525
01526 void CMPEG2Dec::motion_compensation(int MBA, int macroblock_type, int motion_type,
01527 int PMV[2][2][2], int motion_vertical_field_select[2][2],
01528 int dmvector[2], int dct_type)
01529 {
01530 int bx, by;
01531 int comp;
01532
01533
01534
01535 bx = 16*(MBA%mb_width);
01536 by = 16*(MBA/mb_width);
01537
01538
01539 if (!(macroblock_type & MACROBLOCK_INTRA))
01540 form_predictions(bx, by, macroblock_type, motion_type, PMV,
01541 motion_vertical_field_select, dmvector);
01542
01543 switch (IDCT_Flag)
01544 {
01545 case IDCT_MMX:
01546 for (comp=0; comp<block_count; comp++)
01547 MMX_IDCT(block[comp]);
01548 break;
01549
01550 case IDCT_SSEMMX:
01551 for (comp=0; comp<block_count; comp++)
01552 SSEMMX_IDCT(block[comp]);
01553 break;
01554
01555 case IDCT_FPU:
01556 __asm emms;
01557 for (comp=0; comp<block_count; comp++)
01558 FPU_IDCT(block[comp]);
01559 break;
01560
01561 case IDCT_REF:
01562 __asm emms;
01563 for (comp=0; comp<block_count; comp++)
01564 REF_IDCT(block[comp]);
01565 break;
01566 }
01567
01568 Add_Block(block_count, bx, by, dct_type, (macroblock_type & MACROBLOCK_INTRA)==0);
01569 }
01570
01571
01572 void CMPEG2Dec::skipped_macroblock(int dc_dct_pred[3], int PMV[2][2][2], int *motion_type,
01573 int motion_vertical_field_select[2][2], int *macroblock_type)
01574 {
01575 Clear_Block(block_count);
01576
01577
01578
01579 dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
01580
01581
01582
01583 if (picture_coding_type==P_TYPE)
01584 PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
01585
01586
01587 if (picture_structure==FRAME_PICTURE)
01588 *motion_type = MC_FRAME;
01589 else
01590 {
01591 *motion_type = MC_FIELD;
01592 motion_vertical_field_select[0][0] = motion_vertical_field_select[0][1] =
01593 (picture_structure==BOTTOM_FIELD);
01594 }
01595
01596
01597 *macroblock_type&= ~MACROBLOCK_INTRA;
01598 }
01599
01600
01601
01602
01603 int CMPEG2Dec::start_of_slice(int *MBA, int *MBAinc,
01604 int dc_dct_pred[3], int PMV[2][2][2])
01605 {
01606 unsigned int code;
01607 int slice_vert_pos_ext;
01608
01609 next_start_code();
01610 code = Get_Bits(32);
01611
01612 if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
01613 {
01614
01615 Fault_Flag = 10;
01616 return -1;
01617 }
01618
01619
01620 slice_vert_pos_ext = slice_header();
01621
01622
01623 *MBAinc = Get_macroblock_address_increment();
01624 if (Fault_Flag) return -1;
01625
01626
01627
01628
01629 *MBA = ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + *MBAinc - 1;
01630 *MBAinc = 1;
01631
01632
01633
01634 dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
01635
01636
01637 PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
01638 PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
01639
01640
01641 return 1;
01642 }
01643
01644
01645 int CMPEG2Dec::decode_macroblock(int *macroblock_type, int *motion_type, int *dct_type,
01646 int PMV[2][2][2], int dc_dct_pred[3],
01647 int motion_vertical_field_select[2][2], int dmvector[2])
01648 {
01649 int quantizer_scale_code, comp, motion_vector_count, mv_format;
01650 int dmv, mvscale, coded_block_pattern;
01651
01652
01653 macroblock_modes(macroblock_type, motion_type, &motion_vector_count, &mv_format,
01654 &dmv, &mvscale, dct_type);
01655 if (Fault_Flag) return 0;
01656
01657 if (*macroblock_type & MACROBLOCK_QUANT)
01658 {
01659 quantizer_scale_code = Get_Bits(5);
01660
01661
01662 quantizer_scale = q_scale_type ?
01663 Non_Linear_quantizer_scale[quantizer_scale_code] : (quantizer_scale_code << 1);
01664 }
01665
01666
01667
01668 if ((*macroblock_type & MACROBLOCK_MOTION_FORWARD)
01669 || ((*macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors))
01670 motion_vectors(PMV, dmvector, motion_vertical_field_select, 0,
01671 motion_vector_count, mv_format, f_code[0][0]-1, f_code[0][1]-1, dmv, mvscale);
01672 if (Fault_Flag) return 0;
01673
01674
01675 if (*macroblock_type & MACROBLOCK_MOTION_BACKWARD)
01676 motion_vectors(PMV, dmvector, motion_vertical_field_select, 1,
01677 motion_vector_count,mv_format, f_code[1][0]-1, f_code[1][1]-1, 0, mvscale);
01678 if (Fault_Flag) return 0;
01679
01680 if ((*macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
01681 Flush_Buffer(1);
01682
01683
01684
01685 if (*macroblock_type & MACROBLOCK_PATTERN)
01686 {
01687 coded_block_pattern = Get_coded_block_pattern();
01688
01689 if (chroma_format==CHROMA422)
01690 coded_block_pattern = (coded_block_pattern<<2) | Get_Bits(2);
01691 else if (chroma_format==CHROMA444)
01692 coded_block_pattern = (coded_block_pattern<<6) | Get_Bits(6);
01693 }
01694 else
01695 coded_block_pattern = (*macroblock_type & MACROBLOCK_INTRA) ? (1<<block_count)-1 : 0;
01696
01697 if (Fault_Flag) return 0;
01698
01699 Clear_Block(block_count);
01700
01701
01702 for (comp=0; comp<block_count; comp++)
01703 {
01704 if (coded_block_pattern & (1<<(block_count-1-comp)))
01705 {
01706 if (*macroblock_type & MACROBLOCK_INTRA)
01707 Decode_MPEG2_Intra_Block(comp, dc_dct_pred);
01708 else
01709 Decode_MPEG2_Non_Intra_Block(comp);
01710 if (Fault_Flag) return 0;
01711 }
01712 }
01713
01714
01715
01716 if (!(*macroblock_type & MACROBLOCK_INTRA))
01717 dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
01718
01719
01720 if ((*macroblock_type & MACROBLOCK_INTRA) && !concealment_motion_vectors)
01721 {
01722
01723
01724 PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
01725 PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
01726 }
01727
01728
01729
01730 if ((picture_coding_type==P_TYPE)
01731 && !(*macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_INTRA)))
01732 {
01733
01734
01735 PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
01736
01737
01738
01739 if (picture_structure==FRAME_PICTURE)
01740 *motion_type = MC_FRAME;
01741 else
01742 {
01743 *motion_type = MC_FIELD;
01744 motion_vertical_field_select[0][0] = (picture_structure==BOTTOM_FIELD);
01745 }
01746 }
01747
01748 return 1 ;
01749 }
01750
01751
01752 void CMPEG2Dec::Decode_MPEG2_Intra_Block(int comp, int dc_dct_pred[])
01753 {
01754 int val, i, j, sign, *qmat;
01755 unsigned int code;
01756 DCTtab *tab;
01757 short *bp;
01758
01759 bp = block[comp];
01760 qmat = (comp<4 || chroma_format==CHROMA420)
01761 ? intra_quantizer_matrix : chroma_intra_quantizer_matrix;
01762
01763
01764 switch (cc_table[comp])
01765 {
01766 case 0:
01767 val = (dc_dct_pred[0]+= Get_Luma_DC_dct_diff());
01768 break;
01769
01770 case 1:
01771 val = (dc_dct_pred[1]+= Get_Chroma_DC_dct_diff());
01772 break;
01773
01774 case 2:
01775 val = (dc_dct_pred[2]+= Get_Chroma_DC_dct_diff());
01776 break;
01777 }
01778
01779 bp[0] = val << (3-intra_dc_precision);
01780
01781
01782 for (i=1; ; i++)
01783 {
01784 code = Show_Bits(16);
01785
01786 if (code>=16384 && !intra_vlc_format)
01787 tab = &DCTtabnext[(code>>12)-4];
01788 else if (code>=1024)
01789 {
01790 if (intra_vlc_format)
01791 tab = &DCTtab0a[(code>>8)-4];
01792 else
01793 tab = &DCTtab0[(code>>8)-4];
01794 }
01795 else if (code>=512)
01796 {
01797 if (intra_vlc_format)
01798 tab = &DCTtab1a[(code>>6)-8];
01799 else
01800 tab = &DCTtab1[(code>>6)-8];
01801 }
01802 else if (code>=256)
01803 tab = &DCTtab2[(code>>4)-16];
01804 else if (code>=128)
01805 tab = &DCTtab3[(code>>3)-16];
01806 else if (code>=64)
01807 tab = &DCTtab4[(code>>2)-16];
01808 else if (code>=32)
01809 tab = &DCTtab5[(code>>1)-16];
01810 else if (code>=16)
01811 tab = &DCTtab6[code-16];
01812 else
01813 {
01814 Fault_Flag = 1;
01815 return;
01816 }
01817
01818 Flush_Buffer(tab->len);
01819
01820 if (tab->run<64)
01821 {
01822 i+= tab->run;
01823 val = tab->level;
01824 sign = Get_Bits(1);
01825 }
01826 else if (tab->run==64)
01827 return;
01828 else
01829 {
01830 i+= Get_Bits(6);
01831 val = Get_Bits(12);
01832
01833 if (sign = (val>=2048))
01834 val = 4096 - val;
01835 }
01836
01837 j = scan[alternate_scan][i];
01838
01839 val = (val * quantizer_scale * qmat[j]) >> 4;
01840 bp[j] = sign ? -val : val;
01841 }
01842 }
01843
01844
01845 void CMPEG2Dec::Decode_MPEG2_Non_Intra_Block(int comp)
01846 {
01847 int val, i, j, sign, *qmat;
01848 unsigned int code;
01849 DCTtab *tab;
01850 short *bp;
01851
01852 bp = block[comp];
01853 qmat = (comp<4 || chroma_format==CHROMA420)
01854 ? non_intra_quantizer_matrix : chroma_non_intra_quantizer_matrix;
01855
01856
01857 for (i=0; ; i++)
01858 {
01859 code = Show_Bits(16);
01860
01861 if (code>=16384)
01862 {
01863 if (i==0)
01864 tab = &DCTtabfirst[(code>>12)-4];
01865 else
01866 tab = &DCTtabnext[(code>>12)-4];
01867 }
01868 else if (code>=1024)
01869 tab = &DCTtab0[(code>>8)-4];
01870 else if (code>=512)
01871 tab = &DCTtab1[(code>>6)-8];
01872 else if (code>=256)
01873 tab = &DCTtab2[(code>>4)-16];
01874 else if (code>=128)
01875 tab = &DCTtab3[(code>>3)-16];
01876 else if (code>=64)
01877 tab = &DCTtab4[(code>>2)-16];
01878 else if (code>=32)
01879 tab = &DCTtab5[(code>>1)-16];
01880 else if (code>=16)
01881 tab = &DCTtab6[code-16];
01882 else
01883 {
01884 Fault_Flag = 1;
01885 return;
01886 }
01887
01888 Flush_Buffer(tab->len);
01889
01890 if (tab->run<64)
01891 {
01892 i+= tab->run;
01893 val = tab->level;
01894 sign = Get_Bits(1);
01895 }
01896 else if (tab->run==64)
01897 return;
01898 else
01899 {
01900 i+= Get_Bits(6);
01901 val = Get_Bits(12);
01902
01903 if (sign = (val>=2048))
01904 val = 4096 - val;
01905 }
01906
01907 j = scan[alternate_scan][i];
01908
01909 val = (((val<<1)+1) * quantizer_scale * qmat[j]) >> 5;
01910 bp[j] = sign ? -val : val;
01911 }
01912 }
01913
01914 int CMPEG2Dec::Get_macroblock_type()
01915 {
01916 int macroblock_type;
01917
01918 switch (picture_coding_type)
01919 {
01920 case I_TYPE:
01921 macroblock_type = Get_I_macroblock_type();
01922 break;
01923
01924 case P_TYPE:
01925 macroblock_type = Get_P_macroblock_type();
01926 break;
01927
01928 case B_TYPE:
01929 macroblock_type = Get_B_macroblock_type();
01930 break;
01931 }
01932
01933 return macroblock_type;
01934 }
01935
01936 int CMPEG2Dec::Get_I_macroblock_type()
01937 {
01938 if (Get_Bits(1))
01939 return 1;
01940
01941 if (!Get_Bits(1))
01942 Fault_Flag = 2;
01943
01944 return 17;
01945 }
01946
01947 int CMPEG2Dec::Get_P_macroblock_type()
01948 {
01949 int code;
01950
01951 if ((code = Show_Bits(6))>=8)
01952 {
01953 code >>= 3;
01954 Flush_Buffer(PMBtab0[code].len);
01955
01956 return PMBtab0[code].val;
01957 }
01958
01959 if (code==0)
01960 {
01961 Fault_Flag = 2;
01962 return 0;
01963 }
01964
01965 Flush_Buffer(PMBtab1[code].len);
01966
01967 return PMBtab1[code].val;
01968 }
01969
01970 int CMPEG2Dec::Get_B_macroblock_type()
01971 {
01972 int code;
01973
01974 if ((code = Show_Bits(6))>=8)
01975 {
01976 code >>= 2;
01977 Flush_Buffer(BMBtab0[code].len);
01978
01979 return BMBtab0[code].val;
01980 }
01981
01982 if (code==0)
01983 {
01984 Fault_Flag = 2;
01985 return 0;
01986 }
01987
01988 Flush_Buffer(BMBtab1[code].len);
01989
01990 return BMBtab1[code].val;
01991 }
01992
01993 int CMPEG2Dec::Get_coded_block_pattern()
01994 {
01995 int code;
01996
01997 if ((code = Show_Bits(9))>=128)
01998 {
01999 code >>= 4;
02000 Flush_Buffer(CBPtab0[code].len);
02001
02002 return CBPtab0[code].val;
02003 }
02004
02005 if (code>=8)
02006 {
02007 code >>= 1;
02008 Flush_Buffer(CBPtab1[code].len);
02009
02010 return CBPtab1[code].val;
02011 }
02012
02013 if (code<1)
02014 {
02015 Fault_Flag = 3;
02016 return 0;
02017 }
02018
02019 Flush_Buffer(CBPtab2[code].len);
02020
02021 return CBPtab2[code].val;
02022 }
02023
02024 int CMPEG2Dec::Get_macroblock_address_increment()
02025 {
02026 int code, val;
02027
02028 val = 0;
02029
02030 while ((code = Show_Bits(11))<24)
02031 {
02032 if (code!=15)
02033 {
02034 if (code==8)
02035 val+= 33;
02036 else
02037 {
02038 Fault_Flag = 4;
02039 return 1;
02040 }
02041 }
02042 Flush_Buffer(11);
02043 }
02044
02045
02046
02047 if (code>=1024)
02048 {
02049 Flush_Buffer(1);
02050 return val + 1;
02051 }
02052
02053
02054 if (code>=128)
02055 {
02056
02057 code >>= 6;
02058 Flush_Buffer(MBAtab1[code].len);
02059
02060 return val + MBAtab1[code].val;
02061 }
02062
02063
02064 code-= 24;
02065 Flush_Buffer(MBAtab2[code].len);
02066
02067 return val + MBAtab2[code].val;
02068 }
02069
02070
02071
02072
02073
02074
02075
02076
02077 int CMPEG2Dec::Get_Luma_DC_dct_diff()
02078 {
02079 int code, size, dct_diff;
02080
02081
02082 code = Show_Bits(5);
02083
02084 if (code<31)
02085 {
02086 size = DClumtab0[code].val;
02087 Flush_Buffer(DClumtab0[code].len);
02088 }
02089 else
02090 {
02091 code = Show_Bits(9) - 0x1f0;
02092 size = DClumtab1[code].val;
02093 Flush_Buffer(DClumtab1[code].len);
02094 }
02095
02096 if (size==0)
02097 dct_diff = 0;
02098 else
02099 {
02100 dct_diff = Get_Bits(size);
02101
02102 if ((dct_diff & (1<<(size-1)))==0)
02103 dct_diff-= (1<<size) - 1;
02104 }
02105
02106 return dct_diff;
02107 }
02108
02109 int CMPEG2Dec::Get_Chroma_DC_dct_diff()
02110 {
02111 int code, size, dct_diff;
02112
02113
02114 code = Show_Bits(5);
02115
02116 if (code<31)
02117 {
02118 size = DCchromtab0[code].val;
02119 Flush_Buffer(DCchromtab0[code].len);
02120 }
02121 else
02122 {
02123 code = Show_Bits(10) - 0x3e0;
02124 size = DCchromtab1[code].val;
02125 Flush_Buffer(DCchromtab1[code].len);
02126 }
02127
02128 if (size==0)
02129 dct_diff = 0;
02130 else
02131 {
02132 dct_diff = Get_Bits(size);
02133
02134 if ((dct_diff & (1<<(size-1)))==0)
02135 dct_diff-= (1<<size) - 1;
02136 }
02137
02138 return dct_diff;
02139 }
02140
02141
02142
02143
02144
02145
02146
02147
02148 void CMPEG2Dec::form_predictions(int bx, int by, int macroblock_type, int motion_type,
02149 int PMV[2][2][2], int motion_vertical_field_select[2][2],
02150 int dmvector[2])
02151 {
02152 int currentfield;
02153 unsigned char **predframe;
02154 int DMV[2][2];
02155 int stw;
02156
02157 stw = 0;
02158
02159 if ((macroblock_type & MACROBLOCK_MOTION_FORWARD) || (picture_coding_type==P_TYPE))
02160 {
02161 if (picture_structure==FRAME_PICTURE)
02162 {
02163 if ((motion_type==MC_FRAME) || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
02164 {
02165
02166
02167 form_prediction(forward_reference_frame, 0, current_frame, 0, Coded_Picture_Width,
02168 Coded_Picture_Width<<1, 16, 8, bx, by, PMV[0][0][0], PMV[0][0][1], stw);
02169
02170 form_prediction(forward_reference_frame, 1, current_frame, 1, Coded_Picture_Width,
02171 Coded_Picture_Width<<1, 16, 8, bx, by, PMV[0][0][0], PMV[0][0][1], stw);
02172 }
02173 else if (motion_type==MC_FIELD)
02174 {
02175
02176 form_prediction(forward_reference_frame, motion_vertical_field_select[0][0],
02177 current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
02178 bx, by>>1, PMV[0][0][0], PMV[0][0][1]>>1, stw);
02179
02180
02181 form_prediction(forward_reference_frame, motion_vertical_field_select[1][0],
02182 current_frame, 1, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
02183 bx, by>>1, PMV[1][0][0], PMV[1][0][1]>>1, stw);
02184 }
02185 else if (motion_type==MC_DMV)
02186 {
02187
02188 Dual_Prime_Arithmetic(DMV, dmvector, PMV[0][0][0], PMV[0][0][1]>>1);
02189
02190
02191 form_prediction(forward_reference_frame, 0, current_frame, 0,
02192 Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
02193 PMV[0][0][0], PMV[0][0][1]>>1, 0);
02194
02195
02196 form_prediction(forward_reference_frame, 1, current_frame, 0,
02197 Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
02198 DMV[0][0], DMV[0][1], 1);
02199
02200
02201 form_prediction(forward_reference_frame, 1, current_frame, 1,
02202 Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
02203 PMV[0][0][0], PMV[0][0][1]>>1, 0);
02204
02205
02206 form_prediction(forward_reference_frame, 0, current_frame, 1,
02207 Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by>>1,
02208 DMV[1][0], DMV[1][1], 1);
02209 }
02210 else
02211 Fault_Flag = 5;
02212 }
02213 else
02214 {
02215
02216 currentfield = (picture_structure==BOTTOM_FIELD);
02217
02218
02219 if (picture_coding_type==P_TYPE && Second_Field && currentfield!=motion_vertical_field_select[0][0])
02220 predframe = backward_reference_frame;
02221 else
02222 predframe = forward_reference_frame;
02223
02224 if ((motion_type==MC_FIELD) || !(macroblock_type & MACROBLOCK_MOTION_FORWARD))
02225 {
02226 form_prediction(predframe, motion_vertical_field_select[0][0], current_frame, 0,
02227 Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
02228 PMV[0][0][0], PMV[0][0][1], stw);
02229 }
02230 else if (motion_type==MC_16X8)
02231 {
02232 form_prediction(predframe, motion_vertical_field_select[0][0], current_frame, 0,
02233 Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by,
02234 PMV[0][0][0], PMV[0][0][1], stw);
02235
02236 if (picture_coding_type==P_TYPE && Second_Field && currentfield!=motion_vertical_field_select[1][0])
02237 predframe = backward_reference_frame;
02238 else
02239 predframe = forward_reference_frame;
02240
02241 form_prediction(predframe, motion_vertical_field_select[1][0], current_frame,
02242 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8, bx, by+8,
02243 PMV[1][0][0], PMV[1][0][1], stw);
02244 }
02245 else if (motion_type==MC_DMV)
02246 {
02247 if (Second_Field)
02248 predframe = backward_reference_frame;
02249 else
02250 predframe = forward_reference_frame;
02251
02252
02253 Dual_Prime_Arithmetic(DMV, dmvector, PMV[0][0][0], PMV[0][0][1]);
02254
02255
02256 form_prediction(forward_reference_frame, currentfield, current_frame, 0,
02257 Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
02258 PMV[0][0][0], PMV[0][0][1], 0);
02259
02260
02261 form_prediction(predframe, !currentfield, current_frame, 0,
02262 Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16, bx, by,
02263 DMV[0][0], DMV[0][1], 1);
02264 }
02265 else
02266 Fault_Flag = 5;
02267 }
02268
02269 stw = 1;
02270 }
02271
02272 if (macroblock_type & MACROBLOCK_MOTION_BACKWARD)
02273 {
02274 if (picture_structure==FRAME_PICTURE)
02275 {
02276 if (motion_type==MC_FRAME)
02277 {
02278
02279 form_prediction(backward_reference_frame, 0, current_frame, 0,
02280 Coded_Picture_Width, Coded_Picture_Width<<1, 16, 8, bx, by,
02281 PMV[0][1][0], PMV[0][1][1], stw);
02282
02283 form_prediction(backward_reference_frame, 1, current_frame, 1,
02284 Coded_Picture_Width, Coded_Picture_Width<<1, 16, 8, bx, by,
02285 PMV[0][1][0], PMV[0][1][1], stw);
02286 }
02287 else
02288 {
02289
02290 form_prediction(backward_reference_frame, motion_vertical_field_select[0][1],
02291 current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
02292 bx, by>>1, PMV[0][1][0], PMV[0][1][1]>>1, stw);
02293
02294
02295 form_prediction(backward_reference_frame, motion_vertical_field_select[1][1],
02296 current_frame, 1, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
02297 bx, by>>1, PMV[1][1][0], PMV[1][1][1]>>1, stw);
02298 }
02299 }
02300 else
02301 {
02302
02303 if (motion_type==MC_FIELD)
02304 {
02305
02306 form_prediction(backward_reference_frame, motion_vertical_field_select[0][1],
02307 current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 16,
02308 bx, by, PMV[0][1][0], PMV[0][1][1], stw);
02309 }
02310 else if (motion_type==MC_16X8)
02311 {
02312 form_prediction(backward_reference_frame, motion_vertical_field_select[0][1],
02313 current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
02314 bx, by, PMV[0][1][0], PMV[0][1][1], stw);
02315
02316 form_prediction(backward_reference_frame, motion_vertical_field_select[1][1],
02317 current_frame, 0, Coded_Picture_Width<<1, Coded_Picture_Width<<1, 16, 8,
02318 bx, by+8, PMV[1][1][0], PMV[1][1][1], stw);
02319 }
02320 else
02321 Fault_Flag = 5;
02322 }
02323 }
02324 }
02325
02326 void CMPEG2Dec::form_prediction(unsigned char *src[], int sfield, unsigned char *dst[],
02327 int dfield, int lx, int lx2, int w, int h, int x, int y,
02328 int dx, int dy, int average_flag)
02329 {
02330 form_component_prediction(src[0]+(sfield?lx2>>1:0), dst[0]+(dfield?lx2>>1:0),
02331 lx, lx2, w, h, x, y, dx, dy, average_flag);
02332
02333 if (chroma_format!=CHROMA444)
02334 {
02335 lx>>=1; lx2>>=1; w>>=1; x>>=1; dx/=2;
02336 }
02337
02338 if (chroma_format==CHROMA420)
02339 {
02340 h>>=1; y>>=1; dy/=2;
02341 }
02342
02343
02344 form_component_prediction(src[1]+(sfield?lx2>>1:0), dst[1]+(dfield?lx2>>1:0),
02345 lx, lx2, w, h, x, y, dx, dy, average_flag);
02346
02347
02348 form_component_prediction(src[2]+(sfield?lx2>>1:0), dst[2]+(dfield?lx2>>1:0),
02349 lx, lx2, w, h, x, y, dx, dy, average_flag);
02350 }
02351
02352
02353 void CMPEG2Dec::form_component_prediction(unsigned char *src, unsigned char *dst,
02354 int lx, int lx2, int w, int h, int x, int y,
02355 int dx, int dy, int average_flag)
02356 {
02357 static const __int64 mmmask_0001 = 0x0001000100010001;
02358 static const __int64 mmmask_0002 = 0x0002000200020002;
02359 static const __int64 mmmask_0003 = 0x0003000300030003;
02360 static const __int64 mmmask_0006 = 0x0006000600060006;
02361
02362 unsigned char *s = src + lx * (y + (dy>>1)) + x + (dx>>1);
02363 unsigned char *d = dst + lx * y + x;
02364 int flag = (average_flag<<2) + ((dx & 1)<<1) + (dy & 1);
02365
02366 switch (flag)
02367 {
02368 case 0:
02369
02370 __asm
02371 {
02372 mov eax, [s]
02373 mov ebx, [d]
02374 mov esi, 0x00
02375 mov edi, [h]
02376 mc0:
02377 movq mm1, [eax+esi]
02378 add esi, 0x08
02379 cmp esi, [w]
02380 movq [ebx+esi-8], mm1
02381 jl mc0
02382
02383 add eax, [lx2]
02384 add ebx, [lx2]
02385 dec edi
02386 mov esi, 0x00
02387 cmp edi, 0x00
02388 jg mc0
02389 }
02390 break;
02391
02392 case 1:
02393
02394 __asm
02395 {
02396 pxor mm0, mm0
02397 movq mm7, [mmmask_0001]
02398 mov eax, [s]
02399 mov ebx, [d]
02400 mov ecx, eax
02401 add ecx, [lx]
02402 mov esi, 0x00
02403 mov edi, [h]
02404 mc1:
02405 movq mm1, [eax+esi]
02406 movq mm2, [ecx+esi]
02407
02408 movq mm3, mm1
02409 movq mm4, mm2
02410
02411 punpcklbw mm1, mm0
02412 punpckhbw mm3, mm0
02413 punpcklbw mm2, mm0
02414 punpckhbw mm4, mm0
02415
02416 paddsw mm1, mm2
02417 paddsw mm3, mm4
02418
02419 paddsw mm1, mm7
02420 paddsw mm3, mm7
02421
02422 psrlw mm1, 1
02423 psrlw mm3, 1
02424
02425 packuswb mm1, mm0
02426 packuswb mm3, mm0
02427
02428 psllq mm3, 32
02429 por mm1, mm3
02430
02431 add esi, 0x08
02432 cmp esi, [w]
02433 movq [ebx+esi-8], mm1
02434 jl mc1
02435
02436 add eax, [lx2]
02437 add ebx, [lx2]
02438 add ecx, [lx2]
02439 dec edi
02440 mov esi, 0x00
02441 cmp edi, 0x00
02442 jg mc1
02443 }
02444 break;
02445
02446 case 2:
02447
02448 __asm
02449 {
02450 pxor mm0, mm0
02451 movq mm7, [mmmask_0001]
02452 mov eax, [s]
02453 mov ebx, [d]
02454 mov esi, 0x00
02455 mov edi, [h]
02456 mc2:
02457 movq mm1, [eax+esi]
02458 movq mm2, [eax+esi+1]
02459
02460 movq mm3, mm1
02461 movq mm4, mm2
02462
02463 punpcklbw mm1, mm0
02464 punpckhbw mm3, mm0
02465
02466 punpcklbw mm2, mm0
02467 punpckhbw mm4, mm0
02468
02469 paddsw mm1, mm2
02470 paddsw mm3, mm4
02471
02472 paddsw mm1, mm7
02473 paddsw mm3, mm7
02474
02475 psrlw mm1, 1
02476 psrlw mm3, 1
02477
02478 packuswb mm1, mm0
02479 packuswb mm3, mm0
02480
02481 psllq mm3, 32
02482 por mm1, mm3
02483
02484 add esi, 0x08
02485 cmp esi, [w]
02486 movq [ebx+esi-8], mm1
02487 jl mc2
02488
02489 add eax, [lx2]
02490 add ebx, [lx2]
02491 dec edi
02492 mov esi, 0x00
02493 cmp edi, 0x00
02494 jg mc2
02495 }
02496 break;
02497
02498 case 3:
02499
02500 __asm
02501 {
02502 pxor mm0, mm0
02503 movq mm7, [mmmask_0002]
02504 mov eax, [s]
02505 mov ebx, [d]
02506 mov ecx, eax
02507 add ecx, [lx]
02508 mov esi, 0x00
02509 mov edi, [h]
02510 mc3:
02511 movq mm1, [eax+esi]
02512 movq mm2, [eax+esi+1]
02513 movq mm3, mm1
02514 movq mm4, mm2
02515
02516 punpcklbw mm1, mm0
02517 punpckhbw mm3, mm0
02518
02519 punpcklbw mm2, mm0
02520 punpckhbw mm4, mm0
02521
02522 paddsw mm1, mm2
02523 paddsw mm3, mm4
02524
02525 movq mm5, [ecx+esi]
02526 paddsw mm1, mm7
02527
02528 movq mm6, [ecx+esi+1]
02529 paddsw mm3, mm7
02530
02531 movq mm2, mm5
02532 movq mm4, mm6
02533
02534 punpcklbw mm2, mm0
02535 punpckhbw mm5, mm0
02536
02537 punpcklbw mm4, mm0
02538 punpckhbw mm6, mm0
02539
02540 paddsw mm2, mm4
02541 paddsw mm5, mm6
02542
02543 paddsw mm1, mm2
02544 paddsw mm3, mm5
02545
02546 psrlw mm1, 2
02547 psrlw mm3, 2
02548
02549 packuswb mm1, mm0
02550 packuswb mm3, mm0
02551
02552 psllq mm3, 32
02553 por mm1, mm3
02554
02555 add esi, 0x08
02556 cmp esi, [w]
02557 movq [ebx+esi-8], mm1
02558 jl mc3
02559
02560 add eax, [lx2]
02561 add ebx, [lx2]
02562 add ecx, [lx2]
02563 dec edi
02564 mov esi, 0x00
02565 cmp edi, 0x00
02566 jg mc3
02567 }
02568 break;
02569
02570 case 4:
02571
02572 __asm
02573 {
02574 pxor mm0, mm0
02575 movq mm7, [mmmask_0001]
02576 mov eax, [s]
02577 mov ebx, [d]
02578 mov esi, 0x00
02579 mov edi, [h]
02580 mc4:
02581 movq mm1, [eax+esi]
02582 movq mm2, [ebx+esi]
02583 movq mm3, mm1
02584 movq mm4, mm2
02585
02586 punpcklbw mm1, mm0
02587 punpckhbw mm3, mm0
02588
02589 punpcklbw mm2, mm0
02590 punpckhbw mm4, mm0
02591
02592 paddsw mm1, mm2
02593 paddsw mm3, mm4
02594
02595 paddsw mm1, mm7
02596 paddsw mm3, mm7
02597
02598 psrlw mm1, 1
02599 psrlw mm3, 1
02600
02601 packuswb mm1, mm0
02602 packuswb mm3, mm0
02603
02604 psllq mm3, 32
02605 por mm1, mm3
02606
02607 add esi, 0x08
02608 cmp esi, [w]
02609 movq [ebx+esi-8], mm1
02610 jl mc4
02611
02612 add eax, [lx2]
02613 add ebx, [lx2]
02614 dec edi
02615 mov esi, 0x00
02616 cmp edi, 0x00
02617 jg mc4
02618 }
02619 break;
02620
02621 case 5:
02622
02623 __asm
02624 {
02625 pxor mm0, mm0
02626 movq mm7, [mmmask_0003]
02627 mov eax, [s]
02628 mov ebx, [d]
02629 mov ecx, eax
02630 add ecx, [lx]
02631 mov esi, 0x00
02632 mov edi, [h]
02633 mc5:
02634 movq mm1, [eax+esi]
02635 movq mm2, [ecx+esi]
02636 movq mm3, mm1
02637 movq mm4, mm2
02638
02639 punpcklbw mm1, mm0
02640 punpckhbw mm3, mm0
02641
02642 punpcklbw mm2, mm0
02643 punpckhbw mm4, mm0
02644
02645 paddsw mm1, mm2
02646 paddsw mm3, mm4
02647
02648 movq mm5, [ebx+esi]
02649
02650 paddsw mm1, mm7
02651 paddsw mm3, mm7
02652
02653 movq mm6, mm5
02654 punpcklbw mm5, mm0
02655 punpckhbw mm6, mm0
02656
02657 psllw mm5, 1
02658 psllw mm6, 1
02659
02660 paddsw mm1, mm5
02661 paddsw mm3, mm6
02662
02663 psrlw mm1, 2
02664 psrlw mm3, 2
02665
02666 packuswb mm1, mm0
02667 packuswb mm3, mm0
02668
02669 psllq mm3, 32
02670 por mm1, mm3
02671
02672 add esi, 0x08
02673 cmp esi, [w]
02674 movq [ebx+esi-8], mm1
02675 jl mc5
02676
02677 add eax, [lx2]
02678 add ebx, [lx2]
02679 add ecx, [lx2]
02680 dec edi
02681 mov esi, 0x00
02682 cmp edi, 0x00
02683 jg mc5
02684 }
02685 break;
02686
02687 case 6:
02688
02689 __asm
02690 {
02691 pxor mm0, mm0
02692 movq mm7, [mmmask_0003]
02693 mov eax, [s]
02694 mov ebx, [d]
02695 mov esi, 0x00
02696 mov edi, [h]
02697 mc6:
02698 movq mm1, [eax+esi]
02699 movq mm2, [eax+esi+1]
02700 movq mm3, mm1
02701 movq mm4, mm2
02702
02703 punpcklbw mm1, mm0
02704 punpckhbw mm3, mm0
02705
02706 punpcklbw mm2, mm0
02707 punpckhbw mm4, mm0
02708
02709 paddsw mm1, mm2
02710 paddsw mm3, mm4
02711
02712 movq mm5, [ebx+esi]
02713
02714 paddsw mm1, mm7
02715 paddsw mm3, mm7
02716
02717 movq mm6, mm5
02718 punpcklbw mm5, mm0
02719 punpckhbw mm6, mm0
02720
02721 psllw mm5, 1
02722 psllw mm6, 1
02723
02724 paddsw mm1, mm5
02725 paddsw mm3, mm6
02726
02727 psrlw mm1, 2
02728 psrlw mm3, 2
02729
02730 packuswb mm1, mm0
02731 packuswb mm3, mm0
02732
02733 psllq mm3, 32
02734 por mm1, mm3
02735
02736 add esi, 0x08
02737 cmp esi, [w]
02738 movq [ebx+esi-8], mm1
02739 jl mc6
02740
02741 add eax, [lx2]
02742 add ebx, [lx2]
02743 dec edi
02744 mov esi, 0x00
02745 cmp edi, 0x00
02746 jg mc6
02747 }
02748 break;
02749
02750 case 7:
02751
02752 __asm
02753 {
02754 pxor mm0, mm0
02755 movq mm7, [mmmask_0006]
02756 mov eax, [s]
02757 mov ebx, [d]
02758 mov ecx, eax
02759 add ecx, [lx]
02760 mov esi, 0x00
02761 mov edi, [h]
02762 mc7:
02763 movq mm1, [eax+esi]
02764 movq mm2, [eax+esi+1]
02765 movq mm3, mm1
02766 movq mm4, mm2
02767
02768 punpcklbw mm1, mm0
02769 punpckhbw mm3, mm0
02770
02771 punpcklbw mm2, mm0
02772 punpckhbw mm4, mm0
02773
02774 paddsw mm1, mm2
02775 paddsw mm3, mm4
02776
02777 movq mm5, [ecx+esi]
02778 paddsw mm1, mm7
02779
02780 movq mm6, [ecx+esi+1]
02781 paddsw mm3, mm7
02782
02783 movq mm2, mm5
02784 movq mm4, mm6
02785
02786 punpcklbw mm2, mm0
02787 punpckhbw mm5, mm0
02788
02789 punpcklbw mm4, mm0
02790 punpckhbw mm6, mm0
02791
02792 paddsw mm2, mm4
02793 paddsw mm5, mm6
02794
02795 paddsw mm1, mm2
02796 paddsw mm3, mm5
02797
02798 movq mm6, [ebx+esi]
02799
02800 movq mm4, mm6
02801 punpcklbw mm4, mm0
02802 punpckhbw mm6, mm0
02803
02804 psllw mm4, 2
02805 psllw mm6, 2
02806
02807 paddsw mm1, mm4
02808 paddsw mm3, mm6
02809
02810 psrlw mm1, 3
02811 psrlw mm3, 3
02812
02813 packuswb mm1, mm0
02814 packuswb mm3, mm0
02815
02816 psllq mm3, 32
02817 por mm1, mm3
02818
02819 add esi, 0x08
02820 cmp esi, [w]
02821 movq [ebx+esi-8], mm1
02822 jl mc7
02823
02824 add eax, [lx2]
02825 add ebx, [lx2]
02826 add ecx, [lx2]
02827 dec edi
02828 mov esi, 0x00
02829 cmp edi, 0x00
02830 jg mc7
02831 }
02832 break;
02833 }
02834 }
02835
02836
02837
02838
02839
02840
02841 void CMPEG2Dec::motion_vectors(int PMV[2][2][2],int dmvector[2],
02842 int motion_vertical_field_select[2][2], int s,
02843 int motion_vector_count, int mv_format, int h_r_size,
02844 int v_r_size, int dmv, int mvscale)
02845 {
02846 if (motion_vector_count==1)
02847 {
02848 if (mv_format==MV_FIELD && !dmv)
02849 motion_vertical_field_select[1][s] =
02850 motion_vertical_field_select[0][s] = Get_Bits(1);
02851
02852 motion_vector(PMV[0][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);
02853
02854
02855 PMV[1][s][0] = PMV[0][s][0];
02856 PMV[1][s][1] = PMV[0][s][1];
02857 }
02858 else
02859 {
02860 motion_vertical_field_select[0][s] = Get_Bits(1);
02861 motion_vector(PMV[0][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);
02862 motion_vertical_field_select[1][s] = Get_Bits(1);
02863 motion_vector(PMV[1][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);
02864 }
02865 }
02866
02867
02868
02869 void CMPEG2Dec::Dual_Prime_Arithmetic(int DMV[][2],int *dmvector, int mvx,int mvy)
02870 {
02871 if (picture_structure==FRAME_PICTURE)
02872 {
02873 if (top_field_first)
02874 {
02875
02876 DMV[0][0] = ((mvx +(mvx>0))>>1) + dmvector[0];
02877 DMV[0][1] = ((mvy +(mvy>0))>>1) + dmvector[1] - 1;
02878
02879
02880 DMV[1][0] = ((3*mvx+(mvx>0))>>1) + dmvector[0];
02881 DMV[1][1] = ((3*mvy+(mvy>0))>>1) + dmvector[1] + 1;
02882 }
02883 else
02884 {
02885
02886 DMV[0][0] = ((3*mvx+(mvx>0))>>1) + dmvector[0];
02887 DMV[0][1] = ((3*mvy+(mvy>0))>>1) + dmvector[1] - 1;
02888
02889
02890 DMV[1][0] = ((mvx +(mvx>0))>>1) + dmvector[0];
02891 DMV[1][1] = ((mvy +(mvy>0))>>1) + dmvector[1] + 1;
02892 }
02893 }
02894 else
02895 {
02896
02897 DMV[0][0] = ((mvx+(mvx>0))>>1) + dmvector[0];
02898 DMV[0][1] = ((mvy+(mvy>0))>>1) + dmvector[1];
02899
02900
02901 if (picture_structure==TOP_FIELD)
02902 DMV[0][1]--;
02903 else
02904 DMV[0][1]++;
02905 }
02906 }
02907
02908
02909 void CMPEG2Dec::motion_vector(int *PMV, int *dmvector, int h_r_size, int v_r_size,
02910 int dmv, int mvscale, int full_pel_vector)
02911 {
02912 int motion_code, motion_residual;
02913
02914
02915
02916 motion_code = Get_motion_code();
02917
02918 motion_residual = (h_r_size!=0 && motion_code!=0) ? Get_Bits(h_r_size) : 0;
02919
02920 decode_motion_vector(&PMV[0],h_r_size,motion_code,motion_residual,full_pel_vector);
02921
02922 if (dmv)
02923 dmvector[0] = Get_dmvector();
02924
02925
02926 motion_code = Get_motion_code();
02927 motion_residual = (v_r_size!=0 && motion_code!=0) ? Get_Bits(v_r_size) : 0;
02928
02929 if (mvscale)
02930 PMV[1] >>= 1;
02931
02932 decode_motion_vector(&PMV[1],v_r_size,motion_code,motion_residual,full_pel_vector);
02933
02934 if (mvscale)
02935 PMV[1] <<= 1;
02936
02937 if (dmv)
02938 dmvector[1] = Get_dmvector();
02939 }
02940
02941
02942
02943
02944
02945 void CMPEG2Dec::decode_motion_vector(int *pred, int r_size, int motion_code,
02946 int motion_residual, int full_pel_vector)
02947 {
02948 int lim, vec;
02949
02950 lim = 16<<r_size;
02951 vec = full_pel_vector ? (*pred >> 1) : (*pred);
02952
02953 if (motion_code>0)
02954 {
02955 vec+= ((motion_code-1)<<r_size) + motion_residual + 1;
02956 if (vec>=lim)
02957 vec-= lim + lim;
02958 }
02959 else if (motion_code<0)
02960 {
02961 vec-= ((-motion_code-1)<<r_size) + motion_residual + 1;
02962 if (vec<-lim)
02963 vec+= lim + lim;
02964 }
02965
02966 *pred = full_pel_vector ? (vec<<1) : vec;
02967 }
02968
02969 int CMPEG2Dec::Get_motion_code()
02970 {
02971 int code;
02972
02973 if (Get_Bits(1))
02974 return 0;
02975
02976 if ((code = Show_Bits(9))>=64)
02977 {
02978 code >>= 6;
02979 Flush_Buffer(MVtab0[code].len);
02980
02981 return Get_Bits(1)?-MVtab0[code].val:MVtab0[code].val;
02982 }
02983
02984 if (code>=24)
02985 {
02986 code >>= 3;
02987 Flush_Buffer(MVtab1[code].len);
02988
02989 return Get_Bits(1)?-MVtab1[code].val:MVtab1[code].val;
02990 }
02991
02992 if ((code-=12)<0)
02993 {
02994 Fault_Flag = 10;
02995 return 0;
02996 }
02997
02998 Flush_Buffer(MVtab2[code].len);
02999
03000 return Get_Bits(1) ? -MVtab2[code].val : MVtab2[code].val;
03001 }
03002
03003
03004 int CMPEG2Dec::Get_dmvector()
03005 {
03006 if (Get_Bits(1))
03007 return Get_Bits(1) ? -1 : 1;
03008 else
03009 return 0;
03010 }
03011
03012
03013
03014
03015
03016 static const __int64 mmmask_0001 = 0x0001000100010001;
03017 static const __int64 mmmask_0002 = 0x0002000200020002;
03018 static const __int64 mmmask_0003 = 0x0003000300030003;
03019 static const __int64 mmmask_0004 = 0x0004000400040004;
03020 static const __int64 mmmask_0005 = 0x0005000500050005;
03021 static const __int64 mmmask_0007 = 0x0007000700070007;
03022 static const __int64 mmmask_0016 = 0x0010001000100010;
03023 static const __int64 mmmask_0040 = 0x0040004000400040;
03024 static const __int64 mmmask_0128 = 0x0080008000800080;
03025
03026 void CMPEG2Dec::assembleFrame(unsigned char *src[], int pf, unsigned char *dst, int pitch)
03027 {
03028 unsigned char *y444;
03029
03030 if (Fault_Flag)
03031 Fault_Flag = 0;
03032
03033 if (Luminance_Flag)
03034 {
03035 Luminance_Filter(src[0], lum);
03036 y444 = lum;
03037 }
03038 else
03039 y444 = src[0];
03040
03041 if (chroma_format==CHROMA420)
03042 {
03043 conv420to422(src[1], u422, pf);
03044 conv420to422(src[2], v422, pf);
03045
03046 if (!dstYUY2())
03047 {
03048 conv422to444(u422, u444);
03049 conv422to444(v422, v444);
03050 }
03051 }
03052 else if (!dstYUY2())
03053 {
03054 conv422to444(src[1], u444);
03055 conv422to444(src[2], v444);
03056 }
03057
03058 if (dstYUY2())
03059 conv422toYUY2(y444, u422, v422, dst, pitch);
03060 else
03061 conv444toRGB24(y444, u444, v444, dst, pitch);
03062 }
03063
03064 void CMPEG2Dec::Luminance_Filter(unsigned char *src, unsigned char *dst)
03065 {
03066 src += CLIP_AREA;
03067 dst += CLIP_AREA;
03068
03069 __asm
03070 {
03071 mov edx, this
03072 mov eax, [src]
03073 mov ebx, [dst]
03074 mov esi, 0x00
03075 mov edi, [edx].LUM_AREA
03076 pxor mm0, mm0
03077 movq mm5, [edx].LumOffsetMask
03078 movq mm6, [edx].LumGainMask
03079 movq mm7, mmmask_0040
03080
03081 lumconv:
03082 movq mm1, [eax+esi]
03083 movq mm2, mm1
03084
03085 punpcklbw mm1, mm0
03086 punpckhbw mm2, mm0
03087
03088 pmullw mm1, mm6
03089 pmullw mm2, mm6
03090
03091 paddw mm1, mm7
03092 paddw mm2, mm7
03093
03094 psrlw mm1, 7
03095 psrlw mm2, 7
03096
03097 paddw mm1, mm5
03098 paddw mm2, mm5
03099
03100 packuswb mm1, mm0
03101 packuswb mm2, mm0
03102
03103 add esi, 0x08
03104 cmp esi, edi
03105 movq [ebx+esi-8], mm1
03106 movq [ebx+esi-4], mm2
03107 jl lumconv
03108 }
03109 }
03110
03111 void CMPEG2Dec::conv422to444(unsigned char *src, unsigned char *dst)
03112 {
03113 src += HALF_CLIP_AREA;
03114 dst += CLIP_AREA;
03115
03116 __asm
03117 {
03118 mov edx, this
03119 mov eax, [src]
03120 mov ebx, [dst]
03121 mov edi, [edx].Clip_Height
03122
03123 movq mm1, [mmmask_0001]
03124 pxor mm0, mm0
03125
03126 convyuv444init:
03127 movq mm7, [eax]
03128 mov esi, 0x00
03129
03130 convyuv444:
03131 movq mm2, mm7
03132 movq mm7, [eax+esi+8]
03133 movq mm3, mm2
03134 movq mm4, mm7
03135
03136 psrlq mm3, 8
03137 psllq mm4, 56
03138 por mm3, mm4
03139
03140 movq mm4, mm2
03141 movq mm5, mm3
03142
03143 punpcklbw mm4, mm0
03144 punpcklbw mm5, mm0
03145
03146 movq mm6, mm4
03147 paddusw mm4, mm1
03148 paddusw mm4, mm5
03149 psrlw mm4, 1
03150 psllq mm4, 8
03151 por mm4, mm6
03152
03153 punpckhbw mm2, mm0
03154 punpckhbw mm3, mm0
03155
03156 movq mm6, mm2
03157 paddusw mm2, mm1
03158 paddusw mm2, mm3
03159
03160 movq [ebx+esi*2], mm4
03161
03162 psrlw mm2, 1
03163 psllq mm2, 8
03164 por mm2, mm6
03165
03166 add esi, 0x08
03167 cmp esi, [edx].HALF_WIDTH_D8
03168 movq [ebx+esi*2-8], mm2
03169 jl convyuv444
03170
03171 movq mm2, mm7
03172 punpcklbw mm2, mm0
03173 movq mm3, mm2
03174
03175 psllq mm2, 8
03176 por mm2, mm3
03177
03178 movq [ebx+esi*2], mm2
03179
03180 punpckhbw mm7, mm0
03181 movq mm6, mm7
03182
03183 psllq mm6, 8
03184 por mm6, mm7
03185
03186 movq [ebx+esi*2+8], mm6
03187
03188 add eax, [edx].HALF_WIDTH
03189 add ebx, [edx].Coded_Picture_Width
03190 dec edi
03191 cmp edi, 0x00
03192 jg convyuv444init
03193 }
03194 }
03195
03196 void CMPEG2Dec::conv420to422(unsigned char *src, unsigned char *dst, int frame_type)
03197 {
03198 if (frame_type)
03199 {
03200 __asm
03201 {
03202 push ebp
03203 mov eax, [src]
03204 mov ebx, [dst]
03205 mov ebp, this
03206 mov ecx, ebx
03207 add ecx, ds:[ebp].HALF_WIDTH
03208 mov esi, 0x00
03209 movq mm3, [mmmask_0003]
03210 pxor mm0, mm0
03211 movq mm4, [mmmask_0002]
03212
03213 mov edx, eax
03214 add edx, ds:[ebp].HALF_WIDTH
03215 convyuv422topp:
03216 movd mm1, [eax+esi]
03217 movd mm2, [edx+esi]
03218 movd [ebx+esi], mm1
03219 punpcklbw mm1, mm0
03220 pmullw mm1, mm3
03221 paddusw mm1, mm4
03222 punpcklbw mm2, mm0
03223 paddusw mm2, mm1
03224 psrlw mm2, 0x02
03225 packuswb mm2, mm0
03226
03227 add esi, 0x04
03228 cmp esi, ds:[ebp].HALF_WIDTH
03229 movd [ecx+esi-4], mm2
03230 jl convyuv422topp
03231
03232 add eax, ds:[ebp].HALF_WIDTH
03233 add ebx, ds:[ebp].Coded_Picture_Width
03234 add ecx, ds:[ebp].Coded_Picture_Width
03235 mov esi, 0x00
03236
03237 mov edi, ds:[ebp].PROGRESSIVE_HEIGHT
03238 convyuv422p:
03239 movd mm1, [eax+esi]
03240
03241 punpcklbw mm1, mm0
03242 mov edx, eax
03243
03244 pmullw mm1, mm3
03245 sub edx, ds:[ebp].HALF_WIDTH
03246
03247 movd mm5, [edx+esi]
03248 movd mm2, [edx+esi]
03249
03250 punpcklbw mm5, mm0
03251 punpcklbw mm2, mm0
03252 paddusw mm5, mm1
03253 paddusw mm2, mm1
03254 paddusw mm5, mm4
03255 paddusw mm2, mm4
03256 psrlw mm5, 0x02
03257 psrlw mm2, 0x02
03258 packuswb mm5, mm0
03259 packuswb mm2, mm0
03260
03261 mov edx, eax
03262 add edx, ds:[ebp].HALF_WIDTH
03263 add esi, 0x04
03264 cmp esi, ds:[ebp].HALF_WIDTH
03265 movd [ebx+esi-4], mm5
03266 movd [ecx+esi-4], mm2
03267
03268 jl convyuv422p
03269
03270 add eax, ds:[ebp].HALF_WIDTH
03271 add ebx, ds:[ebp].Coded_Picture_Width
03272 add ecx, ds:[ebp].Coded_Picture_Width
03273 mov esi, 0x00
03274 dec edi
03275 cmp edi, 0x00
03276 jg convyuv422p
03277
03278 mov edx, eax
03279 sub edx, ds:[ebp].HALF_WIDTH
03280 convyuv422bottomp:
03281 movd mm1, [eax+esi]
03282 movd mm5, [edx+esi]
03283 punpcklbw mm5, mm0
03284 movd [ecx+esi], mm1
03285
03286 punpcklbw mm1, mm0
03287 pmullw mm1, mm3
03288 paddusw mm5, mm1
03289 paddusw mm5, mm4
03290 psrlw mm5, 0x02
03291 packuswb mm5, mm0
03292
03293 add esi, 0x04
03294 cmp esi, ds:[ebp].HALF_WIDTH
03295 movd [ebx+esi-4], mm5
03296 jl convyuv422bottomp
03297 pop ebp
03298 }
03299 }
03300 else
03301 {
03302 __asm
03303 {
03304 push ebp
03305 mov eax, [src]
03306 mov ecx, [dst]
03307 mov ebp, this
03308 mov esi, 0x00
03309 pxor mm0, mm0
03310 movq mm3, [mmmask_0003]
03311 movq mm4, [mmmask_0004]
03312 movq mm5, [mmmask_0005]
03313
03314 convyuv422topi:
03315 movd mm1, [eax+esi]
03316 mov ebx, eax
03317 add ebx, ds:[ebp].HALF_WIDTH
03318 movd mm2, [ebx+esi]
03319 movd [ecx+esi], mm1
03320 punpcklbw mm1, mm0
03321 movq mm6, mm1
03322 pmullw mm1, mm3
03323
03324 punpcklbw mm2, mm0
03325 movq mm7, mm2
03326 pmullw mm2, mm5
03327 paddusw mm2, mm1
03328 paddusw mm2, mm4
03329 psrlw mm2, 0x03
03330 packuswb mm2, mm0
03331
03332 mov edx, ecx
03333 add edx, ds:[ebp].HALF_WIDTH
03334 pmullw mm6, mm5
03335 movd [edx+esi], mm2
03336
03337 add ebx, ds:[ebp].HALF_WIDTH
03338 movd mm2, [ebx+esi]
03339 punpcklbw mm2, mm0
03340 pmullw mm2, mm3
03341 paddusw mm2, mm6
03342 paddusw mm2, mm4
03343 psrlw mm2, 0x03
03344 packuswb mm2, mm0
03345
03346 add edx, ds:[ebp].HALF_WIDTH
03347 add ebx, ds:[ebp].HALF_WIDTH
03348 pmullw mm7, [mmmask_0007]
03349 movd [edx+esi], mm2
03350
03351 movd mm2, [ebx+esi]
03352 punpcklbw mm2, mm0
03353 paddusw mm2, mm7
03354 paddusw mm2, mm4
03355 psrlw mm2, 0x03
03356 packuswb mm2, mm0
03357
03358 add edx, ds:[ebp].HALF_WIDTH
03359 add esi, 0x04
03360 cmp esi, ds:[ebp].HALF_WIDTH
03361 movd [edx+esi-4], mm2
03362
03363 jl convyuv422topi
03364
03365 add eax, ds:[ebp].Coded_Picture_Width
03366 add ecx, ds:[ebp].DOUBLE_WIDTH
03367 mov esi, 0x00
03368
03369 mov edi, ds:[ebp].INTERLACED_HEIGHT
03370 convyuv422i:
03371 movd mm1, [eax+esi]
03372 punpcklbw mm1, mm0
03373 movq mm6, mm1
03374 mov ebx, eax
03375 sub ebx, ds:[ebp].Coded_Picture_Width
03376 movd mm3, [ebx+esi]
03377 pmullw mm1, [mmmask_0007]
03378 punpcklbw mm3, mm0
03379 paddusw mm3, mm1
03380 paddusw mm3, mm4
03381 psrlw mm3, 0x03
03382 packuswb mm3, mm0
03383
03384 add ebx, ds:[ebp].HALF_WIDTH
03385 movq mm1, [ebx+esi]
03386 add ebx, ds:[ebp].Coded_Picture_Width
03387 movd [ecx+esi], mm3
03388
03389 movq mm3, [mmmask_0003]
03390 movd mm2, [ebx+esi]
03391
03392 punpcklbw mm1, mm0
03393 pmullw mm1, mm3
03394 punpcklbw mm2, mm0
03395 movq mm7, mm2
03396 pmullw mm2, mm5
03397 paddusw mm2, mm1
03398 paddusw mm2, mm4
03399 psrlw mm2, 0x03
03400 packuswb mm2, mm0
03401
03402 pmullw mm6, mm5
03403 mov edx, ecx
03404 add edx, ds:[ebp].HALF_WIDTH
03405 movd [edx+esi], mm2
03406
03407 add ebx, ds:[ebp].HALF_WIDTH
03408 movd mm2, [ebx+esi]
03409 punpcklbw mm2, mm0
03410 pmullw mm2, mm3
03411 paddusw mm2, mm6
03412 paddusw mm2, mm4
03413 psrlw mm2, 0x03
03414 packuswb mm2, mm0
03415
03416 pmullw mm7, [mmmask_0007]
03417 add edx, ds:[ebp].HALF_WIDTH
03418 add ebx, ds:[ebp].HALF_WIDTH
03419 movd [edx+esi], mm2
03420
03421 movd mm2, [ebx+esi]
03422 punpcklbw mm2, mm0
03423 paddusw mm2, mm7
03424 paddusw mm2, mm4
03425 psrlw mm2, 0x03
03426 packuswb mm2, mm0
03427
03428 add edx, ds:[ebp].HALF_WIDTH
03429 add esi, 0x04
03430 cmp esi, ds:[ebp].HALF_WIDTH
03431 movd [edx+esi-4], mm2
03432
03433 jl convyuv422i
03434 add eax, ds:[ebp].Coded_Picture_Width
03435 add ecx, ds:[ebp].DOUBLE_WIDTH
03436 mov esi, 0x00
03437 dec edi
03438 cmp edi, 0x00
03439 jg convyuv422i
03440
03441 convyuv422bottomi:
03442 movd mm1, [eax+esi]
03443 movq mm6, mm1
03444 punpcklbw mm1, mm0
03445 mov ebx, eax
03446 sub ebx, ds:[ebp].Coded_Picture_Width
03447 movd mm3, [ebx+esi]
03448 punpcklbw mm3, mm0
03449 pmullw mm1, [mmmask_0007]
03450 paddusw mm3, mm1
03451 paddusw mm3, mm4
03452 psrlw mm3, 0x03
03453 packuswb mm3, mm0
03454
03455 add ebx, ds:[ebp].HALF_WIDTH
03456 movq mm1, [ebx+esi]
03457 punpcklbw mm1, mm0
03458 movd [ecx+esi], mm3
03459
03460 pmullw mm1, [mmmask_0003]
03461 add ebx, ds:[ebp].Coded_Picture_Width
03462 movd mm2, [ebx+esi]
03463 punpcklbw mm2, mm0
03464 movq mm7, mm2
03465 pmullw mm2, mm5
03466 paddusw mm2, mm1
03467 paddusw mm2, mm4
03468 psrlw mm2, 0x03
03469 packuswb mm2, mm0
03470
03471 mov edx, ecx
03472 add edx, ds:[ebp].HALF_WIDTH
03473 pmullw mm7, [mmmask_0007]
03474 movd [edx+esi], mm2
03475
03476 add edx, ds:[ebp].HALF_WIDTH
03477 movd [edx+esi], mm6
03478
03479 punpcklbw mm6, mm0
03480 paddusw mm6, mm7
03481 paddusw mm6, mm4
03482 psrlw mm6, 0x03
03483 packuswb mm6, mm0
03484
03485 add edx, ds:[ebp].HALF_WIDTH
03486 add esi, 0x04
03487 cmp esi, ds:[ebp].HALF_WIDTH
03488 movd [edx+esi-4], mm6
03489
03490 jl convyuv422bottomi
03491 pop ebp
03492 }
03493 }
03494 }
03495
03496 void CMPEG2Dec::conv444toRGB24(unsigned char *py, unsigned char *pu, unsigned char *pv, unsigned char *dst, int pitch)
03497 {
03498 int PWIDTH = pitch - DSTBYTES;
03499
03500 py += CLIP_STEP;
03501 pu += CLIP_STEP;
03502 pv += CLIP_STEP;
03503
03504 int Clip_Height = this->Clip_Height;
03505 __int64 RGB_Offset = this->RGB_Offset;
03506 __int64 RGB_Scale = this->RGB_Scale;
03507 __int64 RGB_CBU = this->RGB_CBU;
03508 __int64 RGB_CRV = this->RGB_CRV;
03509 __int64 RGB_CGX = this->RGB_CGX;
03510 int Clip_Width = this->Clip_Width;
03511 int Coded_Picture_Width = this->Coded_Picture_Width;
03512
03513 __asm
03514 {
03515 mov eax, [py]
03516 mov ebx, [pu]
03517 mov ecx, [pv]
03518 mov edx, [dst]
03519 mov edi, Clip_Height
03520 mov esi, 0x00
03521 pxor mm0, mm0
03522
03523 convRGB24:
03524 movd mm1, [eax+esi]
03525 movd mm3, [ebx+esi]
03526 punpcklbw mm1, mm0
03527 punpcklbw mm3, mm0
03528 movd mm5, [ecx+esi]
03529 punpcklbw mm5, mm0
03530 movq mm7, [mmmask_0128]
03531 psubw mm3, mm7
03532 psubw mm5, mm7
03533
03534 psubw mm1, RGB_Offset
03535 movq mm2, mm1
03536 movq mm7, [mmmask_0001]
03537 punpcklwd mm1, mm7
03538 punpckhwd mm2, mm7
03539 movq mm7, RGB_Scale
03540 pmaddwd mm1, mm7
03541 pmaddwd mm2, mm7
03542
03543 movq mm4, mm3
03544 punpcklwd mm3, mm0
03545 punpckhwd mm4, mm0
03546 movq mm7, RGB_CBU
03547 pmaddwd mm3, mm7
03548 pmaddwd mm4, mm7
03549 paddd mm3, mm1
03550 paddd mm4, mm2
03551 psrld mm3, 13
03552 psrld mm4, 13
03553 packuswb mm3, mm0
03554 packuswb mm4, mm0
03555
03556 movq mm6, mm5
03557 punpcklwd mm5, mm0
03558 punpckhwd mm6, mm0
03559 movq mm7, RGB_CRV
03560 pmaddwd mm5, mm7
03561 pmaddwd mm6, mm7
03562 paddd mm5, mm1
03563 paddd mm6, mm2
03564 psrld mm5, 13
03565 psrld mm6, 13
03566 packuswb mm5, mm0
03567 packuswb mm6, mm0
03568
03569 punpcklbw mm3, mm5
03570 punpcklbw mm4, mm6
03571 movq mm5, mm3
03572 movq mm6, mm4
03573 psrlq mm5, 16
03574 psrlq mm6, 16
03575 por mm3, mm5
03576 por mm4, mm6
03577
03578 movd mm5, [ebx+esi]
03579 movd mm6, [ecx+esi]
03580 punpcklbw mm5, mm0
03581 punpcklbw mm6, mm0
03582 movq mm7, [mmmask_0128]
03583 psubw mm5, mm7
03584 psubw mm6, mm7
03585
03586 movq mm7, mm6
03587 punpcklwd mm6, mm5
03588 punpckhwd mm7, mm5
03589 movq mm5, RGB_CGX
03590 pmaddwd mm6, mm5
03591 pmaddwd mm7, mm5
03592 paddd mm6, mm1
03593 paddd mm7, mm2
03594
03595 psrld mm6, 13
03596 psrld mm7, 13
03597 packuswb mm6, mm0
03598 packuswb mm7, mm0
03599
03600 punpcklbw mm3, mm6
03601 punpcklbw mm4, mm7
03602
03603 movq mm1, mm3
03604 movq mm5, mm4
03605 movq mm6, mm4
03606
03607 psrlq mm1, 32
03608 psllq mm1, 24
03609 por mm1, mm3
03610
03611 psrlq mm3, 40
03612 psllq mm6, 16
03613 por mm3, mm6
03614 movd [edx], mm1
03615
03616 psrld mm4, 16
03617 psrlq mm5, 24
03618 por mm5, mm4
03619 movd [edx+4], mm3
03620
03621 add edx, 0x0c
03622 add esi, 0x04
03623 cmp esi, Clip_Width
03624 movd [edx-4], mm5
03625
03626 jl convRGB24
03627
03628 add eax, Coded_Picture_Width
03629 add ebx, Coded_Picture_Width
03630 add ecx, Coded_Picture_Width
03631 add edx, PWIDTH
03632 mov esi, 0x00
03633 dec edi
03634 cmp edi, 0x00
03635 jg convRGB24
03636
03637 emms
03638 }
03639 }
03640
03641
03642
03643 void CMPEG2Dec::conv422toYUY2(unsigned char *py, unsigned char *pu, unsigned char *pv, unsigned char *dst, int pitch)
03644 {
03645 py += CLIP_STEP;
03646 pu += CLIP_STEP;
03647 pv += CLIP_STEP;
03648
03649 int y = this->Clip_Height;
03650 int Clip_Width_2 = this->Clip_Width / 2;
03651 int Coded_Picture_Width = this->Coded_Picture_Width;
03652 int Coded_Picture_Width_2 = this->Coded_Picture_Width / 2;
03653
03654 __asm
03655 {
03656 emms
03657 mov eax, [py]
03658 mov ebx, [pu]
03659 mov ecx, [pv]
03660 mov edx, [dst]
03661 mov edi, Clip_Width_2
03662 yloop:
03663 xor esi, esi
03664 xloop:
03665 movd mm1, [eax+esi*2] ;0000YYYY
03666 movd mm2, [ebx+esi] ;0000UUUU
03667 movd mm3, [ecx+esi] ;0000VVVV
03668 ;interleave this to VYUYVYUY
03669 punpcklbw mm2, mm3 ;VUVUVUVU
03670 punpcklbw mm1, mm2 ;VYUYVYUY
03671 movq [edx+esi*4], mm1
03672 movd mm1, [eax+esi*2+4] ;0000YYYY
03673 punpckhdq mm2, mm2 ;xxxxVUVU
03674 punpcklbw mm1, mm2 ;VYUYVYUY
03675 movq [edx+esi*4+8], mm1
03676 add esi, 4
03677 cmp esi, edi
03678 jb xloop
03679 add edx, pitch
03680 add eax, Coded_Picture_Width
03681 add ebx, Coded_Picture_Width_2
03682 add ecx, Coded_Picture_Width_2
03683 dec y
03684 jnz yloop
03685 emms
03686 }
03687 }
03688
03689
03690
03691
03692
03693 static const int ChromaFormat[4] = {
03694 0, 6, 8, 12
03695 };
03696
03697 CMPEG2Dec::CMPEG2Dec()
03698 {
03699 VF_File = 0;
03700 VF_FrameLimit = VF_FrameBound = VF_GOPLimit = VF_GOPNow = VF_GOPSize =
03701 VF_OldFrame = VF_OldRef = 0;
03702 VF_FrameSize = VF_FrameRate = 0;
03703 memset(Rdbfr, 0, sizeof(Rdbfr));
03704 Rdptr = Rdmax = 0;
03705 CurrentBfr = NextBfr = BitsLeft = Val = Read = 0;
03706 Fault_Flag = File_Flag = File_Limit = FO_Flag = IDCT_Flag = SystemStream_Flag = 0;
03707 Luminance_Flag = Resize_Flag = KeyOp_Flag = lfsr0 = lfsr1 = 0;
03708 BufferOp = 0;
03709 memset(intra_quantizer_matrix, 0, sizeof(intra_quantizer_matrix));
03710 memset(non_intra_quantizer_matrix, 0, sizeof(non_intra_quantizer_matrix));
03711 memset(chroma_intra_quantizer_matrix, 0, sizeof(chroma_intra_quantizer_matrix));
03712 memset(chroma_non_intra_quantizer_matrix, 0, sizeof(chroma_non_intra_quantizer_matrix));
03713 load_intra_quantizer_matrix =
03714 load_non_intra_quantizer_matrix =
03715 load_chroma_intra_quantizer_matrix =
03716 load_chroma_non_intra_quantizer_matrix = 0;
03717 q_scale_type =
03718 alternate_scan =
03719 quantizer_scale = 0;
03720
03721 int i;
03722 for (i=0; i<MAX_FILE_NUMBER; i++) Infilename[i] = NULL;
03723 for (i=0; i<8; i++) p_block[i] = block[i] = NULL;
03724 p_fTempArray = fTempArray = NULL;
03725 for (i=0; i<3; i++) backward_reference_frame[i] = forward_reference_frame[i] = auxframe[i] = NULL;
03726 lum = NULL;
03727 u422 = v422 = u444 = v444 = dstFrame = NULL;
03728 hLibrary = NULL;
03729
03730 CheckCPU();
03731 }
03732
03733 static char* myfgets(char* buff, int len, FILE* file)
03734 {
03735 char* ret = buff;
03736
03737 ret[0] = 0;
03738
03739 while(ret = fgets(buff, len, file))
03740 {
03741 while(isspace(*ret)) ret++;
03742 if(*ret) break;
03743 }
03744
03745 return(ret);
03746 }
03747
03748 int CMPEG2Dec::Open(const char *path, DstFormat dstFormat)
03749 {
03750 m_dstFormat = dstFormat;
03751 char ID[19], PASS[19] = "DVD2AVIProjectFile";
03752 DWORD i, j, size, code, type, tff, rff, film, ntsc, gop, top, bottom, mapping;
03753 int repeat_on, repeat_off, repeat_init;
03754 int Clip_Top, Clip_Bottom, Clip_Left, Clip_Right, Squeeze_Width, Squeeze_Height;
03755
03756 HKEY key; DWORD value = REG_SZ; DWORD length = 256;
03757 char *ext, buffer[256];
03758
03759 CMPEG2Dec* out = this;
03760
03761 out->VF_File = fopen(path, "r");
03762 if (out->VF_File==NULL)
03763 return 0;
03764 if (fgets(ID, 19, out->VF_File)==NULL)
03765 return 0;
03766 if (strcmp(ID, PASS))
03767 return 0;
03768
03769
03770 if (RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\VFPlugin", 0, KEY_ALL_ACCESS, &key)==ERROR_SUCCESS)
03771 {
03772 RegQueryValueExA(key, "DVD2AVI", NULL, &value, (unsigned char*)buffer, &length);
03773
03774 ext = strrchr(buffer, '\\');
03775 sprintf(buffer + (int)(ext-buffer) + 1, "OpenDVD.dll");
03776 RegCloseKey(key);
03777 }
03778
03779 if ((hLibrary = LoadLibraryA(buffer)) != NULL)
03780 BufferOp = (PBufferOp) GetProcAddress(hLibrary, "BufferOp");
03781
03782 for (i=0; i<MAX_FILE_NUMBER; i++)
03783 Infilename[i] = new char[_MAX_PATH];
03784
03785 if(1 != fscanf(out->VF_File, "%d", &File_Limit))
03786 return 0;
03787
03788 i = File_Limit;
03789 while (i)
03790 {
03791 if(1 != fscanf(out->VF_File, "%d ", &j))
03792 return 0;
03793 fgets(Infilename[File_Limit-i], j+1, out->VF_File);
03794 if ((Infile[File_Limit-i] = _open(Infilename[File_Limit-i], _O_RDONLY | _O_BINARY))==-1)
03795 return 0;
03796 i--;
03797 }
03798
03799 if(3 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "\nStream_Type=%d,%X,%X\n", &SystemStream_Flag, &lfsr0, &lfsr1))
03800 return 0;
03801 if (lfsr0 || lfsr1)
03802 KeyOp_Flag = 1;
03803 else
03804 KeyOp_Flag = 0;
03805
03806 if(1 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "iDCT_Algorithm=%d\n", &IDCT_Flag))
03807 return 0;
03808
03809 switch (IDCT_Flag)
03810 {
03811 case IDCT_SSEMMX:
03812 if (!cpu.ssemmx)
03813 IDCT_Flag = IDCT_MMX;
03814 break;
03815
03816 case IDCT_FPU:
03817 Initialize_FPU_IDCT();
03818 break;
03819
03820 case IDCT_REF:
03821 Initialize_REF_IDCT();
03822 break;
03823 }
03824
03825 File_Flag = 0;
03826 _lseeki64(Infile[0], 0, SEEK_SET);
03827 Initialize_Buffer();
03828
03829 do
03830 {
03831 next_start_code();
03832 code = Get_Bits(32);
03833 }
03834 while (code!=SEQUENCE_HEADER_CODE);
03835
03836 sequence_header();
03837
03838 mb_width = (horizontal_size+15)/16;
03839 mb_height = progressive_sequence ? (vertical_size+15)/16 : 2*((vertical_size+31)/32);
03840
03841 Coded_Picture_Width = 16 * mb_width;
03842 Coded_Picture_Height = 16 * mb_height;
03843
03844 Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width : Coded_Picture_Width>>1;
03845 Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height : Coded_Picture_Height>>1;
03846
03847 block_count = ChromaFormat[chroma_format];
03848
03849 for (i=0; i<8; i++)
03850 {
03851 p_block[i] = (short *)new BYTE[sizeof(short)*64 + 64];
03852 block[i] = (short *)((long)p_block[i] + 64 - (long)p_block[i]%64);
03853 }
03854
03855 p_fTempArray = (void *)new BYTE[sizeof(float)*128 + 64];
03856 fTempArray = (void *)((long)p_fTempArray + 64 - (long)p_fTempArray%64);
03857
03858 for (i=0; i<3; i++)
03859 {
03860 if (i==0)
03861 size = Coded_Picture_Width * Coded_Picture_Height;
03862 else
03863 size = Chroma_Width * Chroma_Height;
03864
03865 backward_reference_frame[i] = new unsigned char[size];
03866 forward_reference_frame[i] = new unsigned char[size];
03867 auxframe[i] = new unsigned char[size];
03868 }
03869
03870 if(1 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "YUVRGB_Scale=%d\n", &i))
03871 return 0;
03872
03873 if (i)
03874 {
03875 RGB_Scale = 0x1000254310002543;
03876 RGB_Offset = 0x0010001000100010;
03877 RGB_CBU = 0x0000408D0000408D;
03878 RGB_CGX = 0xF377E5FCF377E5FC;
03879 RGB_CRV = 0x0000331300003313;
03880 }
03881 else
03882 {
03883 RGB_Scale = 0x1000200010002000;
03884 RGB_Offset = 0x0000000000000000;
03885 RGB_CBU = 0x000038B4000038B4;
03886 RGB_CGX = 0xF4FDE926F4FDE926;
03887 RGB_CRV = 0x00002CDD00002CDD;
03888 }
03889
03890 char* tmp = myfgets(buffer, sizeof(buffer), out->VF_File);
03891 if(2 != sscanf(tmp, "Luminance=%d,%d\n", &i, &j))
03892 {
03893 if(2 != sscanf(tmp, "Luminance_Filter=%d,%d\n", &i, &j))
03894 return 0;
03895 i=128; j=0;
03896 }
03897
03898 if (i==128 && j==0)
03899 Luminance_Flag = 0;
03900 else
03901 {
03902 Luminance_Flag = 1;
03903 LumGainMask = ((__int64)i<<48) + ((__int64)i<<32) + ((__int64)i<<16) + (__int64)i;
03904 LumOffsetMask = ((__int64)j<<48) + ((__int64)j<<32) + ((__int64)j<<16) + (__int64)j;
03905
03906 lum = new unsigned char[Coded_Picture_Width * Coded_Picture_Height];
03907 }
03908
03909 if(6 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "Picture_Size=%d,%d,%d,%d,%d,%d\n",
03910 &Clip_Top, &Clip_Bottom, &Clip_Left, &Clip_Right, &Squeeze_Width, &Squeeze_Height))
03911 return 0;
03912
03913 Resize_Flag = 0;
03914 Resize_Width = Clip_Width = Coded_Picture_Width;
03915 Resize_Height = Clip_Height = Coded_Picture_Height;
03916 CLIP_AREA = HALF_CLIP_AREA = CLIP_STEP = 0;
03917
03918 if (Clip_Top || Clip_Bottom || Clip_Left || Clip_Right)
03919 {
03920 Clip_Width -= Clip_Left+Clip_Right;
03921 Clip_Height -= Clip_Top+Clip_Bottom;
03922 Resize_Width = Clip_Width;
03923 Resize_Height = Clip_Height;
03924
03925 CLIP_AREA = Coded_Picture_Width * Clip_Top;
03926 HALF_CLIP_AREA = (Coded_Picture_Width>>1) * Clip_Top;
03927 CLIP_STEP = Coded_Picture_Width * Clip_Top + Clip_Left;
03928 }
03929
03930 if (Squeeze_Width || Squeeze_Height)
03931 {
03932 Resize_Flag = 1;
03933 Resize_Width -= Squeeze_Width;
03934 Resize_Height -= Squeeze_Height;
03935 }
03936
03937 DSTBYTES = Clip_Width * (dstRGB24() ? 3 : 2);
03938 DSTBYTES2 = DSTBYTES * 2;
03939 LUM_AREA = Coded_Picture_Width * Clip_Height;
03940 PROGRESSIVE_HEIGHT = (Coded_Picture_Height>>1) - 2;
03941 INTERLACED_HEIGHT = (Coded_Picture_Height>>2) - 2;
03942 HALF_WIDTH = Coded_Picture_Width>>1;
03943 HALF_WIDTH_D8 = (Coded_Picture_Width>>1) - 8;
03944 DOUBLE_WIDTH = Coded_Picture_Width<<1;
03945
03946 u422 = new unsigned char[Coded_Picture_Width * Coded_Picture_Height / 2];
03947 v422 = new unsigned char[Coded_Picture_Width * Coded_Picture_Height / 2];
03948 u444 = new unsigned char[Coded_Picture_Width * Coded_Picture_Height];
03949 v444 = new unsigned char[Coded_Picture_Width * Coded_Picture_Height];
03950 dstFrame = new unsigned char[Clip_Width * Clip_Height * 4];
03951
03952 if(1 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "Field_Operation=%d\n", &FO_Flag))
03953 return 0;
03954 if(1 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "Frame_Rate=%d\n", &(out->VF_FrameRate)))
03955 return 0;
03956 if(4 != sscanf(myfgets(buffer, sizeof(buffer), out->VF_File), "Location=%d,%X,%d,%X\n", &i, &j, &i, &j))
03957 return 0;
03958
03959 ntsc = film = top = bottom = gop = mapping = repeat_on = repeat_off = repeat_init = 0;
03960
03961 while (1 == fscanf(out->VF_File, "%d", &type) && type<9)
03962 {
03963 if (type==7)
03964 {
03965 GOPList[gop] = reinterpret_cast<GOPLIST*>(calloc(1, sizeof(GOPLIST)));
03966 GOPList[gop]->number = film;
03967 if(2 != fscanf(out->VF_File, "%d %X", &(GOPList[gop]->file), &j))
03968 break;
03969
03970 GOPList[gop]->position = (__int64)j*BUFFER_SIZE;
03971 gop ++;
03972
03973 if(1 != fscanf(out->VF_File, "%d", &j))
03974 break;
03975
03976 tff = j>>1;
03977 rff = j & 1;
03978 }
03979 else
03980 {
03981 tff = type>>1;
03982 rff = type & 1;
03983 }
03984
03985 if (!film)
03986 {
03987 if (tff)
03988 Field_Order = 1;
03989 else
03990 Field_Order = 0;
03991 }
03992
03993 if (FO_Flag==FO_FILM)
03994 {
03995 if (rff)
03996 repeat_on++;
03997 else
03998 repeat_off++;
03999
04000 if (repeat_init)
04001 {
04002 if (repeat_off-repeat_on == 5)
04003 {
04004 repeat_on = repeat_off = 0;
04005 }
04006 else
04007 {
04008 FrameList[mapping] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
04009 FrameList[mapping]->top = FrameList[mapping]->bottom = film;
04010 mapping ++;
04011 }
04012
04013 if (repeat_on-repeat_off == 5)
04014 {
04015 repeat_on = repeat_off = 0;
04016 FrameList[mapping] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
04017 FrameList[mapping]->top = FrameList[mapping]->bottom = film;
04018 mapping ++;
04019 }
04020 }
04021 else
04022 {
04023 if (repeat_off-repeat_on == 3)
04024 {
04025 repeat_on = repeat_off = 0;
04026 repeat_init = 1;
04027 }
04028 else
04029 {
04030 FrameList[mapping] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
04031 FrameList[mapping]->top = FrameList[mapping]->bottom = film;
04032 mapping ++;
04033 }
04034
04035 if (repeat_on-repeat_off == 3)
04036 {
04037 repeat_on = repeat_off = 0;
04038 repeat_init = 1;
04039
04040 FrameList[mapping] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
04041 FrameList[mapping]->top = FrameList[mapping]->bottom = film;
04042 mapping ++;
04043 }
04044 }
04045 }
04046 else
04047 {
04048 if (top)
04049 {
04050 FrameList[ntsc]->bottom = film;
04051 ntsc ++;
04052 FrameList[ntsc] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
04053 FrameList[ntsc]->top = film;
04054 }
04055 else if (bottom)
04056 {
04057 FrameList[ntsc]->top = film;
04058 ntsc ++;
04059 FrameList[ntsc] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
04060 FrameList[ntsc]->bottom = film;
04061 }
04062 else
04063 {
04064 FrameList[ntsc] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
04065 FrameList[ntsc]->top = film;
04066 FrameList[ntsc]->bottom = film;
04067 ntsc ++;
04068 }
04069
04070 if (rff)
04071 {
04072 if (!top && !bottom)
04073 FrameList[ntsc] = reinterpret_cast<FRAMELIST*>(calloc(1, sizeof(FRAMELIST)));
04074
04075 if (tff)
04076 {
04077 FrameList[ntsc]->top = film;
04078 top = 1;
04079 }
04080 else
04081 {
04082 FrameList[ntsc]->bottom = film;
04083 bottom = 1;
04084 }
04085
04086 if (top && bottom)
04087 {
04088 top = bottom = 0;
04089 ntsc ++;
04090 }
04091 }
04092 }
04093
04094 film ++;
04095 }
04096
04097 out->VF_FrameBound = film;
04098 film -= 2;
04099
04100 if (FO_Flag==FO_FILM)
04101 {
04102 while (FrameList[mapping-1]->top >= film)
04103 mapping --;
04104
04105 out->VF_FrameLimit = mapping;
04106 }
04107 else
04108 {
04109 if (FO_Flag==FO_SWAP)
04110 {
04111 Field_Order = !Field_Order;
04112
04113 if (Field_Order)
04114 for (i=0; i<ntsc-1; i++)
04115 FrameList[i]->bottom = FrameList[i+1]->bottom;
04116 else
04117 for (i=0; i<ntsc-1; i++)
04118 FrameList[i]->top = FrameList[i+1]->top;
04119 }
04120
04121 while ((FrameList[ntsc-1]->top >= film) || (FrameList[ntsc-1]->bottom >= film))
04122 ntsc --;
04123
04124 out->VF_FrameLimit = ntsc;
04125
04126 for (i=0; i<out->VF_FrameLimit-1; i++)
04127 if (FrameList[i]->top==FrameList[i+1]->top || FrameList[i]->top==FrameList[i+1]->bottom ||
04128 FrameList[i]->bottom==FrameList[i+1]->top || FrameList[i]->bottom==FrameList[i+1]->bottom)
04129 {
04130 FrameList[i]->forward = 1;
04131 FrameList[i+1]->backward = 1;
04132 }
04133 }
04134
04135 Full_Frame = 1;
04136 for (i=0; i<out->VF_FrameLimit; i++)
04137 if (FrameList[i]->top!=FrameList[i]->bottom)
04138 {
04139 Full_Frame = 0;
04140 break;
04141 }
04142
04143 out->VF_GOPNow = out->VF_GOPLimit = gop;
04144 out->VF_OldFrame = out->VF_FrameLimit;
04145 out->VF_FrameSize = Clip_Width * Clip_Height * 3;
04146
04147 return 1;
04148 }
04149
04150 void CMPEG2Dec::Decode(unsigned char *dst, DWORD frame, int pitch)
04151 {
04152 DWORD i, now, size, origin, ref, fo;
04153 int remain;
04154
04155 CMPEG2Dec* in = this;
04156
04157 if (FO_Flag==FO_FILM)
04158 {
04159 fo = 0;
04160 frame = FrameList[frame]->top;
04161 }
04162
04163 origin = frame;
04164
04165 if (FO_Flag!=FO_FILM)
04166 {
04167 if (FrameList[frame]->top == FrameList[frame]->bottom)
04168 {
04169 fo = 0;
04170 frame = FrameList[frame]->top;
04171 }
04172 else if (FrameList[frame]->top < FrameList[frame]->bottom)
04173 {
04174 fo = 1;
04175 frame = FrameList[frame]->top;
04176 }
04177 else
04178 {
04179 fo = 2;
04180 frame = FrameList[frame]->bottom;
04181 }
04182 }
04183
04184 ref = frame;
04185
04186 if (frame >= GOPList[in->VF_GOPLimit-1]->number)
04187 {
04188 now = in->VF_GOPLimit-1;
04189 ref -= GOPList[in->VF_GOPLimit-1]->number;
04190 size = in->VF_FrameBound - GOPList[in->VF_GOPLimit-1]->number + 1;
04191 }
04192 else
04193 for (now = 0; now < (in->VF_GOPLimit-1); now++)
04194 {
04195 if (frame>=GOPList[now]->number && frame<GOPList[now+1]->number)
04196 {
04197 ref -= GOPList[now]->number;
04198 size = GOPList[now+1]->number - GOPList[now]->number + 1;
04199 break;
04200 }
04201 }
04202
04203 if (fo)
04204 ref ++;
04205
04206 if (now != in->VF_GOPNow)
04207 {
04208 if ((in->VF_OldFrame + 1)==origin)
04209 {
04210 if (Full_Frame)
04211 {
04212 Get_Hdr();
04213 Decode_Picture(1, dst, pitch);
04214
04215 if (picture_structure!=FRAME_PICTURE)
04216 {
04217 Get_Hdr();
04218 Decode_Picture(1, dst, pitch);
04219 }
04220 }
04221 else
04222 switch (fo)
04223 {
04224 case 0:
04225 if (!FrameList[origin]->backward)
04226 {
04227 Get_Hdr();
04228 Decode_Picture(1, dst, pitch);
04229
04230 if (picture_structure!=FRAME_PICTURE)
04231 {
04232 Get_Hdr();
04233 Decode_Picture(1, dst, pitch);
04234 }
04235
04236 if (FrameList[origin]->forward)
04237 {
04238 if (Field_Order)
04239 Copyodd(dst, dstFrame, pitch, 1);
04240 else
04241 Copyeven(dst, dstFrame, pitch, 1);
04242 }
04243 }
04244 else
04245 {
04246 Copyodd(dstFrame, dst, pitch, 0);
04247 Copyeven(dstFrame, dst, pitch, 0);
04248 }
04249 break;
04250
04251 case 1:
04252 Copyodd(dstFrame, dst, pitch, 0);
04253
04254 Get_Hdr();
04255 Decode_Picture(1, dstFrame, DSTBYTES);
04256
04257 if (picture_structure!=FRAME_PICTURE)
04258 {
04259 Get_Hdr();
04260 Decode_Picture(1, dstFrame, DSTBYTES);
04261 }
04262
04263 Copyeven(dstFrame, dst, pitch, 0);
04264 break;
04265
04266 case 2:
04267 Copyeven(dstFrame, dst, pitch, 0);
04268
04269 Get_Hdr();
04270 Decode_Picture(1, dstFrame, DSTBYTES);
04271
04272 if (picture_structure!=FRAME_PICTURE)
04273 {
04274 Get_Hdr();
04275 Decode_Picture(1, dstFrame, DSTBYTES);
04276 }
04277
04278 Copyodd(dstFrame, dst, pitch, 0);
04279 break;
04280 }
04281
04282 if (in->VF_GOPSize)
04283 {
04284 for (i=0; i < in->VF_GOPSize; i++)
04285 free(GOPBuffer[i]);
04286
04287 in->VF_GOPSize = 0;
04288 }
04289
04290 in->VF_GOPNow = in->VF_GOPLimit;
04291 in->VF_OldFrame = origin;
04292 return;
04293 }
04294
04295 remain = ref;
04296 in->VF_OldRef = ref;
04297 in->VF_GOPNow = now;
04298 Second_Field = 0;
04299
04300 if (size < in->VF_GOPSize)
04301 for (i=0; i < (in->VF_GOPSize - size); i++)
04302 free(GOPBuffer[size+i]);
04303 else if (size > in->VF_GOPSize)
04304 for (i=0; i < (size - in->VF_GOPSize); i++)
04305 GOPBuffer[in->VF_GOPSize+i] = reinterpret_cast<unsigned char*>(malloc(in->VF_FrameSize));
04306
04307 in->VF_GOPSize = size;
04308
04309 File_Flag = GOPList[now]->file;
04310 _lseeki64(Infile[GOPList[now]->file], GOPList[now]->position, SEEK_SET);
04311 Initialize_Buffer();
04312
04313 while (Get_Hdr() && picture_coding_type!=I_TYPE);
04314
04315 Decode_Picture(0, dst, pitch);
04316
04317 while (Get_Hdr() && picture_coding_type==B_TYPE);
04318
04319 if (picture_structure!=FRAME_PICTURE)
04320 {
04321 Decode_Picture(0, dst, pitch);
04322 Get_Hdr();
04323 }
04324
04325 Decode_Picture(1, dst, pitch);
04326
04327 if (picture_structure!=FRAME_PICTURE)
04328 {
04329 Get_Hdr();
04330 Decode_Picture(1, dst, pitch);
04331 }
04332
04333 Copyodd(dst, GOPBuffer[0], pitch, 1);
04334 Copyeven(dst, GOPBuffer[0], pitch, 1);
04335
04336 while (remain && Get_Hdr())
04337 {
04338 Decode_Picture(1, dst, pitch);
04339
04340 if (picture_structure!=FRAME_PICTURE)
04341 {
04342 Get_Hdr();
04343 Decode_Picture(1, dst, pitch);
04344 }
04345
04346 Copyodd(dst, GOPBuffer[ref - remain + 1], pitch, 1);
04347 Copyeven(dst, GOPBuffer[ref - remain + 1], pitch, 1);
04348
04349 remain--;
04350 }
04351
04352 if (!Full_Frame && ref>=(size-2))
04353 {
04354 Copyodd(dst, dstFrame, pitch, 1);
04355 Copyeven(dst, dstFrame, pitch, 1);
04356 }
04357 }
04358 else
04359 {
04360 remain = ref - in->VF_OldRef;
04361
04362 if (remain > 0)
04363 {
04364 in->VF_OldRef = ref;
04365
04366 while (remain && Get_Hdr())
04367 {
04368 Decode_Picture(1, dst, pitch);
04369
04370 if (picture_structure!=FRAME_PICTURE)
04371 {
04372 Get_Hdr();
04373 Decode_Picture(1, dst, pitch);
04374 }
04375
04376 Copyodd(dst, GOPBuffer[ref - remain + 1], pitch, 1);
04377 Copyeven(dst, GOPBuffer[ref - remain + 1], pitch, 1);
04378
04379 remain--;
04380 }
04381
04382 if (!Full_Frame && ref>=(size-2))
04383 {
04384 Copyodd(dst, dstFrame, pitch, 1);
04385 Copyeven(dst, dstFrame, pitch, 1);
04386 }
04387 }
04388 }
04389
04390 switch (fo)
04391 {
04392 case 0:
04393 Copyodd(GOPBuffer[ref], dst, pitch, 0);
04394 Copyeven(GOPBuffer[ref], dst, pitch, 0);
04395 break;
04396
04397 case 1:
04398 Copyodd(GOPBuffer[ref-1], dst, pitch, 0);
04399 Copyeven(GOPBuffer[ref], dst, pitch, 0);
04400 break;
04401
04402 case 2:
04403 Copyodd(GOPBuffer[ref], dst, pitch, 0);
04404 Copyeven(GOPBuffer[ref-1], dst, pitch, 0);
04405 break;
04406 }
04407
04408 in->VF_OldFrame = origin;
04409 }
04410
04411 void CMPEG2Dec::Close()
04412 {
04413 int i;
04414
04415 for(i = 0; i < VF_GOPLimit; i++) free(GOPList[i]);
04416 for(i = 0; i < VF_FrameLimit; i++) free(FrameList[i]);
04417
04418 if (VF_File != NULL)
04419 fclose(VF_File);
04420
04421 while (VF_GOPSize)
04422 {
04423 VF_GOPSize--;
04424 free(GOPBuffer[VF_GOPSize]);
04425 }
04426
04427 while (File_Limit)
04428 {
04429 File_Limit--;
04430 _close(Infile[File_Limit]);
04431 }
04432
04433 for (i=0; i<MAX_FILE_NUMBER; i++)
04434 delete [] Infilename[i];
04435
04436 for (i=0; i<3; i++)
04437 {
04438 delete [] backward_reference_frame[i];
04439 delete [] forward_reference_frame[i];
04440 delete [] auxframe[i];
04441 }
04442
04443 delete [] u422;
04444 delete [] v422;
04445 delete [] u444;
04446 delete [] v444;
04447 delete [] dstFrame;
04448
04449 if(Luminance_Flag)
04450 delete [] lum;
04451
04452 for (i=0; i<8; i++)
04453 delete [] p_block[i];
04454
04455 delete [] p_fTempArray;
04456
04457 if (hLibrary)
04458 FreeLibrary(hLibrary);
04459 }
04460
04461 void CMPEG2Dec::Copyodd(unsigned char *src, unsigned char *dst, int pitch, int forward)
04462 {
04463 int i;
04464 int PWIDTH = forward ? (pitch<<1) : DSTBYTES2;
04465 int QWIDTH = forward ? DSTBYTES2 : (pitch<<1);
04466
04467 for (i=0; i<(Clip_Height>>1); i++)
04468 {
04469 memcpy (dst, src, DSTBYTES);
04470 src += PWIDTH;
04471 dst += QWIDTH;
04472 }
04473 }
04474
04475 void CMPEG2Dec::Copyeven(unsigned char *src, unsigned char *dst, int pitch, int forward)
04476 {
04477 int i;
04478 int PWIDTH = forward ? (pitch<<1) : DSTBYTES2;
04479 int QWIDTH = forward ? DSTBYTES2 : (pitch<<1);
04480 src += forward ? pitch : DSTBYTES;
04481 dst += forward ? DSTBYTES : pitch;
04482
04483 for (i=0; i<(Clip_Height>>1); i++)
04484 {
04485 memcpy (dst, src, DSTBYTES);
04486 src += PWIDTH;
04487 dst += QWIDTH;
04488 }
04489 }
