Useful Python Scripts

Content:

1. Removal Specific SEI Message from H264/AVC Elementary Stream
2.  Get H264/AVC Video Statistics from Transport Stream
3.  Get Picture Statistics From HEVC/H.264 Elementary Stream
4.  Extract a Selected GOP starting at CRA in HEVC/H.265 Elementary Stream
5.  Print High-Level Syntax Elements (SPS/PPS) in HEVC/H.265 Elementary Stream
6.  Modify Aspect Ratio Parameters in HEVC/H.265 Elementary Stream
7.  Detect Discontinuities in frame_num cadence in AVC/H.264 elementary stream
8.  Removal of Non-Reference Frames from H.264/AVC Elementary Stream in order to Reduce Bitrate
9.  Enhancement of  Random Access Ability of H.264/AVC Stream by Insertion of SPS/PPS at IDR frames
10.  Remove Frames Until First Key Frame in H.264/AVC File
11.  Get DTS Statistics of both Video and Audio in MPEG2 System (Transport) Stream
12.  Get H265/HEVC Video Statistics from Transport Stream
13.  Remove AUDs (Access Unit Delimiters) from H.264/AVC and H.265/HEVC Elementary Stream
14.   Print pic_parameter_set_id of each frame in H.264/AVC stream, relevant if multiple PPS are present

   15.  Print weighted prediction parameters per frame/slice (for H.264/AVC) streams,  adapted for Python 3.x

   16.  Parse SPS and Print Resolution (H.264/AVC), adapted for Python 3.x

    17.  Get Number Slices in H.264/HEVC Streams, adapted for Python 3.x

    18.   Parse SPS and Print Custom Scaling Matrices (if present) in H.264/AVC, adapted for Python 3.x

    19.   Compare SPS in H264/AVC stream, adapted for Python 3.x

20.   Get Instant Bitrates from H264 File, adapted for Python 3.x

21.   Get Instant Bitrates from HEVC File, adapted for Python 3.x

22. Remove Specific SEI Messages from HEVC File, Python 3.x

23.  Get Meta Data of HEVC Stream in MP4-file, Python 3.x

24.  Detect Large Frames in H264/AVC Elementary Stream, Python 3.x

25. Detect Large Frames in HEVC Elementary Stream, Python 3.x

26.  Find Video Track Number in mp4-file, Python 3.x

27.  Print Mpegts Packets Payload Sizes,  Python 3.x

28.   Cut H264/AVC Elementary Stream at Specified IDR,  Python 3.x

29.   Count Short Start-Codes,  Python 3.x

30.   Parse PNG Image Format, Python 3.x

31.   Parse Slice Header and Print Weighted Prediction Parameters H264, Python 3.x

32.  Get PSNR, SSIM and VIFP with sewar package, Python 3.x

33.   Print NAL Headers of HEVC Elementary Stream, Python 3.x

34.  Remove NALU with Given nal_unit_type from H264 Elementary Stream,  Python 3.x

*Additional python scripts to analyze MPEG-System stream (Transport Stream) are housed at the following page “Python Scripts to Analyze and Process Transport Stream“

Part of scripts written in Python 2.x

 

 

Removal Specific SEI Message from H264/AVC Elementary Stream

The script RemoveSeiInH264Stream.py  tailored to remove SEI messages specified by sei_type (e.g. sei_type=0 is buffering period SEI message).

Note: with ffmpeg you can remove all SEI NALUs regardless to sei_type:

 

The removal process of the python script  is not in-place therefore the output stream must be different from the input one.

If the input stream does not contain a specified sei_type then no output stream is generated. Notice that most of SEI messages carry auxiliary information and can be removed from the stream (although the appearence of video might be affected in some cases).

Example [ removal of SEI messages with sei_type=0 ]

• The input stream does not contain SEI message with sei_type=5

• The input stream contains SEI message with sei_type=0

This script can be useful to adapt a video stream to be playable by Microsoft Media Player (since SEI bueffering period prior to SPS makes the stream not playable.

 

---

 

Get H264/AVC Video Statistics from Transport Stream

The script   GetAVCVideoStatsFromTS.py   (adapted for python 2.x) and

GetAVCVideoStatsFromTSVer3.py (adapted for python 3.x)

is tailored to pick statistics (frame size, dts/pts. frame duration etc.) from video AVC/H.264 stream comprised in Mpeg System container ( Transport format files usually ending with ‘.ts’). It’s worth mentioning that the frame start is detected if a video ts-packet contains the PES header with the timestamp DTS (to avoid counting of frame slices).

Usage:

 -i           input ts-file, a section of ts-stream can be provided (even without SPS/PPS, unlike to ‘ffmpeg’)

 -v          print pts, dts and sizes of each video frame (default false)

 -a          ignore AUD (Access Unit Delimiter) violations (AUD is mandatory in Transport Stream but sometimes AUDs are absent and most of players copes with that violation),   default  false

  -p          print progress  bar (the length is 80), default false. If verbose is ON then the progress bar disappears. 

Examples:

[Print Number of detected frames, if AUD is absent a corresponding error reported  ]

---

Get Picture Statistics From HEVC/H.264 Elementary Stream

HEVC Case:

The scripts GetPictureStatsHevc.py (adapted to python 2.x) and GetPictureStatsHevcVer3.py (adapted to Python 3.x)

gathers and prints frame starts and offsets (in hex) as well as frame types.

Usage:

 

 

Note:

ffprobe is declared as supporting computation of the average bitrate, but for elementary streams ffprobe provides nothing

ffprobe -v quiet -show_entries stream=bit_rate -of default=noprint_wrappers=1 test.h264
bit_rate=N/A

Moreover, i found that for mpegts streams results of ffprobe bitrate computation are wrong, for test.ts with video bitrate ~5Mbps, ffprobe shows incorrect result:

ffprobe -v quiet -show_entries stream=bit_rate -of default=noprint_wrappers=1 test.ts
bit_rate=192141
bit_rate=N/A
bit_rate=192141
bit_rate=N/A

 

In addition there are two free bitrate viewers:

• https://www.videohelp.com/software/Bitrate-Viewer-2

 

• Bitrate viewer based on ffprobe (actually GUI version of ffprobe) – ffmpeg bitrate viewer:

————————————————————————————————————————————————-

Usage:

-i                                              input hevc-file
-n                                            number frames to process, if 0 then the whole stream processed
-v                                            verbose mode (default false)
-p                                            print progress (default false), set fault if verbose is ON
-f                                            frame rate (integer), default 60
–overlap                               overlaping window with hop of frame duration (default false)
–winsize                             window size in seconds for calculation instant bitrate (default 1)

 

Example:

python GetHevcBitrate.py -i crowd_2Mbps_deadzone_50_ver2.hevc -f 50

number of frames 500

non-overlap windowing, window size 1s, average bitrate (Mbps) 2.1179, maxbitrate (Mbps) 3.7076

 

————————————————————————————————————————————————-

Remove Specific SEI Messages from HEVC File

Sometimes SEI messages in HEVC/H.265 streams get redundant (or even can mislead decoders). Therefore i provide the script RemoveSeiFromHevcStream.py to remove all SEI messages from the input HEVC/H.265 elementary stream (“SEI thinning”)

The script works at GOP level (to be easy in future to parallel it), the script reads the whole GOP, analyzes it, removes SEIs and writes SEI-free GOP to output file.

Usage:

-i             input hevc fifo or file
-o           output hevc tiled stream
-v           whether to print naltypes and offsets (default false)

Example:

 python RemoveSeiFromHevcStream.py -i test.h265 -o qwert.h265
gop 0, address  0x0
gop 1, address  0xd2535
gop 2, address  0x146657
removed seis  31

 

———————————————————————————————————————————————————————————————————

Get Meta Data of HEVC Stream in MP4-file

The script GetMetaHevcHdr searches video track in mp4-file and checks whether the track contains hevc-stream (‘hev1’ or ‘hvc1’ are present). If hevc-stream is presnt then hvcC-box is parsed and the stream’s information printed:

Usage:

-i      input mp4-file containing hevc stream
-d     dump headers vps, sps and pps as vps.bin, sps.bin and pps.bin (default false),  note – strat code ’00 00 00 01′ added.

 

Example:

python GetMetaHevcHdr.py -i strange.mp4

 

C:\Tools>python GetMetaHevcHdr.py -i strange.mp4

video trak number 0
resolution 1920×1080
Configuration Version 0x1
profile Main
compatibility_flags 60000000
progressive_source_flag 0
interlaced_source_flag 0
non_packed_constraint_flag 0
frame_only_constraint_flag 0
level_idc 0x78 (120)
min_spatial_segmentation_idc 0x0
parallelismType 0
chromaFormat 1
luma_bit_depth 8
chroma_bit_depth 8
avgFrameRate 0
constantFrameRate 0
numTemporalLayers 3
temporalIdNested 0
nal_unit_size 4
high level headers 3

Hexstr 0x20
array_completeness 0
header type VPS
nal_count 1
hdr_len 30

Hexstr 0x21
array_completeness 0
header type SPS
nal_count 1
hdr_len 66

Hexstr 0x22
array_completeness 0
header type PPS
nal_count 1
hdr_len 9

---

Detect Large Frames in H264/AVC Elementary Stream

We determine large frames as frames with sizes exceeding much the expected size for a given bitrate. Such spike frames can impact on latency and cause network congestions. I-frames or P-frames at a scene cut or a flaw in Rate Control can generate large frames. 

It’s obvious that the stream should be generated by an encoder configured with CBR mode or in VBR mode. If the encoder is configured with CRF or constant QP mode then frame size fluctuations are caused by the complexity of scenes.

The script DetectLargeFramesInH264     is tailored to detect large frames in h264/avc elementary stream. This script works in dual-pass mode, in the first pass it gathers statisitics and in the second pass the script processes collected data. In addition to number of large frames the scripts compute average and peak bitrates (taken over the window of 1s).

This script is dedicated to check Rate Control in CBR/VBR modes.

Usage:

-i        input h264-file
-n       number frames to process, if 0 then the whole stream processed
-s       skip first frames due to ubstability Rate Control at the start, default 0
-t        target bitrate in Mbps, default 10Mbps
-v        verbose mode, print numbers of large frames (default false)
-f         frame rate, default 60
-a        large frame scale factor, when the size of a frame in bytes exceeds ‘factor’ x ‘expected_size’ it is called Large Frame, default 1.5x above the expected

 

Example [ find large frames exceeding the expectd size by 1.5x or more, the traget bitrate is 10Mbps, the frame rate 60fps, skip first 10 frames due to instability of Rate Control at the start]

python DetectLargeFramesInH264.py -i test_vbr_10Mbps.h264 -s 10 -t 10 -v -f 60 -a 1.5

Expected frame size 20833 bytes
number of frames 765
62 frame type pb frame size 31432 (expected 20833)
387 frame type pb frame size 33387 (expected 20833)
480 frame type idr frame size 31412 (expected 20833)
540 frame type idr frame size 32222 (expected 20833)
660 frame type idr frame size 32998 (expected 20833)
720 frame type idr frame size 34312 (expected 20833)

average bitrate (Mbps) 9.5568, peak bitrate (Mbps) 9.9682

number Large Frames (scale threshold 1.500000) 6

 

Note:  frame type is either ‘idr’ or ‘pb’ including P,B or non-IDR I-frame

---

Detect Large Frames in HEVC Elementary Stream

Description is similar to that of h264 case – Detect Large Frames in H264/AVC Elementary Stream

The script DetectLargeFramesInHEVC    is tailored to detect large frames in hevc elementary stream. This script works in dual-pass mode, in the first pass it gathers statisitics and in the second pass the script processes collected data. In addition to number of large frames the scripts compute average and peak bitrates (taken over the window of 1s).

This script is dedicated to check Rate Control in CBR/VBR modes.

Usage:

-i        input hevc-file
-n       number frames to process, if 0 then the whole stream processed
-s       skip first frames due to ubstability Rate Control at the start, default 0
-t        target bitrate in Mbps, default 10Mbps
-v        verbose mode, print numbers of large frames (default false)
-f         frame rate, default 60
-a        large frame scale factor, when the size of a frame in bytes exceeds ‘factor’ x ‘expected_size’ it is called Large Frame, default 1.5x above the expected

 

Example [ find large frames exceeding the expectd size by 1.4x or more, the traget bitrate is 15Mbps, the frame rate 60fps]

python DetectLargeFramesInHEVC.py -i  test_vbr_15M.h265 -s 0 -t 15 -v -f 60 -a 1.4

Expected frame size 31250 bytes
number of frames 557
0 frame type idr frame size 43967 (expected 31250)
148 frame type pb frame size 45329 (expected 31250)
478 frame type pb frame size 44949 (expected 31250)
549 frame type pb frame size 44957 (expected 31250)

average bitrate (Mbps) 13.4108, peak bitrate (Mbps) 14.9510

number Large Frames (scale threshold 1.400000) 4

 

Note:  frame type is either ‘idr’ or ‘pb’ including P,B, I, CRA

 

---

Find Video Track Number in mp4-file

The script GetVideoTrakNo.py  (adapted for Python 3.x) , looks for the video track (actually for  the first video track) in mp4-file’s metadata and prints the track number (counted from one, not from zero, the reason MP4Box tool uses track numbers counted from 1).

Example:

python GetVideoTrakNo.py test.mp4
Video Track 1

 

Note:

video track can have number 2 or even higher.

Example:

python GetVideoTrakNo.py  box.mp4
Video Track 2

mp4box -info box.mp4

* Movie Info *
Timescale 90000 – Duration 00:00:15.184
Fragmented File no – 2 track(s)
File Brand isom – version 0
Created: GMT Mon Jun 09 15:54:39 2014

File has no MPEG4 IOD/OD

Track # 1 Info – TrackID 1 – TimeScale 44100 – Duration 00:00:15.123
Media Info: Language “Undetermined” – Type “soun:mp4a” – 579 samples
MPEG-4 Config: Audio Stream – ObjectTypeIndication 0x6b
MPEG-1 Audio – 1 Channel(s) – SampleRate 44100 – Layer 2
Self-synchronized

Track # 2 Info – TrackID 2 – TimeScale 1000000 – Duration 00:00:15.217
Media Info: Language “Undetermined” – Type “vide:avc1” – 456 samples
Visual Track layout: x=0 y=0 width=640 height=480
MPEG-4 Config: Visual Stream – ObjectTypeIndication 0x21
AVC/H264 Video – Visual Size 640 x 480
AVC Info: 1 SPS – 1 PPS – Profile High @ Level 3
NAL Unit length bits: 32
Pixel Aspect Ratio 1:1 – Indicated track size 640 x 480
Synchronized on stream 1

 

---

 

Print Mpegts Packets Payload Sizes

The script PrintPayloadSize.py (adapted for Python 3.x) , traverses mpegts file until PAT/PMT found, then the script parses PAT/PMT to figire out video PID (h264 or hevc).

Then the scripts parses video mpegts packets and prints payload sizes (incl. PES headers).

Usage:

-i       input mpegts-file (must contain video – h264 or hevc)
-n     number of mpegts video packets to parse, if 0 then all, (default 0)

Note: For each packet three magnitudes are printed out:

packet number       video packet number     payload size in bytes

its commonly mpegts contains not only video packets, therefore packet number differs from video packet number.

Example [ process first 200 video packets]:

python PrintPayloadSize.py -i   test_real_clock.ts -n 200

Pkt 1588, vpkt 0, mpegts-payload 182   // first video packet is 1588 packet from the beginning of the file and has payload 182 (due to adaptation field, since it’s a frame start)
Pkt 1589, vpkt 1, mpegts-payload 184
Pkt 1590, vpkt 2, mpegts-payload 184
Pkt 1591, vpkt 3, mpegts-payload 184
…
Pkt 1773, vpkt 180, mpegts-payload 184
Pkt 1774, vpkt 181, mpegts-payload 184
Pkt 1775, vpkt 182, mpegts-payload 184
Pkt 1776, vpkt 183, mpegts-payload 184
Pkt 1777, vpkt 184, mpegts-payload 184
Pkt 1778, vpkt 185, mpegts-payload 81   // the last packet in a frame, the payload size is not 184
Pkt 1779, vpkt 186, mpegts-payload 182   // the first packet in the next frame
Pkt 1780, vpkt 187, mpegts-payload 184
Pkt 1781, vpkt 188, mpegts-payload 184
Pkt 1782, vpkt 189, mpegts-payload 184
Pkt 1783, vpkt 190, mpegts-payload 184
Pkt 1784, vpkt 191, mpegts-payload 184
Pkt 1785, vpkt 192, mpegts-payload 184
Pkt 1786, vpkt 193, mpegts-payload 184
Pkt 1787, vpkt 194, mpegts-payload 184
Pkt 1788, vpkt 195, mpegts-payload 184
Pkt 1789, vpkt 196, mpegts-payload 184
Pkt 1790, vpkt 197, mpegts-payload 184
Pkt 1791, vpkt 198, mpegts-payload 184
Pkt 1792, vpkt 199, mpegts-payload 184

 

 

---

 

Cut H264/AVC Elementary Stream at Specified IDR

The python script CutH264AtIDR.py  traverses the input stream until it detects k-th IDR (specified in the command line), then the script cuts the input stream at this IDR and the tail is saved as output h264 stream. 

Usage: 

 -i         input h264-file

 -o        output h264-file, cut at the specified k-th IDR

  -n       IDR number to cut (k-th IDR), must be greater 1, default 2 (i.e. at the second IDR to cut)

 

Examples:

python CutH264.py -i test.h264 -o test_tail.h264 -n 2

2-th idr found at offset 0x2c303a8, frame 3342

If k-th IDR not found then the output file is empty and a corresponding print is issued, e.g

python CutH264.py -i test.h264 -o test_tail.h264 -n 20

20-th idr not found, empty output file

 

---

 

Count Short Start-Codes

The H264/AVC spec. contains two types of start-codes:  long (32 bits, 00 00 00 01) and short (24 bits, 00 00 01)

During my career, once I was faced with a peculiar  h264 decoder which ignored short start-codes (and respected long start codes). This decoder could not find the slice start if the start code was short.

I share the python script CountShortStartCodesInH264.py which detects and count short start codes in h264 file. In addtion this script counts the number of frames.

 

Usage:

-i          input h264 file
-v         verbose mode, print offset of short start code (default false)
-n         number frames to process, if 0 then the whole stream processed

 

Example:

python CountShortStartCodesInH264.py -i  battlefield_hp_cbr16_10M.h264

number of detected frames 557
number of short start codes 1672

Note:  why number of start codes is greater than the number of frames? In the given stream each frame is divided into four slices. Thus each frame contains four start codes.

 

Example (process two frames in verbose mode)

python CountShortStartCodesInH264.py -i battlefield_hp_cbr16_10M.h264 -n 2 -v

short start code at offset 4467 (0x1173)
short start code at offset 8600 (0x2198)
short start code at offset 15524 (0x3ca4)
short start code at offset 20005 (0x4e25)

number of detected frames 2
number of short start codes 4

 

---

 

Parse PNG Image Format

 

PNG is still-popular lossless format, despite it was developed at the middle of 90x.  PNG file consists of chunks (control and data), each chunk ends with 4-bytes CRC code. Thus, the png-format is highly error resilient. 

The python script ParsePNSG , adapted for 3.x version, is tailored to parse PNG file.

 

Example:

python ParsePNG.py -i intra-modes.png

 

chunk name: IHDR
chunk size: 13, offset 0x8
width 632
height 677
bit-depth 8
palette used 0
color image 1

chunk name: sRGB
chunk size: 1, offset 0x21

chunk name: gAMA
chunk size: 4, offset 0x2e

chunk name: pHYs
chunk size: 9, offset 0x3e

chunk name: IDAT
chunk size: 65445, offset 0x53

chunk name: IDAT
chunk size: 65524, offset 0x10004

chunk name: IDAT
chunk size: 65524, offset 0x20004

chunk name: IDAT
chunk size: 65524, offset 0x30004

chunk name: IDAT
chunk size: 65524, offset 0x40004

chunk name: IDAT
chunk size: 51084, offset 0x50004

number of chunks 10

————————————————————————————————————————————————————-

Parse Slice Header and Print Weighted Prediction Parameters, H.264

The weighted prediction was adopted by H.264/AVC. In some video sequences, in particular those containg fading between scenes, the current picture  is more strongly correlated to a reference picture scaled by a weighting factor.

The python script PrintWeightsH264  gets as input H.264/AVC stream and parses SPS, PPS and slice headers. The script prints the weghted prediction information if it’s present in the slice header.

Usage:

-i         input h264-file
-n        number frames to process, if 0 then the whole stream processed, default 0
-v        verbose mode, print SPS and PPS info (default false)

Example [encode 4 frames in verbose mode (i.e. printing SPS and PPS)]:

python PrintWeightsH264.py    -i test.h264    -n 3     -v

SPS
profile_idc 100
level_idc    50 
sps_id          0
log2_max_frame_num 4
log2_max_pic_order_cnt 10
max_num_ref_frames 1
gaps_in_frame_num_value_allowed_flag 0
pic_width_in_mbs 120
pic_width_in_mbs 68
frame_mbs_only_flag 1
direct_8x8_inference_flag 1

PPS
pps_id 0
sps_id 0
bottom_field_pic_order_in_frame_present_flag 0
num_ref_idx_l0 1
num_ref_idx_l1 1
weighted_pred_flag 1
weighted_bipred_idc 0
pic_init_qp 26
chroma_qp_index_offset 0
deblocking_filter_control_present_flag 0
constrained_intra_pred_flag 0

Frame 0

Slice
first_mb 0
slice type I
pps_id 0
frame_num 0
idr_idx 0
POC 0

Frame 1

Slice
first_mb 0
slice type P
pps_id 0
frame_num 1
POC 2
override flag 0
ref_pic_list_modification_flag_l0 0
luma_log2_weight_denom 5
chroma_log2_weight_denom 5
luma_weight_l0_flag 1
luma_weight_l0 33
luma_offset_l0 -2
chroma_weight_l0_flag 0

 

Frame 2

Slice
first_mb 0
slice type P
pps_id 0
frame_num 2
POC 4
override flag 0
ref_pic_list_modification_flag_l0 0
luma_log2_weight_denom 5
chroma_log2_weight_denom 5
luma_weight_l0_flag 0
chroma_weight_l0_flag 0

 

Frame 3

Slice
first_mb 0
slice type P
pps_id 0
frame_num 3
POC 6
override flag 0
ref_pic_list_modification_flag_l0 0
luma_log2_weight_denom 5
chroma_log2_weight_denom 5
luma_weight_l0_flag 0
chroma_weight_l0_flag 0

 

————————————————————————————————————————————————————-

Get PSNR, SSIM and VIFP (Visual Information Fidelity) with sewar package

The ‘sewar’ package contains different image and video quality metrics (PSNR,SSIM,MS-SSIM,VIFP etc.).

To install ‘sewar’ type: pip install sewar

The scripts GetPsnr.py , GetSSIM.py and GetVifp.py take as input reference and deformed yuv420p@8bpp video sequences and computes PSNR, SSIM and VIFP (Visual Information Fidelity) score per picture.

Usage:

-f                reference yuv-sequence (yuv420p@8bpp)
-d               deformed yuv-sequence (yuv420p@8bpp) 
-n               number of frames to process, if 0 then all frames, default 0
--width      width in pixels, must be even
--height     height in pixels, must be even

 

Example [ compute psnr values of first 10 frames]

python GetPsnr.py --width 1920 --height 1080 -f Fifa17_1920x1080.yuv -d fifa_hp_cbr16_10M.yuv -n 10

frame 0, psnr 30.53
frame 1, psnr 32.48
frame 2, psnr 33.20
frame 3, psnr 34.46
frame 4, psnr 33.86
frame 5, psnr 33.63
frame 6, psnr 33.35
frame 7, psnr 33.09
frame 8, psnr 32.88
frame 9, psnr 32.60

average psnr 33.01

 

Example [ compute SSIM values of first 10 frames]

python GetSsim.py --width 1920 --height 1080 -f Fifa17_1920x1080.yuv -d fifa_hp_cbr16_10M.yuv -n 10

frame 0, ssim 0.84
frame 1, ssim 0.87
frame 2, ssim 0.89
frame 3, ssim 0.91
frame 4, ssim 0.90
frame 5, ssim 0.90
frame 6, ssim 0.90
frame 7, ssim 0.90
frame 8, ssim 0.89
frame 9, ssim 0.89

average ssim 0.89

 

Example [ compute VIFP scores of first 10 frames]

python GetVifp.py --width 1920 --height 1080 -f Fifa17_1920x1080.yuv -d fifa_hp_cbr16_10M.yuv -n 10

frame 0, vifp 0.29
frame 1, vifp 0.36
frame 2, vifp 0.40
frame 3, vifp 0.44
frame 4, vifp 0.43
frame 5, vifp 0.43
frame 6, vifp 0.43
frame 7, vifp 0.42
frame 8, vifp 0.42
frame 9, vifp 0.41

average vifp 0.40

Note: to get (or to extract) yuv-sequence from encoded stream i use ffmpeg tool:

ffmpeg -i fifa_hp_cbr16_15M.h264 -pixel_format yuv420p -frames 100 -y fifa_hp_cbr16_15M.yuv

 

 

————————————————————————————————————————————————————-

Print NAL Headers of HEVC Elementary Stream

The python script GetHevcNalTypes.py takes input HEVC elementary stream and print NAL unit types and layer IDs (relevant for scalable streams). 

If layerID (nuh_layer_id) is non-zero then NAL data belong to enchancement layer, if layerID=0 then the current NAL unit belongs to base layer.

Usage:

-i  input hevc file
-n  number of frames to process, if 0 then all, (default 0)

 

Example:  dual SNR scalable stream

python GetHevcNalTypes.py -i dual_layer.h265

nal-type 32 VPS, layerId 0
nal-type 33 SPS, layerId 0
nal-type 33 SPS, layerId 1
nal-type 34 PPS, layerId 0
nal-type 19 IDR, layerId 0
nal-type 34 PPS, layerId 1
nal-type 19 IDR, layerId 1
nal-type 1 PB, layerId 0
nal-type 5 STSA, layerId 1
nal-type 1 PB, layerId 0
nal-type 5 STSA, layerId 1
nal-type 1 PB, layerId 0
nal-type 5 STSA, layerId 1
nal-type 1 PB, layerId 0
...
nal-type 5 STSA, layerId 1
nal-type 1 PB, layerId 0
nal-type 5 STSA, layerId 1
nal-type 1 PB, layerId 0
nal-type 5 STSA, layerId 1
nal-type 1 PB, layerId 0
nal-type 5 STSA, layerId 1

 

 

————————————————————————————————————————————————————-

Remove NALU with Given nal_unit_type from H264 Elementary Stream

There are situations when it’s required to remove NALU with a specific nal_unit_type (e.g. NALUs belonging to an enhanced layer in scalable h264).

The script RemoveNalTypeInH264Stream.py is tailored to remove NALUs with given nal_unit_type.

 

Usage:

RemoveNalTypeInH264Stream.py    input.h264   nal_unit_type   output.h264

 

Example [remove NALUs with user-defined nal_unit_type=0x1F (31 in decimal)]:

python RemoveNalTypeInH264Stream.py   tomoishicheck.h264    31    out.h264
Nal units to remove 2223