rwmh.c

QccPack-0.54-1 released (2007-04-30) is being developed and tested on Fedora Core Linux. QccPack pro

  if (QccVIDRWMHDecodeHeader(&input_buffer,
                             NULL, NULL, NULL, NULL, NULL, NULL, NULL))
    {
      QccErrorAddMessage("(QccVIDRWMHEncodeFrame): Error calling QccVIDRWMHDecodeHeader()");
      goto Error;
    }
  
  if (!quiet)
    {
      printf("===========================================================\n");
      printf("\n");
      printf("  RWMH -- encoding sequence:\n      %s\n         to\n      %s\n\n",
             image_sequence->filename,
             output_buffer->filename);
      printf("         Frame size: %d x %d\n",
             num_cols, num_rows);
      printf("        Start frame: %d\n",
             image_sequence->start_frame_num);
      printf("          End frame: %d\n\n",
             image_sequence->end_frame_num);
      printf("         Block size: %d\n\n",
             blocksize);
      printf("  Subpixel accuracy: ");
      switch (subpixel_accuracy)
        {
        case QCCVID_ME_FULLPIXEL:
          printf("full-pixel\n");
          break;
        case QCCVID_ME_HALFPIXEL:
          printf("half-pixel\n");
          break;
        case QCCVID_ME_QUARTERPIXEL:
          printf("quarter-pixel\n");
          break;
        case QCCVID_ME_EIGHTHPIXEL:
          printf("eighth-pixel\n");
          break;
        }
      printf("\n");
      printf("===========================================================\n");
      printf("\n");
    }
  
  if (!quiet)
    printf("  Frame: %d\n",
           image_sequence->start_frame_num);
  
  if (QccVIDRWMHEncodeFrame(current_frame,
                            &reconstructed_frame,
                            current_frame_rdwt,
                            reference_frame_rdwt,
                            num_levels,
                            blocksize,
                            subpixel_accuracy,
                            filter1,
                            filter2,
                            filter3,
                            wavelet,
                            output_buffer,
                            &input_buffer,
                            NULL,
                            NULL,
                            0,
                            target_bit_cnt,
                            &statistics))
    {
      QccErrorAddMessage("(QccVIDRWMHEncode): Error calling QccVIDRWMHEncodeFrame()");
      goto Error;
    }
  
  if (!quiet)
    QccVIDRWMHPrintStatistics(&statistics);
  
  for (frame = image_sequence->start_frame_num + 1;
       frame <= image_sequence->end_frame_num;
       frame++)
    {
      if (!quiet)
        printf("  Frame: %d\n", frame);
      
      if (QccIMGImageSequenceIncrementFrameNum(image_sequence))
        {
          QccErrorAddMessage("(QccVIDRWMHEncode): Error calling QccIMGImageSequenceIncrementFrameNum()");
          goto Error;
        }
      
      if (QccIMGImageSequenceReadFrame(image_sequence))
        {
          QccErrorAddMessage("(QccVIDRWMHEncode): Error calling QccIMGImageSequenceReadFrame()");
          goto Error;
        }
      
      if ((mv_filename != NULL) && read_motion_vectors)
        if (QccVIDMotionVectorsReadFile(&motion_vector_horizontal,
                                        &motion_vector_vertical,
                                        mv_filename,
                                        frame))
          {
            QccErrorAddMessage("(QccVIDRWMHEncode): Error calling QccVIDMotionVectorsReadFile()");
            goto Error;
          }

      if (QccVIDRWMHEncodeFrame(current_frame,
                                &reconstructed_frame,
                                current_frame_rdwt,
                                reference_frame_rdwt,
                                num_levels,
                                blocksize,
                                subpixel_accuracy,
                                filter1,
                                filter2,
                                filter3,
                                wavelet,
                                output_buffer,
                                &input_buffer,
                                &motion_vector_horizontal,
                                &motion_vector_vertical,
                                read_motion_vectors,
                                target_bit_cnt,
                                &statistics))
        {
          QccErrorAddMessage("(QccVIDRWMHEncode): Error calling QccVIDRWMHEncodeFrame()");
          goto Error;
        }
      
      if ((mv_filename != NULL) && (!read_motion_vectors))
        if (QccVIDMotionVectorsWriteFile(&motion_vector_horizontal,
                                         &motion_vector_vertical,
                                         mv_filename,
                                         frame))
          {
            QccErrorAddMessage("(QccVIDRWMHEncode): Error calling QccVIDMotionVectorsWriteFile()");
            goto Error;
          }

      if (!quiet)
        QccVIDRWMHPrintStatistics(&statistics);
    }
  
  if (QccBitBufferEnd(&input_buffer))
    {
      QccErrorAddMessage("(QccVIDRWMHEncode): Error calling QccBitBufferEnd()");
      goto Error;
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccIMGImageComponentFree(&motion_vector_horizontal);
  QccIMGImageComponentFree(&motion_vector_vertical);
  QccIMGImageComponentFree(&reconstructed_frame);
  QccWAVWaveletRedundantDWT2DFree(current_frame_rdwt,
                                  num_rows,
                                  num_levels);
  QccWAVWaveletRedundantDWT2DFree(reference_frame_rdwt,
                                  reference_num_rows,
                                  num_levels);
  return(return_value);
}  


int QccVIDRWMHDecode(QccIMGImageSequence *image_sequence,
                     const QccFilter *filter1,
                     const QccFilter *filter2,
                     const QccFilter *filter3,
                     int subpixel_accuracy,
                     int blocksize,
                     QccBitBuffer *input_buffer,
                     int target_bit_cnt,
                     int num_levels,
                     const QccWAVWavelet *wavelet,
                     const QccString mv_filename,
                     int quiet)
{
  int return_value;
  int num_rows, num_cols;
  int reference_num_rows, reference_num_cols;
  QccIMGImageComponent *reconstructed_frame;
  QccMatrix *compensated_frame_rdwt = NULL;
  QccMatrix *reference_frame_rdwt = NULL;
  QccIMGImageComponent motion_vector_horizontal;
  QccIMGImageComponent motion_vector_vertical;
  int frame;
  
  QccIMGImageComponentInitialize(&motion_vector_horizontal);
  QccIMGImageComponentInitialize(&motion_vector_vertical);
  
  image_sequence->current_frame_num = image_sequence->start_frame_num;
  
  if (QccIMGImageGetSize(&image_sequence->current_frame,
                         &num_rows, &num_cols))
    {
      QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccIMGImageGetSize()");
      goto Error;
    }
  
  reconstructed_frame = &image_sequence->current_frame.Y;
  
  motion_vector_horizontal.num_rows =
    num_rows / blocksize;
  motion_vector_horizontal.num_cols =
    num_cols / blocksize;
  if (QccIMGImageComponentAlloc(&motion_vector_horizontal))
    {
      QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccIMGImageComponentAlloc()");
      goto Error;
    }
  motion_vector_vertical.num_rows =
    num_rows / blocksize;
  motion_vector_vertical.num_cols =
    num_cols / blocksize;
  if (QccIMGImageComponentAlloc(&motion_vector_vertical))
    {
      QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccIMGImageComponentAlloc()");
      goto Error;
    }
  
  if (QccVIDMotionEstimationCalcReferenceFrameSize(num_rows,
                                                   num_cols,
                                                   &reference_num_rows,
                                                   &reference_num_cols,
                                                   subpixel_accuracy))
    {
      QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccVIDMotionEstimationCalcReferenceFrameSize()");
      goto Error;
    }

  if ((compensated_frame_rdwt =
       QccWAVWaveletRedundantDWT2DAlloc(num_rows,
                                        num_cols,
                                        num_levels)) == NULL)
    {
      QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccWAVWaveletRedundantDWT2DAlloc");
      goto Error;
    }
  if ((reference_frame_rdwt =
       QccWAVWaveletRedundantDWT2DAlloc(reference_num_rows,
                                        reference_num_cols,
                                        num_levels)) == NULL)
    {
      QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccWAVWaveletRedundantDWT2DAlloc");
      goto Error;
    }
  
  if (!quiet)
    {
      printf("===========================================================\n");
      printf("\n");
      printf("  RWMH -- decoding sequence:\n      %s\n         to\n      %s\n\n",
             input_buffer->filename,
             image_sequence->filename);
      printf("         Frame size: %d x %d\n",
             num_cols, num_rows);
      printf("        Start frame: %d\n",
             image_sequence->start_frame_num);
      printf("          End frame: %d\n\n",
             image_sequence->end_frame_num);
      printf("         Block size: %d\n\n",
             blocksize);
      printf("  Subpixel accuracy: ");
      switch (subpixel_accuracy)
        {
        case QCCVID_ME_FULLPIXEL:
          printf("full-pixel\n");
          break;
        case QCCVID_ME_HALFPIXEL:
          printf("half-pixel\n");
          break;
        case QCCVID_ME_QUARTERPIXEL:
          printf("quarter-pixel\n");
          break;
        case QCCVID_ME_EIGHTHPIXEL:
          printf("eighth-pixel\n");
          break;
        }
      printf("\n");
      printf("===========================================================\n");
      printf("\n");
    }
  
  if (!quiet)
    printf("  Frame %d\n",
           image_sequence->start_frame_num);
  
  if (QccVIDRWMHDecodeFrame(reconstructed_frame,
                            compensated_frame_rdwt,
                            reference_frame_rdwt,
                            num_levels,
                            blocksize,
                            subpixel_accuracy,
                            filter1,
                            filter2,
                            filter3,
                            target_bit_cnt,
                            wavelet,
                            input_buffer,
                            0,
                            NULL,
                            NULL))
    {
      QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccVIDRWMHDecodeFrame()");
      goto Error;
    }
  
  if (QccIMGImageSequenceWriteFrame(image_sequence))
    {
      QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccIMGImageSequenceWriteFrame()");
      goto Error;
    }
  
  for (frame = image_sequence->start_frame_num + 1;
       frame <= image_sequence->end_frame_num;
       frame++)
    {
      if (QccIMGImageSequenceIncrementFrameNum(image_sequence))
        {
          QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccIMGImageSequenceIncrementFrameNum()");
          goto Error;
        }
      
      if (!quiet)
        printf("  Frame %d\n", image_sequence->current_frame_num);
      
      if (mv_filename != NULL)
        if (QccVIDMotionVectorsReadFile(&motion_vector_horizontal,
                                        &motion_vector_vertical,
                                        mv_filename,
                                        frame))
          {
            QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccVIDMotionVectorsReadFile()");
            goto Error;
          }

      if (QccVIDRWMHDecodeFrame(reconstructed_frame,
                                compensated_frame_rdwt,
                                reference_frame_rdwt,
                                num_levels,
                                blocksize,
                                subpixel_accuracy,
                                filter1,
                                filter2,
                                filter3,
                                target_bit_cnt,
                                wavelet,
                                input_buffer,
                                (mv_filename != NULL),
                                &motion_vector_horizontal,
                                &motion_vector_vertical))
        {
          QccErrorAddMessage("(QccVIDRWMHDecode): Error calling QccVIDRWMHDecodeFrame()");
          goto Error;
        }
      
      if (QccIMGImageSequenceWriteFrame(image_sequence))
        {
          QccErrorAddMessage("(QccVIDRWMHDecode(): Error calling QccIMGImageSequenceWriteFrame()");
          goto Error;
        }
    }
  
  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccIMGImageComponentFree(&motion_vector_horizontal);
  QccIMGImageComponentFree(&motion_vector_vertical);
  QccWAVWaveletRedundantDWT2DFree(compensated_frame_rdwt,
                                  num_rows,
                                  num_levels);
  QccWAVWaveletRedundantDWT2DFree(reference_frame_rdwt,
                                  reference_num_rows,
                                  num_levels);
  return(return_value);
}

#else
int QccVIDRWMHEncode(QccIMGImageSequence *image_sequence,
                     const QccFilter *filter1,
                     const QccFilter *filter2,
                     const QccFilter *filter3,
                     int subpixel_accuracy,
                     int blocksize,
                     QccBitBuffer *output_buffer,
                     int num_levels,
                     int target_bit_cnt,
                     const QccWAVWavelet *wavelet,
                     const QccString mv_filename,
                     int read_motion_vectors,
                     int quiet)
{
  QccErrorAddMessage("(QccVIDRWMHEncode): Optional QccSPIHT module is not available -- RWMH coder is consequently not supported");
  return(1);
}


int QccVIDRWMHDecodeHeader(QccBitBuffer *input_buffer,
                           int *num_rows,
                           int *num_cols,
                           int *start_frame_num,
                           int *end_frame_num,
                           int *num_levels,
                           int *blocksize,
                           int *target_bit_cnt)
{
  QccErrorAddMessage("(QccVIDRWMHDecodeHeader): Optional QccSPIHT module is not available -- RWMH coder is consequently not supported");
  return(1);
}


int QccVIDRWMHDecode(QccIMGImageSequence *image_sequence,
                     const QccFilter *filter1,
                     const QccFilter *filter2,
                     const QccFilter *filter3,
                     int subpixel_accuracy,
                     int blocksize,
                     QccBitBuffer *input_buffer,
                     int target_bit_cnt,
                     int num_levels,
                     const QccWAVWavelet *wavelet,
                     const QccString mv_filename,
                     int quiet)
{
  QccErrorAddMessage("(QccVIDRWMHDecode): Optional QccSPIHT module is not available -- RWMH coder is consequently not supported");
  return(1);
}


#endif