PR/Applications/VSs/VSs__H264__App: 0b056460c67d libavcodec/h264

418 s->qp_thresh= 15 + 52 - FFMIN(s->slice_alpha_c0_offset, s->slice_beta_offset) - FFMAX3(0, s->pps.chroma_qp_index_offset[0], s->pps.chroma_qp_index_offset[1]);

419

420 return 0;

421 }

422

423 PictureInfo *get_pib_entry(NalContext *nc, int coded_pic_num){

424 PictureInfo *pic = NULL;

425

426 for(int i=0; i<MAX_REF_PIC_COUNT+1; i++){

427 if(nc->picture[i].reference==0){

428 pic= &nc->picture[i];

429 break;

430 }

431 }

432 pic->cpn = coded_pic_num;

433

434 return pic;

435 }

436

437 int decode_nal_units(NalContext *n, H264Slice *s, GetBitContext *gb1){

438 GetBitContext *gb = gb1;

439 uint8_t *buf = gb1->raw;

440 int buf_size = gb1->buf_size;

441 int next_avc = buf_size;

442 int buf_index=0;

443 uint8_t *dst=NULL;

444 // gb->raw = gb1->raw;

445 // gb->rbsp = NULL;

446 s->release_cnt=0;

447 ff_h264_reset_sei(n);

448

449 s->current_picture_info = get_pib_entry(n, n->coded_pic_num);

450

451 for(;;){

452 int consumed;

453 int dst_length;

454 int bit_length;

455 const uint8_t *ptr;

456 int err;

457

458 if (buf_index >= buf_size){

459 break;

460 } else {

461 // start code prefix search

462 for(; buf_index + 3 < buf_size; buf_index++){

463 // This should always succeed in the first iteration.

464 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)

465 break;

466 }

467 if(buf_index+3 >= buf_size) break;

468 buf_index+=3;

469 }

470

471 {

472 int length = next_avc - buf_index;

473 int i, si, di;

474 uint8_t *src= buf+buf_index;

475 // src[0]&0x80; //forbidden bit

476 s->nal_ref_idc= src[0]>>5;

477 s->nal_unit_type= src[0]&0x1F;

478

479 src++; length--;

480

481 for(i=0; i+1<length; i+=2){

482 if(src[i]) continue;

483 if(i>0 && src[i-1]==0) i--;

484 if(i+2<length && src[i+1]==0 && src[i+2]<=3){

485 if(src[i+2]!=3){

486 /* startcode, so we must be past the end */

487 length=i;

488 }

489 break;

490 }

491 }

492

493 if(i>=length-1){ //no escaped 0

494 dst_length= length;

495 consumed= length+1; //+1 for the header

496 ptr=src;

497 }else{

498 av_fast_malloc(&gb->rbsp, &gb->rbsp_size, length+FF_INPUT_BUFFER_PADDING_SIZE);

499 dst = gb->rbsp;

500 // if (dst){

501 // av_free(dst);

502 // }

503 // dst = av_malloc(length+FF_INPUT_BUFFER_PADDING_SIZE);

504

505 if (dst == NULL){

506 return -1;

507 }

508

509 //printf("decoding esc\n");

510 memcpy(dst, src, i);

511 si=di=i;

512 while(si+2<length){

513 //remove escapes (very rare 1:2^22)

514 if(src[si+2]>3){

515 dst[di++]= src[si++];

516 dst[di++]= src[si++];

517 }else if(src[si]==0 && src[si+1]==0){

518 if(src[si+2]==3){ //escape

519 dst[di++]= 0;

520 dst[di++]= 0;

521 si+=3;

522 continue;

523 }else //next start code

524 goto nsc;

525 }

526

527 dst[di++]= src[si++];

528 }

529 while(si<length)

530 dst[di++]= src[si++];

531 nsc:

532

533 memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);

534

535 dst_length= di;

536 consumed= si + 1;//+1 for the header

537 //FIXME store exact number of bits in the getbitcontext (it is needed for decoding)

538 ptr=dst;

539 // gb->rbsp=ptr;

540 }

541 }

542 if (ptr==NULL || dst_length < 0){

543 return -1;

544 }

545

546 //error prevention, should not touch dst_length

547 while(ptr[dst_length - 1] == 0 && dst_length > 0)

548 dst_length--;

549

550 bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(ptr + dst_length - 1));

551 buf_index += consumed;

552

553 err = 0;

554 init_get_bits(gb, ptr, bit_length);

555 switch(s->nal_unit_type){

556 case NAL_IDR_SLICE:

557 idr(n, s); //FIXME ensure we don't loose some frames if there is reordering

558 case NAL_SLICE:

559 if((err = decode_slice_header(n, s, gb)))

560 break;

561 s->key_frame |= (s->nal_unit_type == NAL_IDR_SLICE) || (n->sei_recovery_frame_cnt >= 0);

562 break;

563 case NAL_DPA:

564 case NAL_DPB:

565 case NAL_DPC:

566 av_log(AV_LOG_ERROR,"no slices/data partitioning support\n");

567 break;

568 case NAL_SEI:

569 ff_h264_decode_sei(n, gb);

570 break;

571 case NAL_SPS:

572 ff_h264_decode_seq_parameter_set(n, gb);

573 break;

574 case NAL_PPS:

575 ff_h264_decode_picture_parameter_set(n, gb, bit_length);

576 break;

577 case NAL_AUD:

578 case NAL_END_SEQUENCE:

579 case NAL_END_STREAM:

580 case NAL_FILLER_DATA:

581 case NAL_SPS_EXT:

582 case NAL_AUXILIARY_SLICE:

583 break;

584 default:

585 av_log(AV_LOG_ERROR, "Unknown NAL code: %d (%d bits)\n", s->nal_unit_type, bit_length);

586 }

587 if (err < 0)

588 av_log(AV_LOG_ERROR, "decode_slice_header error\n");

589

590 }

591

592 return buf_index;

593 }

594

595 NalContext *get_nal_context(int width, int height){

596 const int mb_height = (height + 15) / 16;

597 const int mb_width = (width + 15) / 16;

598 const int mb_stride = ((mb_width+1)/16 + 1) *16; //align mb_stride to 16

599

600 NalContext *nc = av_mallocz(sizeof(NalContext));

601 nc->width = width;

602 nc->height = height;

603 nc->mb_height = mb_height;

604 nc->mb_width = mb_width;

605 nc->b4_stride = mb_width*4 + 1;

606 nc->mb_stride = mb_stride;

607 nc->outputed_poc = INT_MIN;

608

609 for(int i=0; i<16; i++){

610 nc->picture[i].cpn =-1;

611 }

612

613 return nc;

614 }

615

616 void free_nal_context(NalContext *nc){

617 for(int i = 0; i < MAX_SPS_COUNT; i++){

618 if (nc->sps_buffers[i]){

619 av_free( nc->sps_buffers[i]);

620 }

621 }

622 for(int i = 0; i < MAX_PPS_COUNT; i++){

623 if (nc->pps_buffers[i]){

624 av_free( nc->pps_buffers[i]);

625 }

626 }

627 av_free(nc);

628 }

Mercurial > cgi-bin > hgwebdir.cgi > PR > Applications > VSs > VSs__H264__App

view libavcodec/h264_nal.c @ 3:0b056460c67d

Mercurial > cgi-bin > hgwebdir.cgi > PR > Applications > VSs > VSsH264App