libx265 - кодируем видео в самом современном формате

#include <cstring>
#include <cstdio>
#include "x265.h"
 
class x265_encoder {
    typedef bool (*write_callback_t)( int action, const x265_nal *, uint32_t );
 
    bool                m_is_valid;
    x265_encoder *      m_encoder;
    x265_picture *      m_picture;
    unsigned            m_frame;
    write_callback_t    m_write_callback;
 
public:
    enum { OPEN, WRITE, CLOSE };
 
    x265_encoder( unsigned width, unsigned height, unsigned fps, double quality, write_callback_t write_callback )
        : m_is_valid( false ), m_frame( 0 ), m_write_callback( write_callback ) {
 
        x265_param * p_param = x265_param_alloc();
        x265_param_default( p_param );
 
        // presets: "ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo"
        if ( x265_param_default_preset( p_param, "medium", "zerolatency" ) < 0 ) {
            fprintf( stderr, "x265_param_default_preset(): error\n" );
        } else {
            p_param->sourceWidth = width;
            p_param->sourceHeight = height;
 
            p_param->fpsNum = fps;
            p_param->fpsDenom = 1;
 
            p_param->rc.rateControlMode = X265_RC_CRF;
 
            p_param->rc.rfConstant = (quality < 0 ? 0 : (quality > 1 ? 1 : (quality * 51)));
 
            m_encoder = x265_encoder_open( p_param );
            if ( !m_encoder ) {
                fprintf( stderr, "x265_encoder_open(): error\n" );
            } else {
                x265_encoder_parameters( m_encoder, p_param );
 
                m_write_callback( OPEN, 0, 0 );
 
                if ( !p_param->bRepeatHeaders ) {
                    x265_nal *  p_nal;
                    uint32_t    n_nal;
                    x265_encoder_headers( m_encoder, &p_nal, &n_nal );
                    m_write_callback( WRITE, p_nal, n_nal );
                }
 
                m_picture = x265_picture_alloc();
                x265_picture_init( p_param, m_picture );
                m_picture->colorSpace = X265_CSP_I420;
                m_picture->bitDepth = 8;
 
                // I420
                m_picture->stride[0] = p_param->sourceWidth;
                m_picture->stride[1] = p_param->sourceWidth / 2;
                m_picture->stride[2] = p_param->sourceWidth / 2;
 
                m_is_valid = true;
            }
        }
        x265_param_free( p_param );
    }
 
    virtual ~x265_encoder() {
        if ( is_valid() ) {
            m_write_callback( CLOSE, 0, 0 );
            x265_picture_free( m_picture );
            x265_encoder_close( m_encoder );
        }
    }
 
    bool is_valid() const { return m_is_valid; }
 
    bool encode( uint8_t * pY, uint8_t * pU, uint8_t * pV ) {
        m_picture->pts = m_frame;
        m_picture->planes[0] = pY;
        m_picture->planes[1] = pU;
        m_picture->planes[2] = pV;
 
        x265_nal *  p_nal;
        uint32_t    n_nal;
        int err = x265_encoder_encode( m_encoder, &p_nal, &n_nal, m_picture, NULL );
        if ( err < 0 ) return false;
        m_write_callback( WRITE, p_nal, n_nal );
        ++m_frame;
        return true;
    }
};
 
static bool write_cb( int action, const x265_nal * p_nal, uint32_t n_nal ) {
    static FILE * fp = NULL;
    switch ( action ) {
        case x265_encoder::OPEN:
            fp = fopen( "out.raw", "wb+" );
            if ( !fp ) return false;
            break;
 
        case x265_encoder::CLOSE:
            fclose( fp );
            break;
 
        case x265_encoder::WRITE:
            for ( unsigned i = 0; i < n_nal; ++i ) {
                fwrite( p_nal->payload, p_nal->sizeBytes, 1, fp );
                p_nal++;
            }
            break;
    }
    return true;
}
 
int main()
{
    const int w = 320;
    const int h = 240;
 
    x265_encoder enc( w, h, 30, .5, write_cb );
    if ( enc.is_valid() ) {
 
        uint8_t * pY = new uint8_t [w * h];
        uint8_t * pU = new uint8_t [w / 2 * h / 2];
        uint8_t * pV = new uint8_t [w / 2 * h / 2];
 
        // set U and V planes to 128
        memset( pU, 128, w / 2 * h / 2 );
        memset( pV, 128, w / 2 * h / 2 );
 
        for ( unsigned i = 0; i < 100; ++i ) {
 
            // set Y plane
            for ( int y = 0; y < h; y++ )
            for ( int x = 0; x < w; x++ ) {
                pY[y * w + x] = (((x + i) >> 4) + ((y + i) >> 4)) & 1 ? 255 : 0;
            }
 
            enc.encode( pY, pU, pV );
        }
 
        delete [] pV;
        delete [] pU;
        delete [] pY;
    }
}