C++ XIRef类代码示例

void H264UserDataTest::TestZeroRawSEI()
{
    printf("H264UserDataTest::TestZeroRawSEI()\n");
    fflush(stdout);

    XIRef<XMemory> data = new XMemory;

    for(uint8_t i = 1; i < 77; ++i)
        data->Append<uint8_t>(0);

    XRef<SEIPayload> payload = new SEIPayload(data);
    CPPUNIT_ASSERT(payload->GetData().Get() == data.Get());
    CPPUNIT_ASSERT(payload->GetUUID() == XUuid("7e0858c4-38fe-48ea-852d-dace39badb30"));

    H264UserData before(payload);
    const std::vector<XRef<SEIPayload> >& beforePayloads = before.GetPayloads();
    CPPUNIT_ASSERT(beforePayloads.size() == 1);
    CPPUNIT_ASSERT(beforePayloads.front() == payload);
    XIRef<XMemory> sei = before.GenSEI();

    H264UserData after(sei->begin(), sei->GetDataSize());
    const std::vector<XRef<SEIPayload> >& afterPayloads = before.GetPayloads();
    CPPUNIT_ASSERT(afterPayloads.size() == 1);
    CPPUNIT_ASSERT(afterPayloads.front().Get() == payload.Get());
}

AVDeMuxer::AVDeMuxer( XIRef<XSDK::XMemory> buffer, bool annexBFilter ) :
    _fileName(),
    _memoryIOContext( NULL ),
    _storage( new XMemory ),
    _pos( 0 ),
    _context( NULL ),
    _eof( false ),
    _deMuxPkt(),
    _filterPkt(),
    _streamTypes(),
    _videoStreamIndex( STREAM_TYPE_UNKNOWN ),
    _audioPrimaryStreamIndex( STREAM_TYPE_UNKNOWN ),
    _bsfc( (annexBFilter)? av_bitstream_filter_init( "h264_mp4toannexb" ) : NULL ),
    _pf( new PacketFactoryDefault() )
{
    if( !Locky::IsRegistered() )
        X_THROW(("Please register AVKit::Locky before using this class."));

    _deMuxPkt.size = 0;
    _deMuxPkt.data = NULL;
    _filterPkt.size = 0;
    _filterPkt.data = NULL;

    size_t bufferSize = buffer->GetDataSize();

    _OpenCustomIOContext( buffer->Map(), bufferSize );

    _OpenStreams();
}

XIRef<XDomParserNode> XUTC::ToXML() const
{
    XIRef<XDomParserNode> node = new XDomParserNode;
    node->SetTagName("XUTC");

    return node;
}

XIRef<XMemory> H264Encoder::GetExtraData() const
{
    XIRef<XMemory> ed = new XMemory( DEFAULT_EXTRADATA_BUFFER_SIZE );

    memcpy( &ed->Extend( _extraData.GetDataSize() ), _extraData.Map(), _extraData.GetDataSize() );

    return ed;
}

struct StreamStatistics AVDeMuxer::GetVideoStreamStatistics( const XSDK::XString& fileName )
{
    struct StreamStatistics result;
    XStatistics<Average,uint32_t> avgFrameSize;

    uint32_t indexFirstKey = 0;
    bool foundFirstKey = false;
    bool foundGOPSize = false;
    uint32_t currentIndex = 0;

    AVDeMuxer dm( fileName );

    int videoStreamIndex = dm.GetVideoStreamIndex();

    result.frameRate = (((double)1.0) / dm.GetSecondsBetweenFrames( videoStreamIndex ));
    pair<int,int> tb = dm.GetTimeBase( videoStreamIndex );
    result.timeBaseNum = tb.first;
    result.timeBaseDen = tb.second;

    int streamIndex = 0;
    while( dm.ReadFrame( streamIndex ) )
    {
        if( streamIndex != videoStreamIndex )
            continue;

        if( dm.IsKey() )
        {
            if( !foundFirstKey )
            {
                indexFirstKey = currentIndex;
                foundFirstKey = true;
            }
            else
            {
                if( !foundGOPSize )
                {
                    result.gopSize = currentIndex - indexFirstKey;
                    foundGOPSize = true;
                }
            }
        }

        XIRef<Packet> pkt = dm.Get();

        avgFrameSize.AddSample( pkt->GetDataSize() );

        currentIndex++;
    }

    uint32_t avgSize = 0;
    avgFrameSize.GetResult( avgSize );

    result.averageBitRate = (uint32_t)((avgSize * (1.0 / dm.GetSecondsBetweenFrames(videoStreamIndex))) * 8);

    result.numFrames = currentIndex;

    return result;
}

ExportOverlay::ExportOverlay( const XSDK::XString& msg,
                              bool withTime,
                              OverlayHAlign hAlign,
                              OverlayVAlign vAlign,
                              uint16_t width,
                              uint16_t height,
                              int timeBaseNum,
                              int timeBaseDen ) :
    _msg( msg ),
    _decodedMsg(),
    _withTime( withTime ),
    _hAlign( hAlign ),
    _vAlign( vAlign ),
    _width( width ),
    _height( height ),
    _timeBaseNum( timeBaseNum),
    _timeBaseDen( timeBaseDen ),
    _timePerFrame( ((double)timeBaseNum / timeBaseDen) ),
    _logoX( (uint16_t)((double)_width * 0.79) ),
    _logoY( (uint16_t)((double)_height * 0.92) ),
    _logoWidth( (uint16_t)((double)_width * 0.2) ),
    _logoHeight( (uint16_t)((double)_height * 0.07) ),
    _wmSurface( NULL )
{
    if( !_msg.empty() )
    {
        XIRef<XSDK::XMemory> decodedBuf = _msg.FromBase64();
        _decodedMsg = XString( (const char*)decodedBuf->Map(), decodedBuf->GetDataSize() );
    }

    X_LOG_NOTICE("watermark: x=%u, y=%u, w=%u, h=%u", _logoX, _logoY, _logoWidth, _logoHeight);

    _wmSurface = cairo_image_surface_create( CAIRO_FORMAT_ARGB32, _logoWidth, _logoHeight );

    if( !_wmSurface )
        X_THROW(("Unable to allocate cairo surface for watermark: _logoWidth = %u, _logoHeight = %u", _logoWidth, _logoHeight));

    cairo_t* wmCr = cairo_create( _wmSurface );

    if( !wmCr )
        X_THROW(("Unable to allocate cairo handle for watermark."));

    cairo_scale( wmCr, (double)_width / 1408, (double)_height / 792 );

    GError* err = NULL;
    RsvgHandle* rsvgHandle = rsvg_handle_new_from_file("multisight-logo-white-outline.svg", &err);

    if( !rsvgHandle )
        X_THROW(("Unable to open ms logo from svg for watermark."));

    if( rsvg_handle_render_cairo( rsvgHandle, wmCr ) != TRUE )
        X_THROW(("svg render failed for watermark."));

    g_object_unref(rsvgHandle);

    cairo_destroy( wmCr );

}

void JPEGEncoder::WriteJPEGFile( const XSDK::XString& fileName, XIRef<Packet> jpeg )
{
    FILE* outFile = fopen( fileName.c_str(), "wb" );
    if( !outFile )
        X_THROW(("Unable to open output file."));

    fwrite( jpeg->Map(), 1, jpeg->GetDataSize(), outFile );

    fclose( outFile );
}

XIRef<XTimeZone> XUTC::Instance()
{
    XGuard lock(_cInstanceLock);

    static XIRef<XTimeZone> instance;

    if( instance.IsEmpty() )
        instance = new XUTC;

    return instance;
}

void AVMuxer::WriteVideoPacket( XIRef<Packet> input, bool keyFrame )
{
    if( _context->pb == NULL )
        _OpenIO();

    if( _isTS )
    {
        if( _numVideoFramesWritten == 0 )
        {
            if( _fileNum == 0 )
            {
                if( avformat_write_header( _context, NULL ) < 0 )
                    X_THROW(("Unable to write header to container."));
            }

            av_opt_set( _context->priv_data, "mpegts_flags", "resend_headers", 0 );
        }
    }
    else
    {
        if( !_oweTrailer )
        {
            if( avformat_write_header( _context, NULL ) < 0 )
                X_THROW(("Unable to write header to container."));

            _oweTrailer = true;
        }
    }

    AVPacket pkt;
    av_init_packet( &pkt );

    pkt.stream_index = _stream->index;
    pkt.data = input->Map();
    pkt.size = input->GetDataSize();

    pkt.pts = _ts;
    pkt.dts = _ts;

    // convert a tick of 1 from the codecs time_base (e.g. 1/15) to the containers
    // time_base
    _ts += av_rescale_q(1, _stream->codec->time_base, _stream->time_base);

    pkt.flags |= (keyFrame) ? AV_PKT_FLAG_KEY : 0;

    if( av_interleaved_write_frame( _context, &pkt ) < 0 )
        X_THROW(("Unable to write video frame."));

    _numVideoFramesWritten++;
}

void AVMuxer::SetExtraData( XIRef<XSDK::XMemory> extraData )
{
    if( !(_context->oformat->flags & AVFMT_GLOBALHEADER) )
        X_LOG_INFO("Extradata not required for %s container.",_fileName.c_str());
    else
    {
        _stream->codec->extradata = (uint8_t*)av_mallocz( extraData->GetDataSize() );
        if( !_stream->codec->extradata )
            X_THROW(("Unable to allocate extradata storage."));
        _stream->codec->extradata_size = extraData->GetDataSize();

        memcpy( _stream->codec->extradata, extraData->Map(), extraData->GetDataSize() );
    }
}

void AVMuxer::FinalizeBuffer( XIRef<XSDK::XMemory> buffer )
{
    if( _location != OUTPUT_LOCATION_BUFFER )
        X_THROW(("Unable to finalize a non buffer IO object."));

    _FinalizeCommon();

    uint8_t* fileBytes = NULL;
    int fileSize = avio_close_dyn_buf( _context->pb, &fileBytes );
    _context->pb = NULL;

    if( fileBytes == NULL || fileSize == 0 )
        X_THROW(("Unable to finalize empty buffer."));

    buffer->ResizeData( fileSize );

    memcpy( buffer->Map(), fileBytes, fileSize );

    av_freep( &fileBytes );
}

XIRef<XTimeZone> XSimpleTimeZone::FromXML(XIRef<XDomParserNode> node)
{
    const XString utcOffsetStr = node->GetMetaData("utcOffset");
    const XString dstOffsetStr = node->GetMetaData("dstOffset");

    if(node->GetTagName() != "XSimpleTimeZone" ||
       utcOffsetStr.empty() ||
       (!verifyDigit(utcOffsetStr[0]) && utcOffsetStr[0] != '-') ||
       count_if(utcOffsetStr.begin() + 1, utcOffsetStr.end(), verifyDigit) != (int)utcOffsetStr.size() - 1 ||
       dstOffsetStr.empty() ||
       (!verifyDigit(dstOffsetStr[0]) && dstOffsetStr[0] != '-') ||
       count_if(dstOffsetStr.begin() + 1, dstOffsetStr.end(), verifyDigit) != (int)dstOffsetStr.size() - 1)
    {
        return 0;
    }

    const int utcOffset = utcOffsetStr.ToInt();
    const int dstOffset = dstOffsetStr.ToInt();

    return new XSimpleTimeZone(utcOffset, dstOffset);
}

XIRef<XMemory> AVDeMuxer::LoadFile( const XSDK::XString& fileName )
{
    XIRef<XMemory> buffer = new XMemory;

    struct x_file_info fileInfo;
    if( x_stat( fileName, &fileInfo ) < 0 )
        X_THROW(("Unable to stat specified file."));

    FILE* inFile = fopen( fileName.c_str(), "rb" );
    if( !inFile )
        X_THROW(("Unable to open specified file."));

    uint8_t* d = &buffer->Extend( fileInfo._fileSize );

    int itemsRead = fread( d, 1, fileInfo._fileSize, inFile );

    fclose( inFile );

    if( itemsRead != fileInfo._fileSize )
        X_THROW(("Failed to read all of the data from the file."));

    return buffer;
}

void JPEGEncoder::EncodeYUV420P( XIRef<Packet> input )
{
    AVFrame frame;
    avcodec_get_frame_defaults( &frame );

    _output = _pf->Get( DEFAULT_JPEG_ENCODE_BUFFER_SIZE + DEFAULT_PADDING );

    uint8_t* pic = input->Map();

    frame.data[0] = pic;
    pic += (_context->width * _context->height);
    frame.data[1] = pic;
    pic += ((_context->width/4) * _context->height);
    frame.data[2] = pic;

    frame.linesize[0] = _context->width;
    frame.linesize[1] = (_context->width/2);
    frame.linesize[2] = (_context->width/2);

    int attempt = 0;
    int gotPacket = 0;
    AVPacket pkt;

    do
    {
        av_init_packet( &pkt );
        pkt.data = _output->Map();
        pkt.size = _output->GetBufferSize();

        if( avcodec_encode_video2( _context,
                                   &pkt,
                                   &frame,
                                   &gotPacket ) < 0 )
            X_THROW(("Error while encoding."));

        attempt++;
    } while( gotPacket == 0 && (attempt < _encodeAttempts) );

    _output->SetDataSize( pkt.size );
}

void YUV420PToARGB24::Transform( XIRef<Packet> input, size_t width, size_t height )
{
    uint8_t* src = input->Map();

    AVFrame frame;
    frame.data[0] = src;
    src += width * height;
    frame.data[1] = src;
    src += ((width/2) * (height/2));
    frame.data[2] = src;

    frame.linesize[0] = width;
    frame.linesize[1] = (width/2);
    frame.linesize[2] = (width/2);

    size_t dataSize = height * (width*4);
    _rgb24 = _pf->Get( dataSize + DEFAULT_PADDING );
    _rgb24->SetDataSize( dataSize );

    AVPicture pict;
    pict.data[0] = _rgb24->Map();
    pict.linesize[0] = width * 4;

    if( (width != _currentWidth) || (height != _currentHeight) )
        _DestroyScaler();

    if( !_scaler )
        _InitScaler( width, height );

    int ret = sws_scale( _scaler,
                         frame.data,
                         frame.linesize,
                         0,
                         height,
                         pict.data,
                         pict.linesize );
}