开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
dirac_encoder.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：29k
源码类别：

多媒体编程

开发平台：

Visual C++

dirac_encoder.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2. *
  3. * $Id: dirac_encoder.cpp,v 1.1 2005/01/30 05:11:41 gabest Exp $ $Name:  $
  4. *
  5. * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  6. *
  7. * The contents of this file are subject to the Mozilla Public License
  8. * Version 1.1 (the "License"); you may not use this file except in compliance
  9. * with the License. You may obtain a copy of the License at
  10. * http://www.mozilla.org/MPL/
  11. *
  12. * Software distributed under the License is distributed on an "AS IS" basis,
  13. * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
  14. * the specific language governing rights and limitations under the License.
  15. *
  16. * The Original Code is BBC Research and Development code.
  17. *
  18. * The Initial Developer of the Original Code is the British Broadcasting
  19. * Corporation.
  20. * Portions created by the Initial Developer are Copyright (C) 2004.
  21. * All Rights Reserved.
  22. *
  23. * Contributor(s): Anuradha Suraparaju (Original Author)
  24. *
  25. * Alternatively, the contents of this file may be used under the terms of
  26. * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
  27. * Public License Version 2.1 (the "LGPL"), in which case the provisions of
  28. * the GPL or the LGPL are applicable instead of those above. If you wish to
  29. * allow use of your version of this file only under the terms of the either
  30. * the GPL or LGPL and not to allow others to use your version of this file
  31. * under the MPL, indicate your decision by deleting the provisions above
  32. * and replace them with the notice and other provisions required by the GPL
  33. * or LGPL. If you do not delete the provisions above, a recipient may use
  34. * your version of this file under the terms of any one of the MPL, the GPL
  35. * or the LGPL.
  36. * ***** END LICENSE BLOCK ***** */
  38. #include <cstring>
  39. #include <sstream>
  40. #include <fstream>
  41. #include <queue>
  42. #include <libdirac_common/dirac_assertions.h>
  43. #include <libdirac_common/common.h>
  44. #include <libdirac_common/frame.h>
  45. #include <libdirac_common/pic_io.h>
  46. #include <libdirac_encoder/dirac_encoder.h>
  47. #include <libdirac_encoder/seq_compress.h>
  48. using namespace dirac;
  50. template <class T >
  51. void copy_2dArray (const TwoDArray<T> & in, T *out)
  52. {
  53.     for (int j=0 ; j<in.LengthY() ; ++j)
  54.     {
  55.         for (int i=0 ; i<in.LengthX() ; ++i)
  56.         {
  57.             // out[j*in.LengthX() + i] =  in[j][i];
  58.             *out++ =  in[j][i];
  59.         }// i
  60.     }// j
  61. }
  63. void copy_2dArray (const TwoDArray<PredMode> & in, int *out)
  64. {
  65.     for (int j=0 ; j<in.LengthY() ; ++j)
  66.     {
  67.         for (int i=0 ; i<in.LengthX() ; ++i)
  68.         {
  69.             // out[j*in.LengthX() + i] =  in[j][i];
  70.             *out++ =  in[j][i];
  71.         }// i
  72.     }// j
  73. }
  75. void copy_2dArray (const TwoDArray<bool> & in, int *out)
  76. {
  77.     for (int j=0 ; j<in.LengthY() ; ++j)
  78.     {
  79.         for (int i=0 ; i<in.LengthX() ; ++i)
  80.         {
  81.             // out[j*in.LengthX() + i] =  in[j][i];
  82.             *out++ =  in[j][i];
  83.         }// i
  84.     }// j
  85. }
  87. void copy_mv ( const MvArray& mv, dirac_mv_t *dmv)
  88. {
  89.     for (int j=0 ; j<mv.LengthY() ; ++j)
  90.     {
  91.         for (int i=0 ; i<mv.LengthX() ; ++i)
  92.         {
  93.             //dmv[j*mv.LengthX() + i].x = mv[j][i].x;
  94.             //dmv[j*mv.LengthX() + i].y = mv[j][i].y;
  95.             (*dmv).x = mv[j][i].x;
  96.             (*dmv).y = mv[j][i].y;
  97.             dmv++;
  98.         }// i
  99.     }// j
  100. }
  102. void copy_mv_cost (const TwoDArray<MvCostData> &pc, dirac_mv_cost_t *dpc)
  103. {
  104.     for (int j=0 ; j<pc.LengthY() ; ++j)
  105.     {
  106.         for (int i=0 ; i<pc.LengthX() ; ++i)
  107.         {
  108.             //dpc[j*pc.LengthX() + i].SAD = pc[j][i].SAD;
  109.             //dpc[j*pc.LengthX() + i].mvcost = pc[j][i].mvcost;
  110.             (*dpc).SAD = pc[j][i].SAD;
  111.             (*dpc).mvcost = pc[j][i].mvcost;
  112.             dpc++;
  113.         }// i
  114.     }// j
  115. }
  117. /*
  118.     Function that allocates the locally managed instrumentation data
  119. */
  120. void alloc_instr_data(dirac_instr_t *instr)
  121. {
  122.     instr->mb_split_mode = new int [instr->mb_ylen*instr->mb_xlen];
  123.     memset (instr->mb_split_mode, 0, sizeof(int)*instr->mb_ylen*instr->mb_xlen);
  125.     instr->mb_common_mode = new int [instr->mb_ylen*instr->mb_xlen];
  126.     memset (instr->mb_common_mode, 0, 
  127.                     sizeof(int)*instr->mb_ylen*instr->mb_xlen);
  129.     instr->mb_costs = new float [instr->mb_ylen*instr->mb_xlen];
  130.     memset (instr->mb_costs, 0, sizeof(float)*instr->mb_ylen*instr->mb_xlen);
  132.     instr->pred_mode = new int [instr->mv_ylen * instr->mv_xlen];
  133.     memset (instr->pred_mode, 0, sizeof(int)*instr->mv_ylen*instr->mv_xlen);
  134.         
  135.     instr->intra_costs = new float [instr->mv_ylen * instr->mv_xlen];
  136.     memset (instr->intra_costs, 0, sizeof(float)*instr->mv_ylen*instr->mv_xlen);
  137.         
  138.     instr->bipred_costs = new dirac_mv_cost_t [instr->mv_ylen * instr->mv_xlen];
  139.     memset (instr->bipred_costs, 0, sizeof(dirac_mv_cost_t)*instr->mv_ylen*instr->mv_xlen);
  140.         
  141.     instr->dc_ycomp = new short [instr->mv_ylen * instr->mv_xlen];
  142.     memset (instr->dc_ycomp, 0, sizeof(short)*instr->mv_ylen*instr->mv_xlen);
  143.         
  144.     instr->dc_ucomp = new short [instr->mv_ylen * instr->mv_xlen];
  145.     memset (instr->dc_ucomp, 0, sizeof(short)*instr->mv_ylen*instr->mv_xlen);
  146.         
  147.     instr->dc_vcomp = new short [instr->mv_ylen * instr->mv_xlen];
  148.     memset (instr->dc_vcomp, 0, sizeof(short)*instr->mv_ylen*instr->mv_xlen);
  149.         
  150.     for (int i = 0; i < 2; i++)
  151.     {
  152.         instr->mv[i] = new dirac_mv_t[instr->mv_ylen * instr->mv_xlen];
  153.         memset (instr->mv[i], 0, 
  154.             sizeof(dirac_mv_t)*instr->mv_ylen*instr->mv_xlen);
  155.     }
  156.         
  157.     for (int i = 0; i < 2; i++)
  158.     {
  159.         instr->pred_costs[i] = new dirac_mv_cost_t[instr->mv_ylen * instr->mv_xlen];
  160.         memset (instr->pred_costs[i], 0, 
  161.             sizeof(dirac_mv_cost_t)*instr->mv_ylen*instr->mv_xlen);
  162.     }
  163. }
  165. /*
  166.     Function that frees the locally managed instrumentation data
  167. */
  168. void dealloc_instr_data(dirac_instr_t *instr)
  169. {
  170.     if (instr->mb_split_mode)
  171.         delete [] instr->mb_split_mode;
  173.     if (instr->mb_common_mode)
  174.         delete [] instr->mb_common_mode;
  176.     if (instr->mb_costs)
  177.         delete [] instr->mb_costs;
  179.     if (instr->pred_mode)
  180.         delete [] instr->pred_mode;
  182.     if (instr->intra_costs)
  183.         delete [] instr->intra_costs;
  185.     if (instr->bipred_costs)
  186.         delete [] instr->bipred_costs;
  188.     if (instr->dc_ycomp)
  189.         delete [] instr->dc_ycomp;
  191.     if (instr->dc_ucomp)
  192.         delete [] instr->dc_ucomp;
  194.     if (instr->dc_vcomp)
  195.         delete [] instr->dc_vcomp;
  197.     for (int i = 0; i < 2; i++)
  198.     {
  199.         if (instr->mv[i])
  200.             delete [] instr->mv[i];
  201.     }
  202.     for (int i = 0; i < 2; i++)
  203.     {
  204.         if (instr->pred_costs[i])
  205.             delete [] instr->pred_costs[i];
  206.     }
  207. }
  209. /*
  210.     Wrapper class around the SequenceCompressor Class. This class is used 
  211.     by the "C" encoder interface
  212. */
  213. class DiracEncoder
  214. {
  215. public:
  216.     // constructor
  217.     DiracEncoder(const dirac_encoder_context_t *enc_ctx, bool verbose);
  218.     // destructor
  219.     ~DiracEncoder();
  221.     // Load the next frame of uncompressed data into the SequenceCompressor
  222.     bool LoadNextFrame(unsigned char *data, int size);
  223.     // Compress the next frame of data
  224.     int CompressNextFrame();
  226.     // Set the encode frame in encoder to the encoded frame data
  227.     int GetEncodedData(dirac_encoder_t *encoder);
  228.     
  229.     // Set the locally decoded frame data in encoder
  230.     int GetDecodedData (dirac_encoder_t *encoder);
  232.     // Set the instrumentation data in encoder
  233.     void GetInstrumentationData (dirac_encoder_t *encoder);
  235.     // Set the end of sequence infomration in encoder
  236.     int GetSequenceEnd(dirac_encoder_t *encoder);
  238.     // Set the buffer to hold the locally decoded frame
  239.     void SetDecodeBuffer (unsigned char *buffer, int buffer_size);
  241.     // Return the sequence parameters
  242.     const SeqParams& GetSeqParams() const { return m_sparams; }
  244.     // Return the encoder parameters
  245.     const EncoderParams& GetEncParams() const { return m_encparams; }
  247. private:
  249.     // Set the sequence parameters
  250.     void SetSequenceParams (const dirac_encoder_context_t *enc_ctx);
  251.     
  252.     // Set the encoder parameters
  253.     void SetEncoderParams (const dirac_encoder_context_t *enc_ctx);
  255.     // Get the frame statistics
  256.     void GetFrameStats(dirac_encoder_t *encoder);
  258.     // Get the seuqence statistics
  259.     void GetSequenceStats(dirac_encoder_t *encoder);
  261. private:
  262.     // sequence compressor
  263.     SequenceCompressor *m_comp;
  264.     // sequence parameters
  265.     SeqParams m_sparams;
  266.     // encoder parameters
  267.     EncoderParams m_encparams;
  268.     // stream to hold the compressed frame
  269.     std::ostringstream m_comp_stream;
  270.     // locally encoded frame in coded order
  271.     const Frame *m_enc_frame;
  272.     // locally encoded frame ME data
  273.     const MEData *m_enc_medata;
  274.     // locally decoded frame number in display order
  275.     int m_decfnum;
  276.     //locally decoded frame type
  277.     FrameSort m_decfsort;
  278.     // locally decoded frame number in display order
  279.     int m_show_fnum;
  280.     // total number of frame loaded so far
  281.     int m_num_loaded_frames;
  282.     // total number of frames encoded so far
  283.     int m_num_coded_frames;
  284.     // verbose flag
  285.     bool m_verbose;
  286.     // input stream for uncompressed input frame
  287.     MemoryStreamInput m_inp_ptr;
  288.     // output stream for locally decoded frame
  289.     MemoryStreamOutput m_out_ptr;
  290.     // buffer to hold locally decoded frame. Set by SetDecodeBuffer
  291.     unsigned char *m_dec_buf;
  292.     // size of buffer to hold locally decoded data. Set by SetDecodeBuffer
  293.     int m_dec_bufsize;
  294.     // Flag that determines if locally decoded frames are to be returned. Set
  295.     // in Constructor
  296.     bool m_return_decoded_frames;
  297.     // Flag that determines if instrumentation data is to be returned. Set
  298.     // in Constructor
  299.     bool m_return_instr_data;
  300. };
  302. /*
  303.     Instrumentation callback. This function is passed as a parameter to the
  304.     SequenceCompressor constructor. It is called by the 
  305.     FrameCompressor::Compress function once the frame is successfully compressed
  306. */
  307. void DiracEncoder::GetInstrumentationData (dirac_encoder_t *encoder)
  308. {
  309.     dirac_ASSERT (encoder != NULL);
  310.     dirac_instr_t *instr = &encoder->instr;
  311.     dirac_instr_t old_instr = *instr;
  313.     if (!m_return_instr_data)
  314.         return;
  316.     const FrameParams& fparams = m_enc_frame->GetFparams();
  317.     const FrameSort fsort = fparams.FSort();
  319.     instr->fnum = fparams.FrameNum();
  320.     instr->ftype = fsort;
  321.     instr->num_refs = 0;
  322.     encoder->instr_data_avail = 1;
  324.     if (fsort == I_frame)
  325.     {
  326.         // no MV data for Intra coded data
  327.         return;
  328.     }
  330.     TESTM (m_enc_medata != NULL, "ME data available");
  332.     // Reference info
  333.     instr->num_refs = fparams.Refs().size();
  334.     dirac_ASSERTM (instr->num_refs <= 2, "Max # reference frames is 2");
  336.     for (int i=0; i<instr->num_refs; ++i)
  337.         instr->refs[i] = fparams.Refs()[i];
  339.     // Block separation params
  340.     instr->ybsep = m_encparams.LumaBParams(2).Ybsep();
  341.     instr->xbsep = m_encparams.LumaBParams(2).Xbsep();
  343.     // Num macroblocks
  344.     instr->mb_ylen = m_enc_medata->MBSplit().LengthY();
  345.     instr->mb_xlen = m_enc_medata->MBSplit().LengthX();
  347.     // Motion vector array dimensions
  348.     instr->mv_ylen = m_enc_medata->Vectors(1).LengthY();
  349.     instr->mv_xlen = m_enc_medata->Vectors(1).LengthX();
  351.     if (old_instr.mb_ylen != instr->mb_ylen || 
  352.         old_instr.mb_xlen != instr->mb_xlen ||
  353.         old_instr.mv_ylen != instr->mv_ylen || 
  354.         old_instr.mv_xlen != instr->mv_xlen)
  355.     {
  356.         dealloc_instr_data(instr);
  357.         alloc_instr_data(instr);
  358.     }
  360.     copy_2dArray (m_enc_medata->MBSplit(), instr->mb_split_mode);
  361.     copy_2dArray (m_enc_medata->MBCommonMode(), instr->mb_common_mode);
  362.     copy_2dArray (m_enc_medata->MBCosts(), instr->mb_costs);
  363.     copy_2dArray (m_enc_medata->Mode(), instr->pred_mode);
  364.     copy_2dArray (m_enc_medata->IntraCosts(), instr->intra_costs);
  366.     // FIXME: Always allocating for bipred_costs even though no data available
  367.     //  Since medata is always created assuming two references
  368.     // if (instr->num_refs > 1)
  369.     {
  370.         copy_mv_cost (m_enc_medata->BiPredCosts(), instr->bipred_costs);
  371.     }
  373.     copy_2dArray (m_enc_medata->DC( Y_COMP ), instr->dc_ycomp);
  374.     if (m_enc_medata->DC().Length() == 3 && 
  375.         encoder->enc_ctx.seq_params.chroma != Yonly)
  376.     {
  377.         copy_2dArray (m_enc_medata->DC( U_COMP ), instr->dc_ucomp);
  378.         copy_2dArray (m_enc_medata->DC( V_COMP ), instr->dc_vcomp);
  379.     }
  381.     // FIXME: Always allocating for bipred_costs even though no data available
  382.     //  Since medata is always created assuming two references
  383.     // for (int i=1; i<=instr->num_refs; ++i)
  384.     for (int i=1; i<=2; ++i)
  385.     {
  386.         copy_mv (m_enc_medata->Vectors(i), instr->mv[i-1]);
  387.         copy_mv_cost (m_enc_medata->PredCosts(i), instr->pred_costs[i-1]);
  388.     }
  389. }
  391. DiracEncoder::DiracEncoder(const dirac_encoder_context_t *enc_ctx, 
  392.                            bool verbose) :
  393.     m_show_fnum(-1),
  394.     m_num_loaded_frames(0),
  395.     m_num_coded_frames(0),
  396.     m_verbose(verbose),
  397.     m_dec_buf(0),
  398.     m_dec_bufsize(0),
  399.     m_return_decoded_frames(enc_ctx->decode_flag > 0),
  400.     m_return_instr_data(enc_ctx->instr_flag > 0)
  401. {
  402.     // Setup sequence parameters
  403.     SetSequenceParams (enc_ctx);
  404.     // Setup encoder parameters
  405.     m_encparams.SetVerbose( verbose );
  406.     SetEncoderParams (enc_ctx);
  408.     // Set up the input data stream (uncompressed data)
  409.     m_inp_ptr.SetSequenceParams(m_sparams);
  410.     // Set up the output data stream (locally decoded frame)
  411.     m_out_ptr.SetSequenceParams(m_sparams);
  412.     
  413.     // initialise the sequence compressor
  414.     m_comp = new SequenceCompressor (&m_inp_ptr, &m_comp_stream, m_encparams);
  415. }
  417. void DiracEncoder::SetDecodeBuffer (unsigned char *buffer, int buffer_size)
  418. {
  419.     m_dec_buf = buffer;
  420.     m_dec_bufsize = buffer_size;
  421.     m_return_decoded_frames = true;
  422. }
  424. DiracEncoder::~DiracEncoder()
  425. {
  426.     delete m_comp;
  427. }
  429. void DiracEncoder::SetSequenceParams (const dirac_encoder_context_t *enc_ctx)
  430. {
  431.     m_sparams.SetCFormat( enc_ctx->seq_params.chroma );
  432.     m_sparams.SetXl( enc_ctx->seq_params.width );
  433.     m_sparams.SetYl( enc_ctx->seq_params.height );
  434.     m_sparams.SetInterlace( enc_ctx->seq_params.interlace );
  435.     m_sparams.SetTopFieldFirst( enc_ctx->seq_params.topfieldfirst );
  436.     m_sparams.SetFrameRate( enc_ctx->seq_params.frame_rate.numerator /
  437.                             enc_ctx->seq_params.frame_rate.denominator );
  438. }
  440. void DiracEncoder::SetEncoderParams (const dirac_encoder_context_t *enc_ctx)
  441. {
  442.     TEST (enc_ctx != NULL);
  443.     OLBParams bparams(12, 12, 8, 8);
  445.     m_encparams.SetQf(enc_ctx->enc_params.qf);
  446.     m_encparams.SetL1Sep(enc_ctx->enc_params.L1_sep);
  447.     m_encparams.SetNumL1(enc_ctx->enc_params.num_L1);
  448.     m_encparams.SetCPD(enc_ctx->enc_params.cpd);
  449.     m_encparams.SetUFactor(3.0f);
  450.     m_encparams.SetVFactor(1.75f);
  451.     bparams.SetYblen( enc_ctx->enc_params.yblen );
  452.     bparams.SetXbsep( enc_ctx->enc_params.xblen );
  453.     bparams.SetYbsep( enc_ctx->enc_params.ybsep );
  454.     bparams.SetXbsep( enc_ctx->enc_params.xbsep );
  456.     // Now rationalise the GOP options
  457.     // this stuff should really be done in a constructor!
  458.     if (m_encparams.NumL1()<0)
  459.     {
  460.         //don't have a proper GOP
  461.         m_encparams.SetL1Sep( std::max(1 , m_encparams.L1Sep()) );
  462.     }
  463.     else if (m_encparams.NumL1() == 0)
  464.     {
  465.         //have I-frame only coding
  466.         m_encparams.SetL1Sep(0);
  467.     }
  468.     m_encparams.SetOrigXl( enc_ctx->seq_params.width );
  469.     m_encparams.SetOrigYl( enc_ctx->seq_params.height );
  470.     m_encparams.SetBlockSizes( bparams , enc_ctx->seq_params.chroma );
  471. }
  474. bool DiracEncoder::LoadNextFrame (unsigned char *data, int size)
  475. {
  476.     TESTM (m_comp->Finished() != true, "Did not reach end of sequence");
  477.     m_inp_ptr.SetMembufReference(data, size);
  478.     if (m_comp->LoadNextFrame())
  479.     {
  480.         m_num_loaded_frames++;
  481.         return true;
  482.     }
  483.     return false;
  484. }
  486. int DiracEncoder::CompressNextFrame ()
  487. {
  488.     TESTM (m_comp->Finished() != true, "Did not reach end of sequence");
  490.     if (!m_num_loaded_frames)
  491.         return 0;
  493.     Frame &myframe = m_comp->CompressNextFrame();
  495.     m_enc_frame = m_comp->GetFrameEncoded();
  496.     m_enc_medata = m_comp->GetMEData();
  498.     m_decfnum = -1;
  499.     if (m_return_decoded_frames && 
  500.             myframe.GetFparams().FrameNum() != m_show_fnum)
  501.     {
  502.         int ret_val;
  503.         m_show_fnum = myframe.GetFparams().FrameNum();
  504.         TEST (! (m_return_decoded_frames && !m_dec_buf) );
  505.         if (m_return_decoded_frames && m_dec_buf)
  506.         {
  507.             // write locally decoded frame to decode buffer
  508.             m_out_ptr.SetMembufReference(m_dec_buf, m_dec_bufsize);
  509.             ret_val = m_out_ptr.WriteNextFrame(myframe);
  511.             if (ret_val)
  512.             {
  513.                 m_decfnum = m_show_fnum;
  514.                 m_decfsort = myframe.GetFparams().FSort();
  515.             }
  516.         }
  517.     }
  519.     int size = m_comp_stream.str().size();
  520.     if (size > 0)
  521.     {
  522.         m_num_coded_frames++;
  523.         TESTM (m_enc_frame != 0, "Encoder frame available");
  524.     }
  525.     return size;
  526. }
  528. void DiracEncoder::GetFrameStats(dirac_encoder_t *encoder)
  529. {
  530.     const FrameOutputManager& foutput = m_encparams.BitsOut().FrameOutput();
  531.     dirac_enc_framestats_t *fstats = &encoder->enc_fstats;
  533.     fstats->mv_bits = foutput.MVBytes() * 8;
  534.     fstats->mv_hdr_bits = foutput.MVBytes() * 8;
  536.     fstats->ycomp_bits = foutput.ComponentBytes( Y_COMP ) * 8;
  537.     fstats->ycomp_hdr_bits = foutput.ComponentHeadBytes( Y_COMP ) * 8;
  539.     fstats->ucomp_bits = foutput.ComponentBytes( U_COMP ) * 8;
  540.     fstats->ucomp_hdr_bits = foutput.ComponentHeadBytes( U_COMP ) * 8;
  542.     fstats->vcomp_bits = foutput.ComponentBytes( V_COMP ) * 8;
  543.     fstats->vcomp_hdr_bits = foutput.ComponentHeadBytes( V_COMP ) * 8;
  545.     fstats->frame_bits = foutput.FrameBytes() * 8;
  546.     fstats->frame_hdr_bits = foutput.FrameHeadBytes() * 8;
  547. }
  549. int DiracEncoder::GetEncodedData (dirac_encoder_t *encoder)
  550. {
  551.     int size = 0;
  552.     dirac_enc_data_t *encdata = &encoder->enc_buf;
  554.     size = m_comp_stream.str().size();
  555.     if (size > 0)
  556.     {
  557.         if (encdata->size < size )
  558.         {
  559.             return -1;
  560.         }
  561.         memmove (encdata->buffer, m_comp_stream.str().c_str(),  size);
  562.         encoder->enc_fparams.fnum = m_enc_frame->GetFparams().FrameNum();
  563.         encoder->enc_fparams.ftype = m_enc_frame->GetFparams().FSort();
  565.         // Get frame statistics
  566.         GetFrameStats (encoder);
  567.         encdata->size = size;
  569.         GetInstrumentationData(encoder);
  570.         encoder->encoded_frame_avail = 1;
  572.         m_comp_stream.str("");
  573.     }
  574.     else
  575.     {
  576.         encdata->size = 0;
  577.     }
  578.     return size;
  579. }
  581. int DiracEncoder::GetDecodedData (dirac_encoder_t *encoder)
  582. {
  583.     dirac_frameparams_t *fp = &encoder->dec_fparams;
  585.     int ret_stat = (m_decfnum != -1);
  586.     if (m_return_decoded_frames && m_decfnum != -1)
  587.     {
  588.             fp->ftype = m_decfsort;
  589.             fp->fnum = m_decfnum;
  590.             encoder->decoded_frame_avail = 1;
  591.             m_decfnum = -1;
  592.     }
  593.     return ret_stat;
  594. }
  596. void DiracEncoder::GetSequenceStats(dirac_encoder_t *encoder)
  597. {
  598.     dirac_enc_seqstats_t *sstats = &encoder->enc_seqstats;
  599.     dirac_seqparams_t *sparams = &encoder->enc_ctx.seq_params;
  601.     sstats->seq_bits = m_encparams.BitsOut().SequenceBytes() * 8;
  602.     sstats->seq_hdr_bits = m_encparams.BitsOut().SequenceHeadBytes() * 8;
  604.     sstats->mv_bits = m_encparams.BitsOut().MVBytes() * 8;
  605.     sstats->ycomp_bits = m_encparams.BitsOut().ComponentBytes( Y_COMP ) * 8;
  606.     sstats->ucomp_bits = m_encparams.BitsOut().ComponentBytes( U_COMP ) * 8;
  607.     sstats->vcomp_bits = m_encparams.BitsOut().ComponentBytes( V_COMP ) * 8;
  609.     sstats->bit_rate = (sstats->seq_bits * sparams->frame_rate.numerator)/
  610.                         (sparams->frame_rate.denominator * m_num_coded_frames);
  611. }
  613. int DiracEncoder::GetSequenceEnd (dirac_encoder_t *encoder)
  614. {
  615.     dirac_enc_data_t *encdata = &encoder->enc_buf;
  616.     m_comp_stream.str("");
  617.     m_comp->EndSequence();
  618.     int size = m_comp_stream.str().size();
  619.     if (size > 0)
  620.     {
  621.         if (encdata->size < size )
  622.         {
  623.             return -1;
  624.         }
  625.         memmove (encdata->buffer, m_comp_stream.str().c_str(),  size);
  626.         GetSequenceStats(encoder);
  627.         m_comp_stream.str("");
  628.         encdata->size = size;
  629.     }
  630.     else
  631.     {
  632.         encdata->size = 0;
  633.     }
  634.     return size;
  635. }
  637. static bool InitialiseEncoder (const dirac_encoder_context_t *enc_ctx, bool verbose, dirac_encoder_t *encoder)
  638. {
  639.     TEST (enc_ctx != NULL);
  640.     TEST (encoder != NULL);
  641.     
  642.     if (enc_ctx->seq_params.width == 0 || enc_ctx->seq_params.height == 0)
  643.         return false;
  645.     if (enc_ctx->seq_params.chroma < Yonly || 
  646.             enc_ctx->seq_params.chroma > formatNK)
  647.         return false;
  649.     if (!enc_ctx->seq_params.frame_rate.numerator || 
  650.             !enc_ctx->seq_params.frame_rate.denominator)
  651.         return false;
  653.     memmove (&encoder->enc_ctx, enc_ctx, sizeof(dirac_encoder_context_t));
  655.     encoder->dec_buf.id = 0;
  657.     switch ( enc_ctx->seq_params.chroma )
  658.     {
  659.     case Yonly:
  660.          encoder->enc_ctx.seq_params.chroma_width = 0;
  661.          encoder->enc_ctx.seq_params.chroma_height = 0;
  662.         break;
  663.     case format411:
  664.          encoder->enc_ctx.seq_params.chroma_width = enc_ctx->seq_params.width/4;
  665.          encoder->enc_ctx.seq_params.chroma_height = enc_ctx->seq_params.height;
  666.          break;
  667.     case format420:
  668.          encoder->enc_ctx.seq_params.chroma_width = enc_ctx->seq_params.width/2;
  669.          encoder->enc_ctx.seq_params.chroma_height = enc_ctx->seq_params.height/2;
  670.          break;
  671.     case format422:
  672.          encoder->enc_ctx.seq_params.chroma_width = enc_ctx->seq_params.width/2;
  673.          encoder->enc_ctx.seq_params.chroma_height = enc_ctx->seq_params.height;
  674.          break;
  675.     case format444:
  676.     default:
  677.          encoder->enc_ctx.seq_params.chroma_width = enc_ctx->seq_params.width;
  678.          encoder->enc_ctx.seq_params.chroma_height = enc_ctx->seq_params.height;
  679.          break;
  680.     }
  682.     try
  683.     {
  684.         DiracEncoder *comp = new DiracEncoder (&encoder->enc_ctx, verbose);
  685.     
  686.         int bufsize = (encoder->enc_ctx.seq_params.width * encoder->enc_ctx.seq_params.height)+ 2*(encoder->enc_ctx.seq_params.chroma_width*encoder->enc_ctx.seq_params.chroma_height);
  688.         encoder->dec_buf.buf[0] = new unsigned char [bufsize];
  689.         encoder->dec_buf.buf[1] = encoder->dec_buf.buf[0] + 
  690.                 (encoder->enc_ctx.seq_params.width * encoder->enc_ctx.seq_params.height);
  691.         encoder->dec_buf.buf[2] = encoder->dec_buf.buf[1] + 
  692.                 (encoder->enc_ctx.seq_params.chroma_width*encoder->enc_ctx.seq_params.chroma_height);
  693.     
  694.         encoder->compressor = comp;
  695.         if (encoder->enc_ctx.decode_flag)
  696.         {
  697.             comp->SetDecodeBuffer (encoder->dec_buf.buf[0], bufsize);
  698.         }
  699.     }
  700.     catch (...)
  701.     {
  702.         return false;
  703.     }
  704.     return true;
  705. }
  707. static void SetSequenceParameters (dirac_encoder_context_t *enc_ctx, dirac_encoder_presets_t preset)
  708. {
  709.     TEST (enc_ctx != NULL);
  710.     dirac_seqparams_t &sparams = enc_ctx->seq_params;
  712.     sparams.chroma = format420;
  713.     switch (preset)
  714.     {
  715.     case SD576:
  716.         sparams.width = 720;
  717.         sparams.height = 576;
  718.         sparams.frame_rate.numerator = 25;
  719.         sparams.frame_rate.denominator = 1;
  720.         sparams.interlace = 1;
  721.         sparams.topfieldfirst = 1;
  722.         break;
  723.     case HD720:
  724.         sparams.width = 1280;
  725.         sparams.height = 720;
  726.         sparams.frame_rate.numerator = 50;
  727.         sparams.frame_rate.denominator = 1;
  728.         sparams.interlace = 0;
  729.         sparams.topfieldfirst = 0;
  730.         break;
  731.     case HD1080:
  732.         sparams.width = 1920;
  733.         sparams.height = 1080;
  734.         sparams.frame_rate.numerator = 25;
  735.         sparams.frame_rate.denominator = 1;
  736.         sparams.interlace = 1;
  737.         sparams.topfieldfirst = 1;
  738.         break;
  739.     case CIF:
  740.     default:
  741.         sparams.width = 352;
  742.         sparams.height = 288;
  743.         sparams.frame_rate.numerator = 13;
  744.         sparams.frame_rate.denominator = 1;
  745.         sparams.interlace = 0;
  746.         sparams.topfieldfirst = 0;
  747.         break;
  748.     }
  749. }
  751. static void SetEncoderParameters (dirac_encoder_context_t *enc_ctx, dirac_encoder_presets_t preset)
  752. {
  753.     TEST (enc_ctx != NULL);
  755.     dirac_encparams_t &encparams = enc_ctx->enc_params;
  757.     encparams.qf = 7.0f;
  759.     switch (preset)
  760.     {
  761.     case SD576:
  762.         encparams.L1_sep = 3;
  763.         encparams.num_L1 = 3;
  764.         encparams.cpd = 32.0f;
  765.         encparams.xblen = 12;
  766.         encparams.yblen = 12;
  767.         encparams.xbsep = 8;
  768.         encparams.ybsep = 8;
  769.         break;
  770.     case HD720:
  771.         encparams.L1_sep = 3;
  772.         encparams.num_L1 = 7;
  773.         encparams.cpd = 20.0f;
  774.         encparams.xblen = 16;
  775.         encparams.yblen = 16;
  776.         encparams.xbsep = 10;
  777.         encparams.ybsep = 12;
  778.         break;
  779.     case HD1080:
  780.         encparams.L1_sep = 3;
  781.         encparams.num_L1 = 3;
  782.         encparams.cpd = 32.0f;
  783.         encparams.xblen = 20;
  784.         encparams.yblen = 20;
  785.         encparams.xbsep = 16;
  786.         encparams.ybsep = 16;
  787.         break;
  788.     case CIF:
  789.     default:
  790.         encparams.L1_sep = 3;
  791.         encparams.num_L1 = 11;
  792.         encparams.cpd = 20.0f;
  793.         encparams.xblen = 12;
  794.         encparams.yblen = 12;
  795.         encparams.xbsep = 8;
  796.         encparams.ybsep = 8;
  797.         break;
  798.     }
  799. }
  800. #ifdef __cplusplus
  801. extern "C" {
  802. #endif
  804. extern DllExport void dirac_encoder_context_init ( dirac_encoder_context_t *enc_ctx, dirac_encoder_presets_t preset)
  805. {
  806.     TEST (enc_ctx != NULL);
  807.     memset (enc_ctx, 0, sizeof(dirac_encoder_context_t));
  808.     SetSequenceParameters (enc_ctx, preset);
  809.     SetEncoderParameters (enc_ctx, preset);
  810. }
  812. extern DllExport dirac_encoder_t *dirac_encoder_init (const dirac_encoder_context_t *enc_ctx, int verbose)
  813. {
  814.     /* Allocate for encoder */
  815.     dirac_encoder_t *encoder = new dirac_encoder_t;
  817.     memset (encoder, 0, sizeof(dirac_encoder_t));
  819.     /* initialse the encoder context */
  820.     if (!InitialiseEncoder(enc_ctx, verbose>0, encoder))
  821.     {
  822.         delete encoder;
  823.         return NULL;
  824.     }
  826.     encoder->encoded_frame_avail = encoder->decoded_frame_avail = 0;
  827.     encoder->instr_data_avail = 0;
  830.     return encoder;
  831. }
  833. extern DllExport int dirac_encoder_load (dirac_encoder_t *encoder, unsigned char *uncdata, int uncdata_size)
  834. {
  835.     TEST (encoder != NULL);
  836.     TEST (encoder->compressor != NULL);
  837.     DiracEncoder *compressor = (DiracEncoder *)encoder->compressor;
  838.     int ret_stat = 0;
  839.     try
  840.     {
  841.         if ( compressor->LoadNextFrame (uncdata, uncdata_size))
  842.         {
  843.             ret_stat = uncdata_size;
  844.         }
  845.     }
  846.     catch (...)
  847.     {
  848.         if (compressor->GetEncParams().Verbose())
  849.             std::cerr << "dirac_encoder_load failed" << std::endl;
  850.         ret_stat = -1;
  851.     }
  852.     return ret_stat;
  853. }
  855. extern DllExport dirac_encoder_state_t 
  856.       dirac_encoder_output (dirac_encoder_t *encoder)
  857. {
  858.     TEST (encoder != NULL);
  859.     TEST (encoder->compressor != NULL);
  860.     TEST (encoder->enc_buf.size != 0);
  861.     TEST (encoder->enc_buf.buffer != NULL);
  862.     DiracEncoder *compressor = (DiracEncoder *)encoder->compressor;
  863.     dirac_encoder_state_t ret_stat = ENC_STATE_BUFFER;
  865.     encoder->encoded_frame_avail = 0;
  866.     encoder->decoded_frame_avail = 0;
  867.     encoder->instr_data_avail = 0;
  869.     try
  870.     {
  871.         compressor->CompressNextFrame();
  872.         if (compressor->GetEncodedData (encoder) < 0)
  873.             ret_stat = ENC_STATE_INVALID;
  874.         else
  875.         {
  876.             if (encoder->enc_buf.size > 0)
  877.             {
  878.                 ret_stat = ENC_STATE_AVAIL;
  879.             }
  880.     
  881.             if (encoder->enc_ctx.decode_flag)
  882.                 compressor->GetDecodedData(encoder);
  883.         }
  884.     }
  885.     catch (...)
  886.     {
  887.         if (compressor->GetEncParams().Verbose())
  888.             std::cerr << "GetEncodedData failed..." << std::endl;
  890.         ret_stat = ENC_STATE_INVALID;
  891.     }
  892.     return ret_stat;
  893. }
  895. extern DllExport int dirac_encoder_end_sequence (dirac_encoder_t *encoder)
  896. {
  897.     TEST (encoder != NULL);
  898.     TEST (encoder->compressor != NULL);
  899.     DiracEncoder *compressor = (DiracEncoder *)encoder->compressor;
  900.     int ret_stat;
  902.     encoder->encoded_frame_avail = 0;
  903.     encoder->decoded_frame_avail = 0;
  904.     encoder->instr_data_avail = 0;
  906.     try
  907.     {
  908.         ret_stat = compressor->GetSequenceEnd (encoder);
  909.         encoder->end_of_sequence = 1;
  911.         if (compressor->GetDecodedData(encoder))
  912.         {
  913.             encoder->decoded_frame_avail = 1;
  914.         }
  915.     }
  916.     catch (...)
  917.     {
  918.         if (compressor->GetEncParams().Verbose())
  919.             std::cerr << "GetSequenceEnd failed..." << std::endl;
  920.         ret_stat = -1;
  921.     }
  922.     return ret_stat;
  923. }
  925. extern DllExport void dirac_encoder_close (dirac_encoder_t *encoder)
  926. {
  927.     TEST (encoder != NULL);
  928.     TEST (encoder->compressor != NULL);
  929.     
  930.     delete (DiracEncoder *)(encoder->compressor);
  932.     if (encoder->enc_ctx.instr_flag)
  933.     {
  934.         dealloc_instr_data(&encoder->instr);
  935.     }
  937.     if (encoder->enc_ctx.decode_flag)
  938.     {
  939.         delete [] encoder->dec_buf.buf[0];
  940.     }
  941.     delete encoder;
  942. }
  945. #ifdef __cplusplus
  946. }
  947. #endif