remove \r

[extl.git] / ExtlTest.cpp

//#include "stdio.h"

#define EXTL_NEW_PLATFORM_ENABLE
#define EXTL_DEBUG
#define EXTL_UNICODE 
//#include "extl/intelligence/intelligence.h"
//#include "extl/counter/counter.h"
//#include "extl/extl.h"
//#include "extl/media/media.h"
//#include "extl/test/test.h"
#include "extl/prefix.h"
//#include "fstream"
EXTL_NS_USING_NAMESPACE(extl)

//using namespace extl::media;


int hamming_d(int v1, int v2, int bit_n)
{
        int count = 0;
        for (int i = 0; i < bit_n; ++i)
        {
                int v1_i = (int(0x1) == ((v1 >> i) & int(0x1)));
                int v2_i = (int(0x1) == ((v2 >> i) & int(0x1)));
                if (v1_i != v2_i) count++;
        }
        return count;
}

int main()
{
        printf("%d\n", hamming_d(5, 10, 5));
        /*std::ifstream fin("data/test.ts", std::ios::in | std::ios::binary);

        e_byte_t buf[188];
        ts::packet pck;

        for (int i = 0; i < 10; i++)
        {
                fin.read((char*)buf, 188);
                pck.decode(buf);

                // transport header
                printf("transport header:\n"                                                                                                                            );
                printf("sync_byte: %#x\n",                                              pck.header().sync_byte()                                        );
                printf("transport_error_indicator: %u\n",               pck.header().transport_error_indicator()        );
                printf("payload_unit_start_indicator: %u\n",    pck.header().payload_unit_start_indicator()     );
                printf("transport_priority: %u\n",                              pck.header().transport_priority()                       );
                printf("pid: %#x\n",                                                    pck.header().pid()                                                      );
                printf("transport_scrambling_control: %u\n",    pck.header().transport_scrambling_control()     );
                printf("adaptation_field_control: %u\n",                pck.header().adaptation_field_control()         );
                printf("continuity_counter: %u\n",                              pck.header().continuity_counter()                       );

                // the end
                if (pck.is_null()) break;

                // cannot be analyzed
                if      (       pck.is_scrambling() 
                        ||      pck.exists_error() 
                        ||      !pck.is_valid()
                        )
                {
                        printf("this packet cannot be analyzed!");
                        break;
                }

                // adaptation field
                if (pck.adaptation().exists())
                {
                        printf("\t adaptation_field header:\n"                                                                                                                                                                  );
                        printf("\t adaptation_field_length: %u\n",                              pck.adaptation().header().adaptation_length()                                   );
                        printf("\t discontinuity_indicator: %u\n",                              pck.adaptation().header().discontinuity_indicator()                             );
                        printf("\t random_access_indicator: %u\n",                              pck.adaptation().header().random_access_indicator()                             );
                        printf("\t elementary_stream_priority_indicator: %u\n", pck.adaptation().header().elementary_stream_priority_indicator());
                        printf("\t pcr_flag: %u\n",                                                             pck.adaptation().header().pcr_flag()                                                    );
                        printf("\t opcr_flag: %u\n",                                                    pck.adaptation().header().opcr_flag()                                                   );
                        printf("\t splicing_point_flag: %u\n",                                  pck.adaptation().header().splicing_point_flag()                                 );
                        printf("\t transport_private_data_flag: %u\n",                  pck.adaptation().header().private_data_flag()                                   );
                        printf("\t extension_flag: %u\n",                                               pck.adaptation().header().extension_flag()                                              );

                        if (pck.adaptation().pcr().exists())
                        {
                                printf("\t pcr: %I64u\n",                       pck.adaptation().pcr().value()                          );
                                printf("\t pcr_base: %I64u\n",          pck.adaptation().pcr().base()                           );
                                printf("\t pcr_extension: %u\n",        pck.adaptation().pcr().extension()                      );
                        }

                        if (pck.adaptation().opcr().exists())
                        {
                                printf("\t pcr: %I64u\n",                       pck.adaptation().opcr().value()                         );
                                printf("\t pcr_base: %I64u\n",          pck.adaptation().opcr().base()                          );
                                printf("\t pcr_extension: %u\n",        pck.adaptation().opcr().extension()                     );
                        }

                        if (pck.adaptation().splicing().exists())
                        {
                                printf("\t splice_countdown: %u\n",     pck.adaptation().splicing().countdown() );
                        }

                        if (pck.adaptation().private_data().exists())
                        {
                                printf("\t private_data_length: %u\n",  pck.adaptation().private_data().size()  );
                                for (int i = 0; i < (int)pck.adaptation().private_data().size(); ++i)
                                {
                                        printf("\t private_data: %02x\n",       pck.adaptation().private_data().data()[i]       );
                                }
                        }

                        if (pck.adaptation().extension().exists())
                        {
                                printf("\t\t adaptation_extension_length: %u\n",        pck.adaptation().extension().size()     );

                                if (pck.adaptation().extension().exists_ltw())
                                {
                                        printf("\t\t ltw_valid_flag: %u\n",     pck.adaptation().extension().ltw().ltw_valid_flag       );
                                        printf("\t\t ltw_offset: %u\n",         pck.adaptation().extension().ltw().ltw_offset   );
                                }

                                if (pck.adaptation().extension().exists_piecewise_rate())
                                {
                                        printf("\t\t piecewise_rate: %u\n",     pck.adaptation().extension().piecewise_rate()   );
                                }

                                if (pck.adaptation().extension().exists_seamless_splice())
                                {
                                        printf("\t\t splice_type: %u\n",        pck.adaptation().extension().seamless_splice().splice_type      );
                                }
                        }
                }

                printf("\n");
                pck.encode();
        }
        

        fin.close();*/
        getchar(); 
        return 0;
}