plm_video_decode_macroblock()

void fl::third_party::plm_video_decode_macroblock

(

plm_video_t *

self

)

Definition at line 2479 of file pl_mpeg.hpp.

                                                                {
    // Decode increment
    int increment = 0;
    int t = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
 
    while (t == 34) {
        // macroblock_stuffing
        t = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
    }
    while (t == 35) {
        // macroblock_escape
        increment += 33;
        t = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
    }
    increment += t;
 
    // Process any skipped macroblocks
    if (self->slice_begin) {
        // The first increment of each slice is relative to beginning of the
        // previous row, not the previous macroblock
        self->slice_begin = FALSE;
        self->macroblock_address += increment;
    }
    else {
        if (self->macroblock_address + increment >= self->mb_size) {
            return; // invalid
        }
        if (increment > 1) {
            // Skipped macroblocks reset DC predictors
            self->dc_predictor[0] = 128;
            self->dc_predictor[1] = 128;
            self->dc_predictor[2] = 128;
 
            // Skipped macroblocks in P-pictures reset motion vectors
            if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) {
                self->motion_forward.h = 0;
                self->motion_forward.v = 0;
            }
        }
 
        // Predict skipped macroblocks
        while (increment > 1) {
            self->macroblock_address++;
            self->mb_row = self->macroblock_address / self->mb_width;
            self->mb_col = self->macroblock_address % self->mb_width;
 
            plm_video_predict_macroblock(self);
            increment--;
        }
        self->macroblock_address++;
    }
 
    self->mb_row = self->macroblock_address / self->mb_width;
    self->mb_col = self->macroblock_address % self->mb_width;
 
    if (self->mb_col >= self->mb_width || self->mb_row >= self->mb_height) {
        return; // corrupt stream;
    }
 
    // Process the current macroblock
    const plm_vlc_t *table = PLM_VIDEO_MACROBLOCK_TYPE[self->picture_type];
    self->macroblock_type = plm_buffer_read_vlc(self->buffer, table);
 
    self->macroblock_intra = (self->macroblock_type & 0x01);
    self->motion_forward.is_set = (self->macroblock_type & 0x08);
    self->motion_backward.is_set = (self->macroblock_type & 0x04);
 
    // Quantizer scale
    if ((self->macroblock_type & 0x10) != 0) {
        self->quantizer_scale = plm_buffer_read(self->buffer, 5);
    }
 
    if (self->macroblock_intra) {
        // Intra-coded macroblocks reset motion vectors
        self->motion_backward.h = self->motion_forward.h = 0;
        self->motion_backward.v = self->motion_forward.v = 0;
    }
    else {
        // Non-intra macroblocks reset DC predictors
        self->dc_predictor[0] = 128;
        self->dc_predictor[1] = 128;
        self->dc_predictor[2] = 128;
 
        plm_video_decode_motion_vectors(self);
        plm_video_predict_macroblock(self);
    }
 
    // Decode blocks
    int cbp = ((self->macroblock_type & 0x02) != 0)
        ? plm_buffer_read_vlc(self->buffer, PLM_VIDEO_CODE_BLOCK_PATTERN)
        : (self->macroblock_intra ? 0x3f : 0);
 
    for (int block = 0, mask = 0x20; block < 6; block++) {
        if ((cbp & mask) != 0) {
            plm_video_decode_block(self, block);
        }
        mask >>= 1;
    }
}

References FALSE, FL_NOEXCEPT, plm_buffer_read(), plm_buffer_read_vlc(), PLM_VIDEO_CODE_BLOCK_PATTERN, plm_video_decode_block(), plm_video_decode_motion_vectors(), PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT, PLM_VIDEO_MACROBLOCK_TYPE, PLM_VIDEO_PICTURE_TYPE_PREDICTIVE, plm_video_predict_macroblock(), and fl::t.

Referenced by plm_video_decode_slice().

Here is the call graph for this function:

Here is the caller graph for this function: