Ticket #6243: H264Parser-fixes-v1.1.patch

File H264Parser-fixes-v1.1.patch, 12.2 KB (added by jppoet@…, 3 years ago)

Allows recorder to designate if I frames should be counted as keyframes

  • libs/libmythtv/mpeg/H264Parser.cpp

    old new  
    33 
    44extern "C" { 
    55// from libavcodec 
    6     extern const uint8_t *ff_find_start_code(const uint8_t * p, const uint8_t *end, uint32_t * state); 
     6    extern const uint8_t *ff_find_start_code(const uint8_t * p, 
     7                                             const uint8_t *end, 
     8                                             uint32_t * state); 
    79#include "avcodec.h" 
    810} 
    911 
    … … static const float eps = 1E-5; 
    8890H264Parser::H264Parser(void) 
    8991{ 
    9092    Reset(); 
     93    I_is_keyframe = false; 
    9194} 
    9295 
    9396void H264Parser::Reset(void) 
    9497{ 
    9598    state_changed = false; 
    96     seen_sps = seen_IDR = false; 
     99    seen_sps = false; 
     100    is_keyframe = false; 
    97101 
    98102    sync_accumulator = 0xffffffff; 
    99     find_AU = false; 
    100103    AU_pending = false; 
    101104 
    102     NAL_type = UNKNOWN; 
    103  
    104105    frame_num = prev_frame_num = -1; 
    105106    slice_type = SLICE_UNDEF; 
    106107    prev_pic_parameter_set_id = pic_parameter_set_id = -1; 
    … … void H264Parser::Reset(void) 
    112113    prev_delta_pic_order_cnt_bottom = delta_pic_order_cnt_bottom = 0; 
    113114    prev_delta_pic_order_cnt[0] = delta_pic_order_cnt[0] = 0; 
    114115    prev_delta_pic_order_cnt[1] = delta_pic_order_cnt[1] = 0; 
    115     prev_nal_unit_type = nal_unit_type = 0; 
     116    prev_nal_unit_type = nal_unit_type = UNKNOWN; 
    116117    prev_idr_pic_id = idr_pic_id = 0; 
    117118 
    118119    log2_max_frame_num = log2_max_pic_order_cnt_lsb = 0; 
    … … void H264Parser::Reset(void) 
    136137 
    137138    AU_offset = frame_start_offset = keyframe_start_offset = 0; 
    138139    on_frame = on_key_frame = false; 
    139  
    140     wait_for_IDR = false; 
    141140} 
    142141 
    143142 
    … … bool H264Parser::new_AU(void) 
    214213    { 
    215214        // Need previous slice information for comparison 
    216215 
    217         if (NAL_type == AU_DELIMITER || 
    218             NAL_type == SPS || 
    219             NAL_type == PPS || 
    220             NAL_type == SEI || 
    221             (NAL_type > SPS_EXT && NAL_type < AUXILIARY_SLICE)) 
    222             result = true; 
    223         else if (NAL_type != SLICE_IDR && frame_num != prev_frame_num) 
     216        if (nal_unit_type != SLICE_IDR && frame_num != prev_frame_num) 
    224217            result = true; 
    225218        else if (prev_pic_parameter_set_id != -1 && 
    226219                 pic_parameter_set_id != prev_pic_parameter_set_id) 
    … … bool H264Parser::new_AU(void) 
    230223        else if ((bottom_field_flag != -1 && prev_bottom_field_flag != -1) && 
    231224                 bottom_field_flag != prev_bottom_field_flag) 
    232225            result = true; 
    233         else if ((nal_ref_idc == 0 || prev_nal_ref_idc == 0) && 
    234                  nal_ref_idc != prev_nal_ref_idc) 
    235             result = true; 
    236226        else if ((pic_order_cnt_type == 0 && prev_pic_order_cnt_type == 0) && 
    237227                 (pic_order_cnt_lsb != prev_pic_order_cnt_lsb || 
    238228                  delta_pic_order_cnt_bottom != 
    … … bool H264Parser::new_AU(void) 
    256246    prev_pic_parameter_set_id = pic_parameter_set_id; 
    257247    prev_field_pic_flag = field_pic_flag; 
    258248    prev_bottom_field_flag = bottom_field_flag; 
    259     prev_nal_ref_idc = nal_ref_idc; 
    260249    prev_pic_order_cnt_lsb = pic_order_cnt_lsb; 
    261250    prev_delta_pic_order_cnt_bottom = delta_pic_order_cnt_bottom; 
    262251    prev_delta_pic_order_cnt[0] = delta_pic_order_cnt[0]; 
    … … uint32_t H264Parser::addBytes(const uint 
    273262{ 
    274263    const uint8_t *byteP = bytes; 
    275264    const uint8_t *endP = bytes + byte_count; 
    276  
     265    const uint8_t *nalP; 
    277266    uint8_t        first_byte; 
    278267 
    279268    state_changed = false; 
    … … uint32_t H264Parser::addBytes(const uint 
    305294  11 End of stream end_of_stream_rbsp( ) 
    306295*/ 
    307296            first_byte = *(byteP - 1); 
    308             NAL_type = first_byte & 0x1f; 
     297            nal_unit_type = first_byte & 0x1f; 
    309298            nal_ref_idc = (first_byte >> 5) & 0x3; 
    310299 
    311             if (NALisSlice(NAL_type) || NAL_type == SPS || NAL_type == PPS) 
     300            if (nal_unit_type == SPS || nal_unit_type == PPS || 
     301                nal_unit_type == SEI || NALisSlice(nal_unit_type)) 
    312302            { 
    313303                /* 
    314304                  bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE 
    … … uint32_t H264Parser::addBytes(const uint 
    318308                { 
    319309                    init_get_bits(&gb, byteP, 8 * (endP - byteP)); 
    320310 
    321                     if (NAL_type == SPS) 
     311                    if (nal_unit_type == SEI) 
     312                    { 
     313                        nalP = ff_find_start_code(byteP+1, endP, 
     314                                                  &sync_accumulator) - 8; 
     315                        decode_SEI(&gb, (nalP - byteP) * 8); 
     316                        set_AU_pending(stream_offset); 
     317                    } 
     318                    else if (nal_unit_type == SPS) 
     319                    { 
    322320                        decode_SPS(&gb); 
    323                     else if (NAL_type == PPS) 
     321                        set_AU_pending(stream_offset); 
     322                    } 
     323                    else if (nal_unit_type == PPS) 
     324                    { 
    324325                        decode_PPS(&gb); 
     326                        set_AU_pending(stream_offset); 
     327                    } 
    325328                    else 
    326                         find_AU = decode_Header(&gb); 
     329                    { 
     330                        decode_Header(&gb); 
     331                        if (new_AU()) 
     332                            set_AU_pending(stream_offset); 
     333                    } 
    327334 
    328335                    byteP += (get_bits_count(&gb) / 8); 
    329336                } 
    330337            } 
    331  
    332             if (find_AU && new_AU()) 
     338            else if (!AU_pending) 
    333339            { 
    334                 /* After finding a new AU, don't look for another one 
    335                    until we decode a SLICE */ 
    336                 find_AU = false; 
    337                 AU_pending = true; 
    338                 AU_offset = stream_offset; 
     340                if (nal_unit_type == AU_DELIMITER || 
     341                    (nal_unit_type > SPS_EXT && 
     342                     nal_unit_type < AUXILIARY_SLICE)) 
     343                { 
     344                    AU_pending = true; 
     345                    AU_offset = stream_offset; 
     346                } 
     347                else if ((nal_ref_idc == 0 || prev_nal_ref_idc == 0) && 
     348                         nal_ref_idc != prev_nal_ref_idc) 
     349                { 
     350                    AU_pending = true; 
     351                    AU_offset = stream_offset; 
     352                } 
    339353            } 
    340              
    341             if (AU_pending && NALisSlice(NAL_type)) 
     354 
     355            if (AU_pending && NALisSlice(nal_unit_type)) 
    342356            { 
    343357                /* Once we know the slice type of a new AU, we can 
    344358                 * determine if it is a keyframe or just a frame */ 
    … … uint32_t H264Parser::addBytes(const uint 
    349363                on_frame = true; 
    350364                frame_start_offset = AU_offset; 
    351365 
    352                 if (isKeySlice(slice_type) && (!wait_for_IDR || seen_IDR)) 
     366                if (is_keyframe) 
    353367                { 
    354368                    on_key_frame = true; 
    355369                    keyframe_start_offset = AU_offset; 
     370                    is_keyframe = false; 
    356371                } 
    357372                else 
    358373                    on_key_frame = false; 
    … … uint32_t H264Parser::addBytes(const uint 
    360375            else 
    361376                on_frame = on_key_frame = false; 
    362377 
     378            prev_nal_ref_idc = nal_ref_idc; 
     379 
    363380            return byteP - bytes; 
    364381        } 
    365382    } 
    … … bool H264Parser::decode_Header(GetBitCon 
    440457    */ 
    441458 
    442459    frame_num = get_bits(gb, log2_max_frame_num); 
    443     if (NAL_type == SLICE_IDR || frame_num == 0) 
    444         seen_IDR = true; 
    445460 
    446461    /* 
    447462      field_pic_flag equal to 1 specifies that the slice is a slice of a 
    … … bool H264Parser::decode_Header(GetBitCon 
    475490      second such IDR access unit. The value of idr_pic_id shall be in 
    476491      the range of 0 to 65535, inclusive. 
    477492     */ 
     493 
    478494    if (nal_unit_type == SLICE_IDR) 
     495    { 
     496        is_keyframe = true; 
    479497        idr_pic_id = get_ue_golomb(gb); 
     498    } 
     499    else 
     500        is_keyframe |= (I_is_keyframe && isKeySlice(slice_type)); 
    480501 
    481502    /* 
    482503      pic_order_cnt_lsb specifies the picture order count modulo 
    … … void H264Parser::decode_PPS(GetBitContex 
    806827#endif 
    807828} 
    808829 
     830void H264Parser::decode_SEI(GetBitContext * gb, int bitlen) 
     831{ 
     832    int   recovery_frame_cnt = -1; 
     833    bool  exact_match_flag = false; 
     834    bool  broken_link_flag = false; 
     835    int   changing_group_slice_idc = -1; 
     836 
     837    while (get_bits_count(gb) < bitlen) 
     838    { 
     839        int type = 0, size = 0; 
     840 
     841        do { 
     842            type += show_bits(gb, 8); 
     843        } while (get_bits(gb, 8) == 255); 
     844 
     845        do { 
     846            size += show_bits(gb, 8); 
     847        } while (get_bits(gb, 8) == 255); 
     848 
     849        switch (type) 
     850        { 
     851          case SEI_TYPE_RECOVERY_POINT: 
     852            recovery_frame_cnt = get_ue_golomb(gb); 
     853            exact_match_flag = get_bits1(gb); 
     854            broken_link_flag = get_bits1(gb); 
     855            changing_group_slice_idc = get_bits(gb, 2); 
     856            is_keyframe |= (recovery_frame_cnt >= 0); 
     857            return; 
     858 
     859          default: 
     860            skip_bits(gb, size * 8); 
     861            break; 
     862        } 
     863 
     864        align_get_bits(gb); 
     865    } 
     866} 
     867 
    809868void H264Parser::vui_parameters(GetBitContext * gb) 
    810869{ 
    811870    /* 

  • libs/libmythtv/mpeg/H264Parser.h

    old new class H264Parser { 
    5353        AUXILIARY_SLICE = 19 
    5454    }; 
    5555 
     56    enum SEI_type { 
     57        SEI_TYPE_PIC_TIMING             = 1, 
     58        SEI_TYPE_USER_DATA_UNREGISTERED = 5, 
     59        SEI_TYPE_RECOVERY_POINT         = 6 
     60    }; 
     61 
    5662    /* 
    5763      slice_type values in the range 5..9 specify, in addition to the 
    5864      coding type of the current slice, that all other slices of the 
    … … class H264Parser { 
    9096 
    9197    bool stateChanged(void) const { return state_changed; } 
    9298 
    93     // seenIDR implies that a SPS has also been seen 
    94     bool seenIDR(void) const { return seen_IDR; } 
    95     uint8_t lastNALtype(void) const { return NAL_type; } 
     99    uint8_t lastNALtype(void) const { return nal_unit_type; } 
    96100 
    97101    frame_type FieldType(void) const 
    98102        { 
    … … class H264Parser { 
    130134                    nal_type == SLICE_IDR); 
    131135        } 
    132136 
    133     void waitForIDR(bool wait) { wait_for_IDR = wait; } 
     137    void use_I_forKeyframes(bool val) { I_is_keyframe = val; } 
    134138 
    135139  private: 
    136140    enum constants {EXTENDED_SAR = 255}; 
    137141 
    138     bool is_first_VCL_NAL_unit(void); 
     142    inline void set_AU_pending(const uint64_t & stream_offset) 
     143        { 
     144            if (!AU_pending) 
     145            { 
     146                AU_pending = true; 
     147                AU_offset = stream_offset; 
     148            } 
     149        } 
     150 
    139151    bool new_AU(void); 
    140152    bool decode_Header(GetBitContext *gb); 
    141153    void decode_SPS(GetBitContext *gb); 
    142154    void decode_PPS(GetBitContext * gb); 
     155    void decode_SEI(GetBitContext * gb, int len); 
    143156    void vui_parameters(GetBitContext * gb); 
    144157 
    145     bool       find_AU; 
    146158    bool       AU_pending; 
    147159    bool       state_changed; 
    148160    bool       seen_sps; 
    149     bool       seen_IDR; 
     161    bool       is_keyframe; 
     162    bool       I_is_keyframe; 
    150163 
    151164    uint32_t   sync_accumulator; 
    152165    GetBitContext gb; 
    153166 
    154     uint8_t    NAL_type; 
    155  
    156167    int        prev_frame_num, frame_num; 
    157168    uint       slice_type; 
    158169    int        prev_pic_parameter_set_id, pic_parameter_set_id; 
    … … class H264Parser { 
    188199 
    189200    uint64_t   AU_offset, frame_start_offset, keyframe_start_offset; 
    190201    bool       on_frame, on_key_frame; 
    191  
    192     bool       wait_for_IDR; 
    193202}; 
    194203 
    195204#endif /* H264PARSER_H */ 

  • libs/libmythtv/mpegrecorder.cpp

    old new bool MpegRecorder::OpenV4L2DeviceAsInput 
    423423            bzero(_stream_id,  sizeof(_stream_id)); 
    424424            bzero(_pid_status, sizeof(_pid_status)); 
    425425            memset(_continuity_counter, 0xff, sizeof(_continuity_counter)); 
     426            m_h264_parser.use_I_forKeyframes(true); 
    426427        } 
    427428        else 
    428429        { 
    … … void MpegRecorder::ResetForNewFile(void) 
    13731374    bzero(_stream_id,  sizeof(_stream_id)); 
    13741375    bzero(_pid_status, sizeof(_pid_status)); 
    13751376    memset(_continuity_counter, 0xff, sizeof(_continuity_counter)); 
    1376  
    1377     m_h264_parser.waitForIDR(true); 
    13781377} 
    13791378 
    13801379void MpegRecorder::Reset(void)