1 /* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18 #include "mp4def.h" 19 #include "mp4lib_int.h" 20 #include "mp4enc_lib.h" 21 #include "bitstream_io.h" 22 #include "m4venc_oscl.h" 23 24 PV_STATUS EncodeShortHeader(BitstreamEncVideo *stream, Vop *currVop); 25 PV_STATUS EncodeVOPHeader(BitstreamEncVideo *stream, Vol *currVol, Vop *currVop); 26 PV_STATUS EncodeGOVHeader(BitstreamEncVideo *stream, UInt seconds); 27 28 PV_STATUS EncodeVop_BXRC(VideoEncData *video); 29 PV_STATUS EncodeVop_NoME(VideoEncData *video); 30 31 /* ======================================================================== */ 32 /* Function : DecodeVop() */ 33 /* Date : 08/23/2000 */ 34 /* Purpose : Encode VOP Header */ 35 /* In/out : */ 36 /* Return : */ 37 /* Modified : */ 38 /* ======================================================================== */ 39 PV_STATUS EncodeVop(VideoEncData *video) 40 { 41 42 PV_STATUS status; 43 Int currLayer = video->currLayer; 44 Vol *currVol = video->vol[currLayer]; 45 Vop *currVop = video->currVop; 46 // BitstreamEncVideo *stream=video->bitstream1; 47 UChar *Mode = video->headerInfo.Mode; 48 rateControl **rc = video->rc; 49 // UInt time=0; 50 51 /*******************/ 52 /* Initialize mode */ 53 /*******************/ 54 55 switch (currVop->predictionType) 56 { 57 case I_VOP: 58 M4VENC_MEMSET(Mode, MODE_INTRA, sizeof(UChar)*currVol->nTotalMB); 59 break; 60 case P_VOP: 61 M4VENC_MEMSET(Mode, MODE_INTER, sizeof(UChar)*currVol->nTotalMB); 62 break; 63 case B_VOP: 64 /*M4VENC_MEMSET(Mode, MODE_INTER_B,sizeof(UChar)*nTotalMB);*/ 65 return PV_FAIL; 66 default: 67 return PV_FAIL; 68 } 69 70 /*********************/ 71 /* Motion Estimation */ 72 /* compute MVs, scene change detection, edge padding, */ 73 /* intra refresh, compute block activity */ 74 /*********************/ 75 MotionEstimation(video); /* do ME for the whole frame */ 76 77 /***************************/ 78 /* rate Control (assign QP) */ 79 /* 4/11/01, clean-up, and put into a separate function */ 80 /***************************/ 81 status = RC_VopQPSetting(video, rc); 82 if (status == PV_FAIL) 83 return PV_FAIL; 84 85 /**********************/ 86 /* Encode VOP */ 87 /**********************/ 88 if (video->slice_coding) /* end here */ 89 { 90 /* initialize state variable for slice-based APIs */ 91 video->totalSAD = 0; 92 video->mbnum = 0; 93 video->sliceNo[0] = 0; 94 video->numIntra = 0; 95 video->offset = 0; 96 video->end_of_buf = 0; 97 video->hp_guess = -1; 98 return status; 99 } 100 101 status = EncodeVop_NoME(video); 102 103 /******************************/ 104 /* rate control (update stat) */ 105 /* 6/2/01 separate function */ 106 /******************************/ 107 108 RC_VopUpdateStat(video, rc[currLayer]); 109 110 return status; 111 } 112 113 /* ======================================================================== */ 114 /* Function : EncodeVop_NoME() */ 115 /* Date : 08/28/2001 */ 116 /* History : */ 117 /* Purpose : EncodeVop without motion est. */ 118 /* In/out : */ 119 /* Return : */ 120 /* Modified : */ 121 /* */ 122 /* ======================================================================== */ 123 124 PV_STATUS EncodeVop_NoME(VideoEncData *video) 125 { 126 Vop *currVop = video->currVop; 127 Vol *currVol = video->vol[video->currLayer]; 128 BitstreamEncVideo *stream = video->bitstream1; 129 Int time = 0; /* follows EncodeVop value */ 130 PV_STATUS status = PV_SUCCESS; 131 132 if (currVol->shortVideoHeader) /* Short Video Header = 1 */ 133 { 134 135 status = EncodeShortHeader(stream, currVop); /* Encode Short Header */ 136 137 video->header_bits = BitstreamGetPos(stream); /* Header Bits */ 138 139 status = EncodeFrameCombinedMode(video); 140 141 } 142 #ifndef H263_ONLY 143 else /* Short Video Header = 0 */ 144 { 145 146 if (currVol->GOVStart && currVop->predictionType == I_VOP) 147 status = EncodeGOVHeader(stream, time); /* Encode GOV Header */ 148 149 status = EncodeVOPHeader(stream, currVol, currVop); /* Encode VOP Header */ 150 151 video->header_bits = BitstreamGetPos(stream); /* Header Bits */ 152 153 if (currVop->vopCoded) 154 { 155 if (!currVol->scalability) 156 { 157 if (currVol->dataPartitioning) 158 { 159 status = EncodeFrameDataPartMode(video); /* Encode Data Partitioning Mode VOP */ 160 } 161 else 162 { 163 status = EncodeFrameCombinedMode(video); /* Encode Combined Mode VOP */ 164 } 165 } 166 else 167 status = EncodeFrameCombinedMode(video); /* Encode Combined Mode VOP */ 168 } 169 else /* Vop Not coded */ 170 { 171 172 return status; 173 } 174 } 175 #endif /* H263_ONLY */ 176 return status; 177 178 } 179 180 #ifndef NO_SLICE_ENCODE 181 /* ======================================================================== */ 182 /* Function : EncodeSlice() */ 183 /* Date : 04/19/2002 */ 184 /* History : */ 185 /* Purpose : Encode one slice. */ 186 /* In/out : */ 187 /* Return : */ 188 /* Modified : */ 189 /* */ 190 /* ======================================================================== */ 191 192 PV_STATUS EncodeSlice(VideoEncData *video) 193 { 194 Vop *currVop = video->currVop; 195 Int currLayer = video->currLayer; 196 Vol *currVol = video->vol[currLayer]; 197 BitstreamEncVideo *stream = video->bitstream1; /* different from frame-based */ 198 Int time = 0; /* follows EncodeVop value */ 199 PV_STATUS status = PV_SUCCESS; 200 rateControl **rc = video->rc; 201 202 if (currVol->shortVideoHeader) /* Short Video Header = 1 */ 203 { 204 205 if (video->mbnum == 0) 206 { 207 status = EncodeShortHeader(stream, currVop); /* Encode Short Header */ 208 209 video->header_bits = BitstreamGetPos(stream); /* Header Bits */ 210 } 211 212 status = EncodeSliceCombinedMode(video); 213 214 } 215 #ifndef H263_ONLY 216 else /* Short Video Header = 0 */ 217 { 218 219 if (video->mbnum == 0) 220 { 221 if (currVol->GOVStart) 222 status = EncodeGOVHeader(stream, time); /* Encode GOV Header */ 223 224 status = EncodeVOPHeader(stream, currVol, currVop); /* Encode VOP Header */ 225 226 video->header_bits = BitstreamGetPos(stream); /* Header Bits */ 227 } 228 229 if (currVop->vopCoded) 230 { 231 if (!currVol->scalability) 232 { 233 if (currVol->dataPartitioning) 234 { 235 status = EncodeSliceDataPartMode(video); /* Encode Data Partitioning Mode VOP */ 236 } 237 else 238 { 239 status = EncodeSliceCombinedMode(video); /* Encode Combined Mode VOP */ 240 } 241 } 242 else 243 status = EncodeSliceCombinedMode(video); /* Encode Combined Mode VOP */ 244 } 245 else /* Vop Not coded */ 246 { 247 248 return status; 249 } 250 } 251 #endif /* H263_ONLY */ 252 if (video->mbnum >= currVol->nTotalMB && status != PV_END_OF_BUF) /* end of Vop */ 253 { 254 /******************************/ 255 /* rate control (update stat) */ 256 /* 6/2/01 separate function */ 257 /******************************/ 258 259 status = RC_VopUpdateStat(video, rc[currLayer]); 260 } 261 262 return status; 263 264 } 265 #endif /* NO_SLICE_ENCODE */ 266 267 #ifndef H263_ONLY 268 /* ======================================================================== */ 269 /* Function : EncodeGOVHeader() */ 270 /* Date : 08/23/2000 */ 271 /* Purpose : Encode GOV Header */ 272 /* In/out : */ 273 /* Return : */ 274 /* Modified : */ 275 /* ======================================================================== */ 276 PV_STATUS EncodeGOVHeader(BitstreamEncVideo *stream, UInt seconds) 277 { 278 PV_STATUS status; 279 // int temp; 280 UInt tmpvar; 281 282 /********************************/ 283 /* Group_of_VideoObjectPlane() */ 284 /********************************/ 285 286 status = BitstreamPutGT16Bits(stream, 32, GROUP_START_CODE); 287 /* time_code */ 288 tmpvar = seconds / 3600; 289 status = BitstreamPutBits(stream, 5, tmpvar); /* Hours*/ 290 291 tmpvar = (seconds - tmpvar * 3600) / 60; 292 status = BitstreamPutBits(stream, 6, tmpvar); /* Minutes*/ 293 294 status = BitstreamPut1Bits(stream, 1); /* Marker*/ 295 296 tmpvar = seconds % 60; 297 status = BitstreamPutBits(stream, 6, tmpvar); /* Seconds*/ 298 299 status = BitstreamPut1Bits(stream, 1); /* closed_gov */ 300 status = BitstreamPut1Bits(stream, 0); /* broken_link */ 301 /*temp =*/ 302 BitstreamMpeg4ByteAlignStuffing(stream); /* Byte align GOV Header */ 303 304 return status; 305 } 306 307 #ifdef ALLOW_VOP_NOT_CODED 308 309 PV_STATUS EncodeVopNotCoded(VideoEncData *video, UChar *bstream, Int *size, ULong modTime) 310 { 311 PV_STATUS status; 312 Vol *currVol = video->vol[0]; 313 Vop *currVop = video->currVop; 314 BitstreamEncVideo *stream = currVol->stream; 315 UInt frameTick; 316 Int timeInc; 317 318 stream->bitstreamBuffer = bstream; 319 stream->bufferSize = *size; 320 BitstreamEncReset(stream); 321 322 status = BitstreamPutGT16Bits(stream, 32, VOP_START_CODE); /*Start Code for VOP*/ 323 status = BitstreamPutBits(stream, 2, P_VOP);/* VOP Coding Type*/ 324 325 frameTick = (Int)(((double)(modTime - video->modTimeRef) * currVol->timeIncrementResolution + 500) / 1000); 326 timeInc = frameTick - video->refTick[0]; 327 while (timeInc >= currVol->timeIncrementResolution) 328 { 329 timeInc -= currVol->timeIncrementResolution; 330 status = BitstreamPut1Bits(stream, 1); 331 /* do not update refTick and modTimeRef yet, do it after encoding!! */ 332 } 333 status = BitstreamPut1Bits(stream, 0); 334 status = BitstreamPut1Bits(stream, 1); /* marker bit */ 335 status = BitstreamPutBits(stream, currVol->nbitsTimeIncRes, timeInc); /* vop_time_increment */ 336 status = BitstreamPut1Bits(stream, 1); /* marker bit */ 337 status = BitstreamPut1Bits(stream, 0); /* vop_coded bit */ 338 BitstreamMpeg4ByteAlignStuffing(stream); 339 340 return status; 341 } 342 #endif 343 344 /* ======================================================================== */ 345 /* Function : EncodeVOPHeader() */ 346 /* Date : 08/23/2000 */ 347 /* Purpose : Encode VOP Header */ 348 /* In/out : */ 349 /* Return : */ 350 /* Modified : */ 351 /* ======================================================================== */ 352 353 PV_STATUS EncodeVOPHeader(BitstreamEncVideo *stream, Vol *currVol, Vop *currVop) 354 { 355 PV_STATUS status; 356 //int temp; 357 358 int MTB = currVol->moduloTimeBase; 359 /************************/ 360 /* VideoObjectPlane() */ 361 /************************/ 362 363 status = BitstreamPutGT16Bits(stream, 32, VOP_START_CODE); /*Start Code for VOP*/ 364 status = BitstreamPutBits(stream, 2, currVop->predictionType);/* VOP Coding Type*/ 365 366 currVol->prevModuloTimeBase = currVol->moduloTimeBase; 367 368 while (MTB) 369 { 370 status = BitstreamPut1Bits(stream, 1); 371 MTB--; 372 } 373 status = BitstreamPut1Bits(stream, 0); 374 375 status = BitstreamPut1Bits(stream, 1); /* marker bit */ 376 status = BitstreamPutBits(stream, currVol->nbitsTimeIncRes, currVop->timeInc); /* vop_time_increment */ 377 status = BitstreamPut1Bits(stream, 1); /* marker bit */ 378 status = BitstreamPut1Bits(stream, currVop->vopCoded); /* vop_coded bit */ 379 if (currVop->vopCoded == 0) 380 { 381 /*temp =*/ 382 BitstreamMpeg4ByteAlignStuffing(stream); /* Byte align VOP Header */ 383 return status; 384 } 385 if (currVop->predictionType == P_VOP) 386 status = BitstreamPut1Bits(stream, currVop->roundingType); /* vop_rounding_type */ 387 388 status = BitstreamPutBits(stream, 3, currVop->intraDCVlcThr); /* intra_dc_vlc_thr */ 389 status = BitstreamPutBits(stream, 5, currVop->quantizer); /* vop_quant */ 390 391 if (currVop->predictionType != I_VOP) 392 status = BitstreamPutBits(stream, 3, currVop->fcodeForward); /* vop_fcode_forward */ 393 if (currVop->predictionType == B_VOP) 394 status = BitstreamPutBits(stream, 3, currVop->fcodeBackward);/* vop_fcode_backward */ 395 396 if (currVol->scalability) 397 /* enhancement_type = 0 */ 398 status = BitstreamPutBits(stream, 2, currVop->refSelectCode); /* ref_select_code */ 399 400 return status; 401 } 402 #endif /* H263_ONLY */ 403 /* ======================================================================== */ 404 /* Function : EncodeShortHeader() */ 405 /* Date : 08/23/2000 */ 406 /* Purpose : Encode VOP Header */ 407 /* In/out : */ 408 /* Return : */ 409 /* Modified : */ 410 /* ======================================================================== */ 411 412 PV_STATUS EncodeShortHeader(BitstreamEncVideo *stream, Vop *currVop) 413 { 414 415 PV_STATUS status; 416 417 status = BitstreamPutGT16Bits(stream, 22, SHORT_VIDEO_START_MARKER); /* Short_video_start_marker */ 418 status = BitstreamPutBits(stream, 8, currVop->temporalRef); /* temporal_reference */ 419 status = BitstreamPut1Bits(stream, 1); /* marker bit */ 420 status = BitstreamPut1Bits(stream, 0); /* zero bit */ 421 status = BitstreamPut1Bits(stream, 0); /* split_screen_indicator=0*/ 422 status = BitstreamPut1Bits(stream, 0); /* document_camera_indicator=0*/ 423 status = BitstreamPut1Bits(stream, 0); /* full_picture_freeze_release=0*/ 424 425 switch (currVop->width) 426 { 427 case 128: 428 if (currVop->height == 96) 429 status = BitstreamPutBits(stream, 3, 1); /* source_format = 1 */ 430 else 431 { 432 status = PV_FAIL; 433 return status; 434 } 435 break; 436 437 case 176: 438 if (currVop->height == 144) 439 status = BitstreamPutBits(stream, 3, 2); /* source_format = 2 */ 440 else 441 { 442 status = PV_FAIL; 443 return status; 444 } 445 break; 446 447 case 352: 448 if (currVop->height == 288) 449 status = BitstreamPutBits(stream, 3, 3); /* source_format = 3 */ 450 else 451 { 452 status = PV_FAIL; 453 return status; 454 } 455 break; 456 457 case 704: 458 if (currVop->height == 576) 459 status = BitstreamPutBits(stream, 3, 4); /* source_format = 4 */ 460 else 461 { 462 status = PV_FAIL; 463 return status; 464 } 465 break; 466 467 case 1408: 468 if (currVop->height == 1152) 469 status = BitstreamPutBits(stream, 3, 5); /* source_format = 5 */ 470 else 471 { 472 status = PV_FAIL; 473 return status; 474 } 475 break; 476 477 default: 478 status = PV_FAIL; 479 return status; 480 } 481 482 483 status = BitstreamPut1Bits(stream, currVop->predictionType); /* picture_coding type */ 484 status = BitstreamPutBits(stream, 4, 0); /* four_reserved_zero_bits */ 485 status = BitstreamPutBits(stream, 5, currVop->quantizer); /* vop_quant*/ 486 status = BitstreamPut1Bits(stream, 0); /* zero_bit*/ 487 status = BitstreamPut1Bits(stream, 0); /* pei=0 */ 488 489 return status; 490 } 491 492 #ifndef H263_ONLY 493 /* ======================================================================== */ 494 /* Function : EncodeVideoPacketHeader() */ 495 /* Date : 09/05/2000 */ 496 /* History : */ 497 /* Purpose : Encode a frame of MPEG4 bitstream in Combined mode. */ 498 /* In/out : */ 499 /* Return : */ 500 /* Modified : 04/25/2002 */ 501 /* Add bitstream structure as input argument */ 502 /* */ 503 /* ======================================================================== */ 504 PV_STATUS EncodeVideoPacketHeader(VideoEncData *video, int MB_number, 505 int quant_scale, Int insert) 506 { 507 // PV_STATUS status=PV_SUCCESS; 508 int fcode; 509 Vop *currVop = video->currVop; 510 Vol *currVol = video->vol[video->currLayer]; 511 BitstreamEncVideo *bs, tmp; 512 UChar buffer[30]; 513 514 if (insert) /* insert packet header to the beginning of bs1 */ 515 { 516 tmp.bitstreamBuffer = buffer; /* use temporary buffer */ 517 tmp.bufferSize = 30; 518 BitstreamEncReset(&tmp); 519 bs = &tmp; 520 } 521 else 522 bs = video->bitstream1; 523 524 525 if (currVop->predictionType == I_VOP) 526 BitstreamPutGT16Bits(bs, 17, 1); /* resync_marker I_VOP */ 527 else if (currVop->predictionType == P_VOP) 528 { 529 fcode = currVop->fcodeForward; 530 BitstreamPutGT16Bits(bs, 16 + fcode, 1); /* resync_marker P_VOP */ 531 532 } 533 else 534 { 535 fcode = currVop->fcodeForward; 536 if (currVop->fcodeBackward > fcode) 537 fcode = currVop->fcodeBackward; 538 BitstreamPutGT16Bits(bs, 16 + fcode, 1); /* resync_marker B_VOP */ 539 } 540 541 BitstreamPutBits(bs, currVol->nBitsForMBID, MB_number); /* resync_marker */ 542 BitstreamPutBits(bs, 5, quant_scale); /* quant_scale */ 543 BitstreamPut1Bits(bs, 0); /* header_extension_code = 0 */ 544 545 if (0) /* header_extension_code = 1 */ 546 { 547 /* NEED modulo_time_base code here ... default 0x01 belo*/ 548 /*status =*/ 549 BitstreamPut1Bits(bs, 1); 550 /*status = */ 551 BitstreamPut1Bits(bs, 0); 552 553 /*status = */ 554 BitstreamPut1Bits(bs, 1); /* marker bit */ 555 /*status = */ 556 BitstreamPutBits(bs, currVol->nbitsTimeIncRes, currVop->timeInc); /* vop_time_increment */ 557 /*status = */ 558 BitstreamPut1Bits(bs, 1); /* marker bit */ 559 560 /*status = */ 561 BitstreamPutBits(bs, 2, currVop->predictionType);/* VOP Coding Type*/ 562 563 /*status = */ 564 BitstreamPutBits(bs, 3, currVop->intraDCVlcThr); /* intra_dc_vlc_thr */ 565 566 if (currVop->predictionType != I_VOP) 567 /*status = */ BitstreamPutBits(bs, 3, currVop->fcodeForward); 568 if (currVop->predictionType == B_VOP) 569 /*status = */ BitstreamPutBits(bs, 3, currVop->fcodeBackward); 570 } 571 #ifndef NO_SLICE_ENCODE 572 if (insert) 573 BitstreamPrependPacket(video->bitstream1, bs); 574 #endif 575 return PV_SUCCESS; 576 } 577 578 #endif /* H263_ONLY */ 579 580 581 582
