示例#1
0
static void Sequence( mpeg_decode* dec )
{
	int i;

	loadbits(dec);
	dec->width = getbits(dec,12);
	dec->height = getbits(dec,12);

	loadbits(dec);
    dec->aspect = getbits(dec,4);

	dec->Codec.In.Format.PacketRate.Den = 1001;
	dec->Codec.In.Format.PacketRate.Num = FrameRate[getbits(dec,4)];
	dec->Codec.FrameTime = Scale(TICKSPERSEC,dec->Codec.In.Format.PacketRate.Den,dec->Codec.In.Format.PacketRate.Num);

	loadbits(dec);
    dec->Codec.In.Format.ByteRate = getbits(dec,18) * 50;
	if (dec->Codec.In.Format.ByteRate > 8*1024*1024)
		dec->Codec.In.Format.ByteRate = 0;

    flushbits(dec,1); // marker
    flushbits(dec,10); // vbv_buffer_size
    flushbits(dec,1);

	loadbits(dec);
    if (getbits1(dec)) 
	{
        for (i=0;i<64;i++) 
		{
			loadbits(dec);
            dec->IntraMatrix[i] = (uint8_t)getbits(dec,8);
        }
    } 
	else 
	{
        for (i=0;i<64;i++) 
            dec->IntraMatrix[i] = MPEG1_IntraMatrix[dec->zigzag[i]];
    }

    if (getbits1(dec)) 
	{
        for (i=0;i<64;i++) 
		{
			loadbits(dec);
            dec->InterMatrix[i] = (uint8_t)getbits(dec, 8);
        }
    } 
	else 
	{
        for (i=0;i<64;i++) 
            dec->InterMatrix[i] = 16;
    }

	dec->ValidSeq = 1;
}
示例#2
0
int getTMNMV ()
{
    int code;

    if (trace)
        fprintf (trace_file, "motion_code (");

    if (getbits1 ())
    {
        if (trace)
            fprintf (trace_file, "1): 0\n");
        return 0;
    }
    if ((code = showbits (12)) >= 512)
    {
        code = (code >> 8) - 2;
        flushbits (TMNMVtab0[code].len);

        if (trace)
        {
            fprintf (trace_file, "0");
            printbits (code + 2, 4, TMNMVtab0[code].len);
            fprintf (trace_file, "): %d\n", TMNMVtab0[code].val);
        }
        return TMNMVtab0[code].val;
    }
示例#3
0
int getslicehdr()
{
  int slice_vertical_position_extension, intra_slice;
  int qs;

  slice_vertical_position_extension =
    (ld->mpeg2 && vertical_size>2800) ? getbits(3) : 0;

  qs = getbits(5);
  ld->quant_scale =
    ld->mpeg2 ? (ld->qscale_type ? non_linear_mquant_table[qs] : qs<<1) : qs;

  if (getbits(1))
  {
    intra_slice = getbits(1);
    flushbits(7);
    ext_bit_info();
  }
  else
    intra_slice = 0;

  if (verbose>2)
  {
    if (verbose>3)
    {
      if (ld->mpeg2 && vertical_size>2800)
        printf("  slice_vertical_position_extension=%d\n",slice_vertical_position_extension);
      printf("  quantizer_scale_code=%d\n",qs);
    }
  }
  return slice_vertical_position_extension;
}
示例#4
0
static void getgophdr()
{
  int drop_flag, hour, minute, sec, frame, closed_gop, broken_link;

  drop_flag = getbits(1);
  hour = getbits(5);
  minute = getbits(6);
  flushbits(1);
  sec = getbits(6);
  frame = getbits(6);
  closed_gop = getbits(1);
  broken_link = getbits(1);

  if (verbose>0)
  {
    if (verbose>1)
    {
      printf("  drop_flag=%d\n",drop_flag);
      printf("  timecode %d:%02d:%02d:%02d\n",hour,minute,sec,frame);
      printf("  closed_gop=%d\n",closed_gop);
      printf("  broken_link=%d\n",broken_link);
    }
  }

  ext_user_data();
}
示例#5
0
// max 11bits
static INLINE int getDCdiff(int dct_dc_size, mpeg_decode* dec)
{
	int code = showbits(dec,32); //we need only dct_dc_size bits (but in the higher bits)
	int adj = 0;
	flushbits(dec,dct_dc_size);
	if (code >= 0)
		adj = (-1 << dct_dc_size) + 1;
	return adj + ((uint32_t)code >> (32-dct_dc_size));
}
示例#6
0
// max 10 bits
static INLINE int getDCsizeChr( mpeg_decode* dec )
{
	int i,code;
	
	if (!getbits1(dec))
		return getbits(dec,1);
	
	code = showbits(dec,9);

	for (i=1;i<10;i++,code<<=1)
		if (!(code & 256))
		{
			flushbits(dec,i);
			return i+1;
		}

	flushbits(dec,9);
	return 11;
}
示例#7
0
// max 9 bits
static INLINE int getDCsizeLum( mpeg_decode* dec )
{
	int i,code;
	
	if (!getbits1(dec))
		return getbits(dec,1)+1;

	if (!getbits1(dec))
		return getbits(dec,1)*3;
	
	code = showbits(dec,7);

	for (i=1;i<8;i++,code<<=1)
		if (!(code & 64))
		{
			flushbits(dec,i);
			return i+3;
		}

	flushbits(dec,7);
	return 11;
}
示例#8
0
static void Picture( mpeg_decode* dec )
{
	static const int16_t aspect[16] = 
	{
		    0,10000, 6735, 7031,
		 7615, 8055, 8437, 8935,
		 9157, 9815,10255,10695,
		10950,11575,12015,    0,
	};

	if (!dec->Codec.In.Format.Format.Video.Aspect && aspect[dec->aspect])
		dec->Codec.In.Format.Format.Video.Aspect = Scale(ASPECT_ONE,10000,aspect[dec->aspect]);

	CodecIDCTSetFormat(&dec->Codec,PF_YUV420,dec->width,dec->height,dec->width,dec->height,dec->Codec.In.Format.Format.Video.Aspect);

    flushbits(dec,10); // temporal ref

    loadbits(dec);
	dec->prediction_type = getbits(dec,3);

    flushbits(dec,16); // non constant bit rate

	loadbits(dec);
    if (dec->prediction_type == P_VOP || dec->prediction_type == B_VOP)
	{
        dec->full_pixel[0] = getbits(dec,1);
        dec->fcode[0] = getbits(dec,3)-1;
    }

    if (dec->prediction_type == B_VOP) 
	{
        dec->full_pixel[1] = getbits(dec,1);
        dec->fcode[1] = getbits(dec,3)-1;
    }

    dec->frame_state = 1;

	DEBUG_MSG1(DEBUG_VCODEC,T("MPEG Picture:%d"),dec->prediction_type);
}
示例#9
0
static void sequence_extension()
{
  int prof_lev;
  int horizontal_size_extension, vertical_size_extension;
  int bit_rate_extension, vbv_buffer_size_extension, low_delay;
  int frame_rate_extension_n, frame_rate_extension_d;

  ld->mpeg2 = 1;
  ld->scalable_mode = SC_NONE; /* unless overwritten by seq. scal. ext. */
  prof_lev = getbits(8);
  prog_seq = getbits(1);
  chroma_format = getbits(2);
  horizontal_size_extension = getbits(2);
  vertical_size_extension = getbits(2);
  bit_rate_extension = getbits(12);
  flushbits(1);
  vbv_buffer_size_extension = getbits(8);
  low_delay = getbits(1);
  frame_rate_extension_n = getbits(2);
  frame_rate_extension_d = getbits(5);

  horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0x0fff);
  vertical_size = (vertical_size_extension<<12) | (vertical_size&0x0fff);

  if (verbose>0)
  {
    if (verbose>1)
    {
      printf("  profile_and_level_indication=%d\n",prof_lev);
      if (prof_lev<128)
      {
        printf("    profile=%d, level=%d\n",prof_lev>>4,prof_lev&15);
      }
      printf("  progressive_sequence=%d\n",prog_seq);
      printf("  chroma_format=%d\n",chroma_format);
      printf("  horizontal_size_extension=%d\n",horizontal_size_extension);
      printf("  vertical_size_extension=%d\n",vertical_size_extension);
      printf("  bit_rate_extension=%d\n",bit_rate_extension);
      printf("  vbv_buffer_size_extension=%d\n",vbv_buffer_size_extension);
      printf("  low_delay=%d\n",low_delay);
      printf("  frame_rate_extension_n=%d\n",frame_rate_extension_n);
      printf("  frame_rate_extension_d=%d\n",frame_rate_extension_d);
    }
示例#10
0
文件: gethdr.c 项目: pierz/vic
void startcode ()
{
  /* search for new picture start code */
  while (showbits (PSC_LENGTH) != 1l)
    flushbits (1);
}
示例#11
0
int gethdr_h263( mp4_decode *dec )
{
	int code;

	bytealign(dec);
	loadbits(dec);

    code = getbits(dec,22-8);
	while (!eofbits(dec))
	{
		loadbits(dec);
		code = ((code << 8) + getbits(dec,8)) & 0x3FFFFF;
		if (code == 32)
			break;
	}

	if (code != 32)
		return 0;

    flushbits(dec,8); // picture timestamp

	loadbits(dec);
	if (!getbits1(dec)) // marker
		return 0;
	if (getbits1(dec)) // h263 id
		return 0;

	flushbits(dec,3);

	code = getbits(dec,3); // format

	if (code == 6 || code == 7)
	{
		if (dec->showerror)
		{
			dec->showerror = 0;
			ShowError(dec->Codec.Node.Class,MPEG4_ID,MPEG4_ERROR_H263);
		}
		//todo: finish
		return 0;
	}
	else
	{
		static const int size[8][2] = {
			{ 0,0 },
			{ 128,96 },
			{ 176,144 },
			{ 352,288 },
			{ 704,576 },
			{ 1408,1152 }};

		int width = size[code][0];
        int height = size[code][1];
		if (!dec->ignoresize && (!width || CodecIDCTSetFormat(&dec->Codec,PF_YUV420,
			dec->Codec.In.Format.Video.Width,dec->Codec.In.Format.Video.Height,width,height) != ERR_NONE))
		{
			dec->validvol = 0;
			return 0;
		}
       
		loadbits(dec);
        dec->prediction_type = getbits(dec,1);
		dec->long_vectors = (char)getbits(dec,1);

		if (getbits1(dec)) // sac not supported
			return 0;

		getbits(dec,1); // obmc
        
		if (getbits1(dec)) // pb frame not supported
			return 0;

		dec->quantizer = getbits(dec,5);
		flushbits(dec,1);

		dec->rounding = 0;
	}

    while (getbits1(dec)) // pei
	{
        flushbits(dec,8);
		loadbits(dec);
    }

	dec->fcode_for = 1;
	dec->validvol = 1;
	dec->Codec.IDCT.Ptr->Set(dec->Codec.IDCT.Ptr,IDCT_ROUNDING,&dec->rounding,sizeof(bool_t));
	return 1;
}
示例#12
0
// write a Differential Data Stream
void writeDDSfile(const char *filename,unsigned char *data,size_t bytes,unsigned int skip,unsigned int strip,int nofree)
   {
   int version=1;

   unsigned char *ptr1,*ptr2;

   int pre1,pre2,
       act1,act2,
       tmp1,tmp2;

   unsigned int cnt,cnt1,cnt2;
   int bits,bits1,bits2;

   if (bytes<1) ERRORMSG();

   if (bytes>DDS_INTERLEAVE) version=2;

   if (skip<1 || skip>4) skip=1;
   if (strip<1 || strip>65536) strip=1;

   if ((DDS_file=fopen(filename,"wb"))==NULL) ERRORMSG();

   fprintf(DDS_file,"%s",(version==1)?DDS_ID:DDS_ID2);

   deinterleave(data,bytes,skip,DDS_INTERLEAVE);

   initbuffer();

   writebits(DDS_file,skip-1,2);
   writebits(DDS_file,strip++-1,16);

   ptr1=ptr2=data;
   pre1=pre2=0;

   cnt=cnt1=cnt2=0;
   bits=bits1=bits2=0;

   while (cnt++<bytes)
      {
      tmp1=*ptr1++;
      if (cnt<=strip) act1=tmp1-pre1;
      else act1=tmp1-pre1-*(ptr1-strip)+*(ptr1-strip-1);
      pre1=tmp1;

      while (act1<-128) act1+=256;
      while (act1>127) act1-=256;

      if (act1<=0)
         for (bits=0; (1<<bits)/2<-act1; bits++) ;
      else
         for (bits=0; (1<<bits)/2<=act1; bits++) ;

      bits=DDS_decode(DDS_code(bits));

      if (cnt1==0)
         {
         cnt1++;
         bits1=bits;
         continue;
         }

      if (cnt1<(1<<DDS_RL)-1 && bits==bits1)
         {
         cnt1++;
         continue;
         }

      if (cnt1+cnt2<(1<<DDS_RL) && (cnt1+cnt2)*max(bits1,bits2)<cnt1*bits1+cnt2*bits2+DDS_RL+3)
         {
         cnt2+=cnt1;
         if (bits1>bits2) bits2=bits1;
         }
      else
         {
         writebits(DDS_file,cnt2,DDS_RL);
         writebits(DDS_file,DDS_code(bits2),3);

         while (cnt2-->0)
            {
            tmp2=*ptr2++;
            if (ptr2-strip<=data) act2=tmp2-pre2;
            else act2=tmp2-pre2-*(ptr2-strip)+*(ptr2-strip-1);
            pre2=tmp2;

            while (act2<-128) act2+=256;
            while (act2>127) act2-=256;

            writebits(DDS_file,act2+(1<<bits2)/2,bits2);
            }

         cnt2=cnt1;
         bits2=bits1;
         }

      cnt1=1;
      bits1=bits;
      }

   if (cnt1+cnt2<(1<<DDS_RL) && (cnt1+cnt2)*max(bits1,bits2)<cnt1*bits1+cnt2*bits2+DDS_RL+3)
      {
      cnt2+=cnt1;
      if (bits1>bits2) bits2=bits1;
      }
   else
      {
      writebits(DDS_file,cnt2,DDS_RL);
      writebits(DDS_file,DDS_code(bits2),3);

      while (cnt2-->0)
         {
         tmp2=*ptr2++;
         if (ptr2-strip<=data) act2=tmp2-pre2;
         else act2=tmp2-pre2-*(ptr2-strip)+*(ptr2-strip-1);
         pre2=tmp2;

         while (act2<-128) act2+=256;
         while (act2>127) act2-=256;

         writebits(DDS_file,act2+(1<<bits2)/2,bits2);
         }

      cnt2=cnt1;
      bits2=bits1;
      }

   if (cnt2!=0)
      {
      writebits(DDS_file,cnt2,DDS_RL);
      writebits(DDS_file,DDS_code(bits2),3);

      while (cnt2-->0)
         {
         tmp2=*ptr2++;
         if (ptr2-strip<=data) act2=tmp2-pre2;
         else act2=tmp2-pre2-*(ptr2-strip)+*(ptr2-strip-1);
         pre2=tmp2;

         while (act2<-128) act2+=256;
         while (act2>127) act2-=256;

         writebits(DDS_file,act2+(1<<bits2)/2,bits2);
         }
      }

   flushbits(DDS_file);
   fclose(DDS_file);

   if (nofree==0) free(data);
   else interleave(data,bytes,skip,DDS_INTERLEAVE);
   }
示例#13
0
static void getseqhdr()
{
  int i;
  int aspect_ratio, picture_rate, vbv_buffer_size;
  int constrained_parameters_flag;
  int load_intra_quantizer_matrix, load_non_intra_quantizer_matrix;
  int bit_rate;

  horizontal_size = getbits(12);
  vertical_size = getbits(12);
  aspect_ratio = getbits(4);
  picture_rate = getbits(4);
  bit_rate = getbits(18);
  flushbits(1); /* marker bit (=1) */
  vbv_buffer_size = getbits(10);
  constrained_parameters_flag = getbits(1);

  if (load_intra_quantizer_matrix = getbits(1))
  {
    for (i=0; i<64; i++)
      ld->intra_quantizer_matrix[zig_zag_scan[i]] = getbits(8);
  }
  else
  {
    for (i=0; i<64; i++)
      ld->intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
  }

  if (load_non_intra_quantizer_matrix = getbits(1))
  {
    for (i=0; i<64; i++)
      ld->non_intra_quantizer_matrix[zig_zag_scan[i]] = getbits(8);
  }
  else
  {
    for (i=0; i<64; i++)
      ld->non_intra_quantizer_matrix[i] = 16;
  }

  /* copy luminance to chrominance matrices */
  for (i=0; i<64; i++)
  {
    ld->chroma_intra_quantizer_matrix[i] =
      ld->intra_quantizer_matrix[i];

    ld->chroma_non_intra_quantizer_matrix[i] =
      ld->non_intra_quantizer_matrix[i];
  }

  if (verbose>0)
  {
    if (verbose>1)
    {
      printf("  horizontal_size=%d\n",horizontal_size);
      printf("  vertical_size=%d\n",vertical_size);
      printf("  aspect_ratio=%d\n",aspect_ratio);
      printf("  picture_rate=%d\n",picture_rate);
      printf("  bit_rate=%d\n",bit_rate);
      printf("  vbv_buffer_size=%d\n",vbv_buffer_size);
      printf("  constrained_parameters_flag=%d\n",constrained_parameters_flag);
      printf("  load_intra_quantizer_matrix=%d\n",load_intra_quantizer_matrix);
      printf("  load_non_intra_quantizer_matrix=%d\n",load_non_intra_quantizer_matrix);
    }
  }

  ext_user_data();
}
示例#14
0
inline void startcode(void)
{
    bitpos=(bitpos+7)&~7;
    while (showbits(24)!=1)
        flushbits(8);
}
示例#15
0
void thread_work_dist()
{
  int tmp, tmp1;
  int rc, t, status;

  int excess, chunk;

#if (NUM_THREADS>1)
  pthread_attr_t attr;
  pthread_t thread[NUM_THREADS-1];
  
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
#endif

  chunk = height2/NUM_THREADS;
  excess = (height2/16)%NUM_THREADS;

  for(t=0;t < NUM_THREADS;t++)
  {
    if (t==0) {
      thread_data_array[t].s_height = 0;
      thread_data_array[t].s_mbh = 0;
      thread_data_array[t].pp_smbh = 0;
      tmp = chunk;
    } else {
      thread_data_array[t].s_height = thread_data_array[t-1].e_height;
      thread_data_array[t].s_mbh = thread_data_array[t-1].e_mbh;
      thread_data_array[t].pp_smbh = thread_data_array[t-1].pp_embh;
      tmp = thread_data_array[t-1].e_height + chunk;
    }

    if (excess) {
      tmp = tmp + 16 - (tmp%16);
      excess--;
    } else {
      tmp = tmp - (tmp%16);
    }
    tmp1 = tmp/16;

    thread_data_array[t].e_height = tmp;
    thread_data_array[t].pp_embh = tmp1;
    thread_data_array[t].e_mbh = tmp1*mb_width;
    
    thread_data_array[t].id = t;
    
    thread_data_array[t].data_ptr = &data_args;

#if (NUM_THREADS>1)
     /* create threads */
    if (t<NUM_THREADS-1) {
      rc = pthread_create(&thread[t], &attr, thread_work, 
			  (void*) &thread_data_array[t]); 
      if (rc)
	{
	  printf("ERROR; return code from pthread_create() is %d\n", rc);
	  exit(-1);
	}
    }
#endif
  }

#if (NUM_THREADS>1)
  /* Free attribute and wait for the other threads */
  pthread_attr_destroy(&attr);
#endif

  /* disabled rate control, detail can be found at putpic.c */

  putpicthdr();
  
  if (!mpeg1)
    putpictcodext();
  
  alignbits(); /*align common bitstream buffer */

  thread_work(&thread_data_array[NUM_THREADS-1]);
  
#if (NUM_THREADS>1)
  for(t=0;t < NUM_THREADS-1;t++)
    {
      rc = pthread_join(thread[t], (void **)&status);
      if (rc)
	{
	  printf("ERROR; return code from pthread_join() is %d\n", rc);
	  exit(-1);
	}
      flushbits(t);
      
    }
#endif
  
  flushbits(NUM_THREADS-1);

}