falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
80367 Commits
32 Branches
283MB
Tree: b51d5c99b8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b51d5c99b8'
${ noResults }
FFmpeg/libavcodec/h264_parse.c

322 lines
11KB
Raw Blame History 

  1. /*

  2.  * This file is part of FFmpeg.

  3.  *

  4.  * FFmpeg is free software; you can redistribute it and/or

  5.  * modify it under the terms of the GNU Lesser General Public

  6.  * License as published by the Free Software Foundation; either

  7.  * version 2.1 of the License, or (at your option) any later version.

  8.  *

  9.  * FFmpeg is distributed in the hope that it will be useful,

  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  12.  * Lesser General Public License for more details.

  13.  *

  14.  * You should have received a copy of the GNU Lesser General Public

  15.  * License along with FFmpeg; if not, write to the Free Software

  16.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  17.  */

  18. 

  19. #include "get_bits.h"

  20. #include "golomb.h"

  21. #include "h264.h"

  22. #include "h264_parse.h"

  23. 

  24. int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,

  25.                               const int *ref_count, int slice_type_nos,

  26.                               H264PredWeightTable *pwt)

  27. {

  28.     int list, i;

  29.     int luma_def, chroma_def;

  30. 

  31.     pwt->use_weight             = 0;

  32.     pwt->use_weight_chroma      = 0;

  33.     pwt->luma_log2_weight_denom = get_ue_golomb(gb);

  34.     if (sps->chroma_format_idc)

  35.         pwt->chroma_log2_weight_denom = get_ue_golomb(gb);

  36. 

  37.     if (pwt->luma_log2_weight_denom > 7U) {

  38.         av_log(NULL, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", pwt->luma_log2_weight_denom);

  39.         pwt->luma_log2_weight_denom = 0;

  40.     }

  41.     if (pwt->chroma_log2_weight_denom > 7U) {

  42.         av_log(NULL, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom);

  43.         pwt->chroma_log2_weight_denom = 0;

  44.     }

  45. 

  46.     luma_def   = 1 << pwt->luma_log2_weight_denom;

  47.     chroma_def = 1 << pwt->chroma_log2_weight_denom;

  48. 

  49.     for (list = 0; list < 2; list++) {

  50.         pwt->luma_weight_flag[list]   = 0;

  51.         pwt->chroma_weight_flag[list] = 0;

  52.         for (i = 0; i < ref_count[list]; i++) {

  53.             int luma_weight_flag, chroma_weight_flag;

  54. 

  55.             luma_weight_flag = get_bits1(gb);

  56.             if (luma_weight_flag) {

  57.                 pwt->luma_weight[i][list][0] = get_se_golomb(gb);

  58.                 pwt->luma_weight[i][list][1] = get_se_golomb(gb);

  59.                 if (pwt->luma_weight[i][list][0] != luma_def ||

  60.                     pwt->luma_weight[i][list][1] != 0) {

  61.                     pwt->use_weight             = 1;

  62.                     pwt->luma_weight_flag[list] = 1;

  63.                 }

  64.             } else {

  65.                 pwt->luma_weight[i][list][0] = luma_def;

  66.                 pwt->luma_weight[i][list][1] = 0;

  67.             }

  68. 

  69.             if (sps->chroma_format_idc) {

  70.                 chroma_weight_flag = get_bits1(gb);

  71.                 if (chroma_weight_flag) {

  72.                     int j;

  73.                     for (j = 0; j < 2; j++) {

  74.                         pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb);

  75.                         pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb);

  76.                         if (pwt->chroma_weight[i][list][j][0] != chroma_def ||

  77.                             pwt->chroma_weight[i][list][j][1] != 0) {

  78.                             pwt->use_weight_chroma        = 1;

  79.                             pwt->chroma_weight_flag[list] = 1;

  80.                         }

  81.                     }

  82.                 } else {

  83.                     int j;

  84.                     for (j = 0; j < 2; j++) {

  85.                         pwt->chroma_weight[i][list][j][0] = chroma_def;

  86.                         pwt->chroma_weight[i][list][j][1] = 0;

  87.                     }

  88.                 }

  89.             }

  90.         }

  91.         if (slice_type_nos != AV_PICTURE_TYPE_B)

  92.             break;

  93.     }

  94.     pwt->use_weight = pwt->use_weight || pwt->use_weight_chroma;

  95.     return 0;

  96. }

  97. 

  98. /**

  99.  * Check if the top & left blocks are available if needed and

  100.  * change the dc mode so it only uses the available blocks.

  101.  */

  102. int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx,

  103.                                      int top_samples_available, int left_samples_available)

  104. {

  105.     static const int8_t top[12] = {

  106.         -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0

  107.     };

  108.     static const int8_t left[12] = {

  109.         0, -1, TOP_DC_PRED, 0, -1, -1, -1, 0, -1, DC_128_PRED

  110.     };

  111.     int i;

  112. 

  113.     if (!(top_samples_available & 0x8000)) {

  114.         for (i = 0; i < 4; i++) {

  115.             int status = top[pred_mode_cache[scan8[0] + i]];

  116.             if (status < 0) {

  117.                 av_log(logctx, AV_LOG_ERROR,

  118.                        "top block unavailable for requested intra mode %d\n",

  119.                        status);

  120.                 return AVERROR_INVALIDDATA;

  121.             } else if (status) {

  122.                 pred_mode_cache[scan8[0] + i] = status;

  123.             }

  124.         }

  125.     }

  126. 

  127.     if ((left_samples_available & 0x8888) != 0x8888) {

  128.         static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 };

  129.         for (i = 0; i < 4; i++)

  130.             if (!(left_samples_available & mask[i])) {

  131.                 int status = left[pred_mode_cache[scan8[0] + 8 * i]];

  132.                 if (status < 0) {

  133.                     av_log(logctx, AV_LOG_ERROR,

  134.                            "left block unavailable for requested intra4x4 mode %d\n",

  135.                            status);

  136.                     return AVERROR_INVALIDDATA;

  137.                 } else if (status) {

  138.                     pred_mode_cache[scan8[0] + 8 * i] = status;

  139.                 }

  140.             }

  141.     }

  142. 

  143.     return 0;

  144. }

  145. 

  146. /**

  147.  * Check if the top & left blocks are available if needed and

  148.  * change the dc mode so it only uses the available blocks.

  149.  */

  150. int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available,

  151.                                   int left_samples_available,

  152.                                   int mode, int is_chroma)

  153. {

  154.     static const int8_t top[4]  = { LEFT_DC_PRED8x8, 1, -1, -1 };

  155.     static const int8_t left[5] = { TOP_DC_PRED8x8, -1,  2, -1, DC_128_PRED8x8 };

  156. 

  157.     if (mode > 3U) {

  158.         av_log(logctx, AV_LOG_ERROR,

  159.                "out of range intra chroma pred mode\n");

  160.         return AVERROR_INVALIDDATA;

  161.     }

  162. 

  163.     if (!(top_samples_available & 0x8000)) {

  164.         mode = top[mode];

  165.         if (mode < 0) {

  166.             av_log(logctx, AV_LOG_ERROR,

  167.                    "top block unavailable for requested intra mode\n");

  168.             return AVERROR_INVALIDDATA;

  169.         }

  170.     }

  171. 

  172.     if ((left_samples_available & 0x8080) != 0x8080) {

  173.         mode = left[mode];

  174.         if (mode < 0) {

  175.             av_log(logctx, AV_LOG_ERROR,

  176.                    "left block unavailable for requested intra mode\n");

  177.             return AVERROR_INVALIDDATA;

  178.         }

  179.         if (is_chroma && (left_samples_available & 0x8080)) {

  180.             // mad cow disease mode, aka MBAFF + constrained_intra_pred

  181.             mode = ALZHEIMER_DC_L0T_PRED8x8 +

  182.                    (!(left_samples_available & 0x8000)) +

  183.                    2 * (mode == DC_128_PRED8x8);

  184.         }

  185.     }

  186. 

  187.     return mode;

  188. }

  189. 

  190. int ff_h264_parse_ref_count(int *plist_count, int ref_count[2],

  191.                             GetBitContext *gb, const PPS *pps,

  192.                             int slice_type_nos, int picture_structure, void *logctx)

  193. {

  194.     int list_count;

  195.     int num_ref_idx_active_override_flag;

  196. 

  197.     // set defaults, might be overridden a few lines later

  198.     ref_count[0] = pps->ref_count[0];

  199.     ref_count[1] = pps->ref_count[1];

  200. 

  201.     if (slice_type_nos != AV_PICTURE_TYPE_I) {

  202.         unsigned max[2];

  203.         max[0] = max[1] = picture_structure == PICT_FRAME ? 15 : 31;

  204. 

  205.         num_ref_idx_active_override_flag = get_bits1(gb);

  206. 

  207.         if (num_ref_idx_active_override_flag) {

  208.             ref_count[0] = get_ue_golomb(gb) + 1;

  209.             if (slice_type_nos == AV_PICTURE_TYPE_B) {

  210.                 ref_count[1] = get_ue_golomb(gb) + 1;

  211.             } else

  212.                 // full range is spec-ok in this case, even for frames

  213.                 ref_count[1] = 1;

  214.         }

  215. 

  216.         if (ref_count[0] - 1 > max[0] || ref_count[1] - 1 > max[1]) {

  217.             av_log(logctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n",

  218.                    ref_count[0] - 1, max[0], ref_count[1] - 1, max[1]);

  219.             ref_count[0] = ref_count[1] = 0;

  220.             *plist_count = 0;

  221.             goto fail;

  222.         }

  223. 

  224.         if (slice_type_nos == AV_PICTURE_TYPE_B)

  225.             list_count = 2;

  226.         else

  227.             list_count = 1;

  228.     } else {

  229.         list_count   = 0;

  230.         ref_count[0] = ref_count[1] = 0;

  231.     }

  232. 

  233.     *plist_count = list_count;

  234. 

  235.     return 0;

  236. fail:

  237.     *plist_count = 0;

  238.     ref_count[0] = 0;

  239.     ref_count[1] = 0;

  240.     return AVERROR_INVALIDDATA;

  241. }

  242. 

  243. int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc,

  244.                      const SPS *sps, H264POCContext *pc,

  245.                      int picture_structure, int nal_ref_idc)

  246. {

  247.     const int max_frame_num = 1 << sps->log2_max_frame_num;

  248.     int field_poc[2];

  249. 

  250.     pc->frame_num_offset = pc->prev_frame_num_offset;

  251.     if (pc->frame_num < pc->prev_frame_num)

  252.         pc->frame_num_offset += max_frame_num;

  253. 

  254.     if (sps->poc_type == 0) {

  255.         const int max_poc_lsb = 1 << sps->log2_max_poc_lsb;

  256. 

  257.         if (pc->poc_lsb < pc->prev_poc_lsb &&

  258.             pc->prev_poc_lsb - pc->poc_lsb >= max_poc_lsb / 2)

  259.             pc->poc_msb = pc->prev_poc_msb + max_poc_lsb;

  260.         else if (pc->poc_lsb > pc->prev_poc_lsb &&

  261.                  pc->prev_poc_lsb - pc->poc_lsb < -max_poc_lsb / 2)

  262.             pc->poc_msb = pc->prev_poc_msb - max_poc_lsb;

  263.         else

  264.             pc->poc_msb = pc->prev_poc_msb;

  265.         field_poc[0] =

  266.         field_poc[1] = pc->poc_msb + pc->poc_lsb;

  267.         if (picture_structure == PICT_FRAME)

  268.             field_poc[1] += pc->delta_poc_bottom;

  269.     } else if (sps->poc_type == 1) {

  270.         int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;

  271.         int i;

  272. 

  273.         if (sps->poc_cycle_length != 0)

  274.             abs_frame_num = pc->frame_num_offset + pc->frame_num;

  275.         else

  276.             abs_frame_num = 0;

  277. 

  278.         if (nal_ref_idc == 0 && abs_frame_num > 0)

  279.             abs_frame_num--;

  280. 

  281.         expected_delta_per_poc_cycle = 0;

  282.         for (i = 0; i < sps->poc_cycle_length; i++)

  283.             // FIXME integrate during sps parse

  284.             expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i];

  285. 

  286.         if (abs_frame_num > 0) {

  287.             int poc_cycle_cnt          = (abs_frame_num - 1) / sps->poc_cycle_length;

  288.             int frame_num_in_poc_cycle = (abs_frame_num - 1) % sps->poc_cycle_length;

  289. 

  290.             expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;

  291.             for (i = 0; i <= frame_num_in_poc_cycle; i++)

  292.                 expectedpoc = expectedpoc + sps->offset_for_ref_frame[i];

  293.         } else

  294.             expectedpoc = 0;

  295. 

  296.         if (nal_ref_idc == 0)

  297.             expectedpoc = expectedpoc + sps->offset_for_non_ref_pic;

  298. 

  299.         field_poc[0] = expectedpoc + pc->delta_poc[0];

  300.         field_poc[1] = field_poc[0] + sps->offset_for_top_to_bottom_field;

  301. 

  302.         if (picture_structure == PICT_FRAME)

  303.             field_poc[1] += pc->delta_poc[1];

  304.     } else {

  305.         int poc = 2 * (pc->frame_num_offset + pc->frame_num);

  306. 

  307.         if (!nal_ref_idc)

  308.             poc--;

  309. 

  310.         field_poc[0] = poc;

  311.         field_poc[1] = poc;

  312.     }

  313. 

  314.     if (picture_structure != PICT_BOTTOM_FIELD)

  315.         pic_field_poc[0] = field_poc[0];

  316.     if (picture_structure != PICT_TOP_FIELD)

  317.         pic_field_poc[1] = field_poc[1];

  318.     *pic_poc = FFMIN(pic_field_poc[0], pic_field_poc[1]);

  319. 

  320.     return 0;

  321. }