~ubuntu-branches/ubuntu/raring/libav/raring-security

0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,

};

static const uint8_t div6[QP_MAX_NUM+1]={

0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9,10,10,10,10,

};

static const enum PixelFormat hwaccel_pixfmt_list_h264_jpeg_420[] = {

PIX_FMT_DXVA2_VLD,

PIX_FMT_VAAPI_VLD,

PIX_FMT_YUVJ420P,

PIX_FMT_NONE

};

void ff_h264_write_back_intra_pred_mode(H264Context *h){

int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];

AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);

mode[4]= h->intra4x4_pred_mode_cache[7+8*3];

mode[5]= h->intra4x4_pred_mode_cache[7+8*2];

mode[6]= h->intra4x4_pred_mode_cache[7+8*1];

}

/**

* checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.

int ff_h264_check_intra4x4_pred_mode(H264Context *h){

MpegEncContext * const s = &h->s;

static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};

static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};

int i;

if(!(h->top_samples_available&0x8000)){

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

int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];

if(status<0){

av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);

return -1;

} else if(status){

h->intra4x4_pred_mode_cache[scan8[0] + i]= status;

}

if((h->left_samples_available&0x8888)!=0x8888){

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

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

if(!(h->left_samples_available&mask[i])){

int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];

if(status<0){

av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);

100

return -1;

101

} else if(status){

102

h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;

103

}

104

}

105

}

106

}

107

108

return 0;

109

} //FIXME cleanup like ff_h264_check_intra_pred_mode

110

111

/**

112

* checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.

113

114

int ff_h264_check_intra_pred_mode(H264Context *h, int mode){

115

MpegEncContext * const s = &h->s;

116

static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};

117

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

118

119

if(mode > 6U) {

120

av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y);

121

return -1;

122

}

123

124

if(!(h->top_samples_available&0x8000)){

125

mode= top[ mode ];

126

if(mode<0){

127

av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);

128

return -1;

129

}

130

}

131

132

if((h->left_samples_available&0x8080) != 0x8080){

133

mode= left[ mode ];

134

if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred

135

mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);

136

}

137

if(mode<0){

138

av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);

139

return -1;

140

}

141

}

142

143

return mode;

144

}

145

146

const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){

147

int i, si, di;

148

uint8_t *dst;

149

int bufidx;

150

151

// src[0]&0x80; //forbidden bit

152

h->nal_ref_idc= src[0]>>5;

153

h->nal_unit_type= src[0]&0x1F;

154

155

src++; length--;

156

157

#if HAVE_FAST_UNALIGNED

158

# if HAVE_FAST_64BIT

159

# define RS 7

160

for(i=0; i+1<length; i+=9){

161

if(!((~AV_RN64A(src+i) & (AV_RN64A(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))

162

# else

163

# define RS 3

164

for(i=0; i+1<length; i+=5){

165

if(!((~AV_RN32A(src+i) & (AV_RN32A(src+i) - 0x01000101U)) & 0x80008080U))

166

# endif

167

continue;

168

if(i>0 && !src[i]) i--;

169

while(src[i]) i++;

170

#else

171

# define RS 0

172

for(i=0; i+1<length; i+=2){

173

if(src[i]) continue;

174

if(i>0 && src[i-1]==0) i--;

175

#endif

176

if(i+2<length && src[i+1]==0 && src[i+2]<=3){

177

if(src[i+2]!=3){

178

/* startcode, so we must be past the end */

179

length=i;

180

}

181

break;

182

}

183

i-= RS;

184

}

185

186

if(i>=length-1){ //no escaped 0

187

*dst_length= length;

188

*consumed= length+1; //+1 for the header

189

return src;

190

}

191

192

bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data

193

av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);

194

dst= h->rbsp_buffer[bufidx];

195

196

if (dst == NULL){

197

return NULL;

198

}

199

200

//printf("decoding esc\n");

201

memcpy(dst, src, i);

202

si=di=i;

203

while(si+2<length){

204

//remove escapes (very rare 1:2^22)

205

if(src[si+2]>3){

206

dst[di++]= src[si++];

207

dst[di++]= src[si++];

208

}else if(src[si]==0 && src[si+1]==0){

209

if(src[si+2]==3){ //escape

210

dst[di++]= 0;

211

dst[di++]= 0;

212

si+=3;

213

continue;

214

}else //next start code

215

goto nsc;

216

}

217

218

dst[di++]= src[si++];

219

}

220

while(si<length)

221

dst[di++]= src[si++];

222

nsc:

223

224

memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);

225

226

*dst_length= di;

227

*consumed= si + 1;//+1 for the header

228

//FIXME store exact number of bits in the getbitcontext (it is needed for decoding)

229

return dst;

230

}

231

232

/**

233

* Identify the exact end of the bitstream

234

* @return the length of the trailing, or 0 if damaged

235

236

static int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){

237

int v= *src;

238

int r;

239

240

tprintf(h->s.avctx, "rbsp trailing %X\n", v);

241

242

for(r=1; r<9; r++){

243

if(v&1) return r;

244

v>>=1;

245

}

246

return 0;

247

}

248

249

static inline int get_lowest_part_list_y(H264Context *h, Picture *pic, int n, int height,

250

int y_offset, int list){

251

int raw_my= h->mv_cache[list][ scan8[n] ][1];

252

int filter_height= (raw_my&3) ? 2 : 0;

253

int full_my= (raw_my>>2) + y_offset;

254

int top = full_my - filter_height, bottom = full_my + height + filter_height;

255

256

return FFMAX(abs(top), bottom);

257

}

258

259

static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n, int height,

260

int y_offset, int list0, int list1, int *nrefs){

261

MpegEncContext * const s = &h->s;

262

int my;

263

264

y_offset += 16*(s->mb_y >> MB_FIELD);

265

266

if(list0){

267

int ref_n = h->ref_cache[0][ scan8[n] ];

268

Picture *ref= &h->ref_list[0][ref_n];

269

270

// Error resilience puts the current picture in the ref list.

271

// Don't try to wait on these as it will cause a deadlock.

272

// Fields can wait on each other, though.

273

if(ref->thread_opaque != s->current_picture.thread_opaque ||

274

(ref->reference&3) != s->picture_structure) {

275

my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);

276

if (refs[0][ref_n] < 0) nrefs[0] += 1;

277

refs[0][ref_n] = FFMAX(refs[0][ref_n], my);

278

}

279

}

280

281

if(list1){

282

int ref_n = h->ref_cache[1][ scan8[n] ];

283

Picture *ref= &h->ref_list[1][ref_n];

284

285

if(ref->thread_opaque != s->current_picture.thread_opaque ||

286

(ref->reference&3) != s->picture_structure) {

287

my = get_lowest_part_list_y(h, ref, n, height, y_offset, 1);

288

if (refs[1][ref_n] < 0) nrefs[1] += 1;

289

refs[1][ref_n] = FFMAX(refs[1][ref_n], my);

290

}

291

}

292

}

293

294

/**

295

* Wait until all reference frames are available for MC operations.

296

297

* @param h the H264 context

298

299

static void await_references(H264Context *h){

300

MpegEncContext * const s = &h->s;

301

const int mb_xy= h->mb_xy;

302

const int mb_type= s->current_picture.mb_type[mb_xy];

303

int refs[2][48];

304

int nrefs[2] = {0};

305

int ref, list;

306

307

memset(refs, -1, sizeof(refs));

308

309

if(IS_16X16(mb_type)){

310

get_lowest_part_y(h, refs, 0, 16, 0,

311

IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);

312

}else if(IS_16X8(mb_type)){

313

get_lowest_part_y(h, refs, 0, 8, 0,

314

IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);

315

get_lowest_part_y(h, refs, 8, 8, 8,

316

IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);

317

}else if(IS_8X16(mb_type)){

318

get_lowest_part_y(h, refs, 0, 16, 0,

319

IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);

320

get_lowest_part_y(h, refs, 4, 16, 0,

321

IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);

322

}else{

323

int i;

324

325

assert(IS_8X8(mb_type));

326

327

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

328

const int sub_mb_type= h->sub_mb_type[i];

329

const int n= 4*i;

330

int y_offset= (i&2)<<2;

331

332

if(IS_SUB_8X8(sub_mb_type)){

333

get_lowest_part_y(h, refs, n , 8, y_offset,

334

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

335

}else if(IS_SUB_8X4(sub_mb_type)){

336

get_lowest_part_y(h, refs, n , 4, y_offset,

337

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

338

get_lowest_part_y(h, refs, n+2, 4, y_offset+4,

339

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

340

}else if(IS_SUB_4X8(sub_mb_type)){

341

get_lowest_part_y(h, refs, n , 8, y_offset,

342

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

343

get_lowest_part_y(h, refs, n+1, 8, y_offset,

344

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

345

}else{

346

int j;

347

assert(IS_SUB_4X4(sub_mb_type));

348

for(j=0; j<4; j++){

349

int sub_y_offset= y_offset + 2*(j&2);

350

get_lowest_part_y(h, refs, n+j, 4, sub_y_offset,

351

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);

352

}

353

}

354

}

355

}

356

357

for(list=h->list_count-1; list>=0; list--){

358

for(ref=0; ref<48 && nrefs[list]; ref++){

359

int row = refs[list][ref];

360

if(row >= 0){

361

Picture *ref_pic = &h->ref_list[list][ref];

362

int ref_field = ref_pic->reference - 1;

363

int ref_field_picture = ref_pic->field_picture;

364

int pic_height = 16*s->mb_height >> ref_field_picture;

365

366

row <<= MB_MBAFF;

367

nrefs[list]--;

368

369

if(!FIELD_PICTURE && ref_field_picture){ // frame referencing two fields

370

ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);

371

ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) , pic_height-1), 0);

372

}else if(FIELD_PICTURE && !ref_field_picture){ // field referencing one field of a frame

373

ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field , pic_height-1), 0);

374

}else if(FIELD_PICTURE){

375

ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);

376

}else{

377

ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);

378

}

379

}

380

}

381

}

382

}

383

384

#if 0

385

/**

386

* DCT transforms the 16 dc values.

387

* @param qp quantization parameter ??? FIXME

388

389

static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){

390

// const int qmul= dequant_coeff[qp][0];

391

int i;

392

int temp[16]; //FIXME check if this is a good idea

393

static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};

394

static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};

395

396

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

397

const int offset= y_offset[i];

398

const int z0= block[offset+stride*0] + block[offset+stride*4];

399

const int z1= block[offset+stride*0] - block[offset+stride*4];

400

const int z2= block[offset+stride*1] - block[offset+stride*5];

401

const int z3= block[offset+stride*1] + block[offset+stride*5];

402

403

temp[4*i+0]= z0+z3;

404

temp[4*i+1]= z1+z2;

405

temp[4*i+2]= z1-z2;

406

temp[4*i+3]= z0-z3;

407

}

408

409

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

410

const int offset= x_offset[i];

411

const int z0= temp[4*0+i] + temp[4*2+i];

412

const int z1= temp[4*0+i] - temp[4*2+i];

413

const int z2= temp[4*1+i] - temp[4*3+i];

414

const int z3= temp[4*1+i] + temp[4*3+i];

415

416

block[stride*0 +offset]= (z0 + z3)>>1;

417

block[stride*2 +offset]= (z1 + z2)>>1;

418

block[stride*8 +offset]= (z1 - z2)>>1;

419

block[stride*10+offset]= (z0 - z3)>>1;

420

}

421

}

422

#endif

423

424

#undef xStride

425

#undef stride

426

427

#if 0

428

static void chroma_dc_dct_c(DCTELEM *block){

429

const int stride= 16*2;

430

const int xStride= 16;

431

int a,b,c,d,e;

432

433

a= block[stride*0 + xStride*0];

434

b= block[stride*0 + xStride*1];

435

c= block[stride*1 + xStride*0];

436

d= block[stride*1 + xStride*1];

437

438

e= a-b;

439

a= a+b;

440

b= c-d;

441

c= c+d;

442

443

block[stride*0 + xStride*0]= (a+c);

444

block[stride*0 + xStride*1]= (e+b);

445

block[stride*1 + xStride*0]= (a-c);

446

block[stride*1 + xStride*1]= (e-b);

447

}

448

#endif

449

450

static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,

451

uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

452

int src_x_offset, int src_y_offset,

453

qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op,

454

int pixel_shift, int chroma444){

455

MpegEncContext * const s = &h->s;

456

const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;

457

int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;

458

const int luma_xy= (mx&3) + ((my&3)<<2);

459

int offset = ((mx>>2) << pixel_shift) + (my>>2)*h->mb_linesize;

460

uint8_t * src_y = pic->data[0] + offset;

461

uint8_t * src_cb, * src_cr;

462

int extra_width= h->emu_edge_width;

463

int extra_height= h->emu_edge_height;

464

int emu=0;

465

const int full_mx= mx>>2;

466

const int full_my= my>>2;

467

const int pic_width = 16*s->mb_width;

468

const int pic_height = 16*s->mb_height >> MB_FIELD;

469

470

if(mx&7) extra_width -= 3;

471

if(my&7) extra_height -= 3;

472

473

if( full_mx < 0-extra_width

474

|| full_my < 0-extra_height

475

|| full_mx + 16/*FIXME*/ > pic_width + extra_width

476

|| full_my + 16/*FIXME*/ > pic_height + extra_height){

477

s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_y - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);

478

src_y= s->edge_emu_buffer + (2 << pixel_shift) + 2*h->mb_linesize;

479

emu=1;

480

}

481

482

qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?

483

if(!square){

484

qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);

485

}

486

487

if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;

488

489

if(chroma444){

490

src_cb = pic->data[1] + offset;

491

if(emu){

492

s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cb - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize,

493

16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);

494

src_cb= s->edge_emu_buffer + (2 << pixel_shift) + 2*h->mb_linesize;

495

}

496

qpix_op[luma_xy](dest_cb, src_cb, h->mb_linesize); //FIXME try variable height perhaps?

497

if(!square){

498

qpix_op[luma_xy](dest_cb + delta, src_cb + delta, h->mb_linesize);

499

}

500

501

src_cr = pic->data[2] + offset;

502

if(emu){

503

s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cr - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize,

504

16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);

505

src_cr= s->edge_emu_buffer + (2 << pixel_shift) + 2*h->mb_linesize;

506

}

507

qpix_op[luma_xy](dest_cr, src_cr, h->mb_linesize); //FIXME try variable height perhaps?

508

if(!square){

509

qpix_op[luma_xy](dest_cr + delta, src_cr + delta, h->mb_linesize);

510

}

511

return;

512

}

513

514

if(MB_FIELD){

515

// chroma offset when predicting from a field of opposite parity

516

my += 2 * ((s->mb_y & 1) - (pic->reference - 1));

517

emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);

518

}

519

src_cb= pic->data[1] + ((mx>>3) << pixel_shift) + (my>>3)*h->mb_uvlinesize;

520

src_cr= pic->data[2] + ((mx>>3) << pixel_shift) + (my>>3)*h->mb_uvlinesize;

521

522

if(emu){

523

s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);

524

src_cb= s->edge_emu_buffer;

525

}

526

chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);

527

528

if(emu){

529

s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);

530

src_cr= s->edge_emu_buffer;

531

}

532

chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);

533

}

534

535

static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,

536

uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

537

int x_offset, int y_offset,

538

qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

539

qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,

540

int list0, int list1, int pixel_shift, int chroma444){

541

MpegEncContext * const s = &h->s;

542

qpel_mc_func *qpix_op= qpix_put;

543

h264_chroma_mc_func chroma_op= chroma_put;

544

545

dest_y += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;

546

if(chroma444){

547

dest_cb += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;

548

dest_cr += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;

549

}else{

550

dest_cb += ( x_offset << pixel_shift) + y_offset*h->mb_uvlinesize;

551

dest_cr += ( x_offset << pixel_shift) + y_offset*h->mb_uvlinesize;

552

}

553

x_offset += 8*s->mb_x;

554

y_offset += 8*(s->mb_y >> MB_FIELD);

555

556

if(list0){

557

Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];

558

mc_dir_part(h, ref, n, square, chroma_height, delta, 0,

559

dest_y, dest_cb, dest_cr, x_offset, y_offset,

560

qpix_op, chroma_op, pixel_shift, chroma444);

561

562

qpix_op= qpix_avg;

563

chroma_op= chroma_avg;

564

}

565

566

if(list1){

567

Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];

568

mc_dir_part(h, ref, n, square, chroma_height, delta, 1,

569

dest_y, dest_cb, dest_cr, x_offset, y_offset,

570

qpix_op, chroma_op, pixel_shift, chroma444);

571

}

572

}

573

574

static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,

575

uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

576

int x_offset, int y_offset,

577

qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

578

h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,

579

h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,

580

int list0, int list1, int pixel_shift, int chroma444){

581

MpegEncContext * const s = &h->s;

582

583

dest_y += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;

584

if(chroma444){

585

chroma_weight_avg = luma_weight_avg;

586

chroma_weight_op = luma_weight_op;

587

dest_cb += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;

588

dest_cr += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;

589

}else{

590

dest_cb += ( x_offset << pixel_shift) + y_offset*h->mb_uvlinesize;

591

dest_cr += ( x_offset << pixel_shift) + y_offset*h->mb_uvlinesize;

592

}

593

x_offset += 8*s->mb_x;

594

y_offset += 8*(s->mb_y >> MB_FIELD);

595

596

if(list0 && list1){

597

/* don't optimize for luma-only case, since B-frames usually

598

* use implicit weights => chroma too. */

599

uint8_t *tmp_cb = s->obmc_scratchpad;

600

uint8_t *tmp_cr = s->obmc_scratchpad + (16 << pixel_shift);

601

uint8_t *tmp_y = s->obmc_scratchpad + 16*h->mb_uvlinesize;

602

int refn0 = h->ref_cache[0][ scan8[n] ];

603

int refn1 = h->ref_cache[1][ scan8[n] ];

604

605

mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,

606

dest_y, dest_cb, dest_cr,

607

x_offset, y_offset, qpix_put, chroma_put, pixel_shift, chroma444);

608

mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,

609

tmp_y, tmp_cb, tmp_cr,

610

x_offset, y_offset, qpix_put, chroma_put, pixel_shift, chroma444);

611

612

if(h->use_weight == 2){

613

int weight0 = h->implicit_weight[refn0][refn1][s->mb_y&1];

614

int weight1 = 64 - weight0;

615

luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0);

616

chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);

617

chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);

618

}else{

619

luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,

620

h->luma_weight[refn0][0][0] , h->luma_weight[refn1][1][0],

621

h->luma_weight[refn0][0][1] + h->luma_weight[refn1][1][1]);

622

chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,

623

h->chroma_weight[refn0][0][0][0] , h->chroma_weight[refn1][1][0][0],

624

h->chroma_weight[refn0][0][0][1] + h->chroma_weight[refn1][1][0][1]);

625

chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,

626

h->chroma_weight[refn0][0][1][0] , h->chroma_weight[refn1][1][1][0],

627

h->chroma_weight[refn0][0][1][1] + h->chroma_weight[refn1][1][1][1]);

628

}

629

}else{

630

int list = list1 ? 1 : 0;

631

int refn = h->ref_cache[list][ scan8[n] ];

632

Picture *ref= &h->ref_list[list][refn];

633

mc_dir_part(h, ref, n, square, chroma_height, delta, list,

634

dest_y, dest_cb, dest_cr, x_offset, y_offset,

635

qpix_put, chroma_put, pixel_shift, chroma444);

636

637

luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,

638

h->luma_weight[refn][list][0], h->luma_weight[refn][list][1]);

639

if(h->use_weight_chroma){

640

chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,

641

h->chroma_weight[refn][list][0][0], h->chroma_weight[refn][list][0][1]);

642

chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,

643

h->chroma_weight[refn][list][1][0], h->chroma_weight[refn][list][1][1]);

644

}

645

}

646

}

647

648

static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,

649

uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

650

int x_offset, int y_offset,

651

qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

652

qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,

653

h264_weight_func *weight_op, h264_biweight_func *weight_avg,

654

int list0, int list1, int pixel_shift, int chroma444){

655

if((h->use_weight==2 && list0 && list1

656

&& (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ][h->s.mb_y&1] != 32))

657

|| h->use_weight==1)

658

mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,

659

x_offset, y_offset, qpix_put, chroma_put,

660

weight_op[0], weight_op[3], weight_avg[0],

661

weight_avg[3], list0, list1, pixel_shift, chroma444);

662

else

663

mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,

664

x_offset, y_offset, qpix_put, chroma_put, qpix_avg,

665

chroma_avg, list0, list1, pixel_shift, chroma444);

666

}

667

668

static inline void prefetch_motion(H264Context *h, int list, int pixel_shift, int chroma444){

669

/* fetch pixels for estimated mv 4 macroblocks ahead

670

* optimized for 64byte cache lines */

671

MpegEncContext * const s = &h->s;

672

const int refn = h->ref_cache[list][scan8[0]];

673

if(refn >= 0){

674

const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;

675

const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;

676

uint8_t **src= h->ref_list[list][refn].data;

677

int off= (mx << pixel_shift) + (my + (s->mb_x&3)*4)*h->mb_linesize + (64 << pixel_shift);

678

s->dsp.prefetch(src[0]+off, s->linesize, 4);

679

if(chroma444){

680

s->dsp.prefetch(src[1]+off, s->linesize, 4);

681

s->dsp.prefetch(src[2]+off, s->linesize, 4);

682

}else{

683

off= ((mx>>1) << pixel_shift) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + (64 << pixel_shift);

684

s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);

685

}

686

}

687

}

688

689

static av_always_inline void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

690

qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),

691

qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),

692

h264_weight_func *weight_op, h264_biweight_func *weight_avg,

693

int pixel_shift, int chroma444){

694

MpegEncContext * const s = &h->s;

695

const int mb_xy= h->mb_xy;

696

const int mb_type= s->current_picture.mb_type[mb_xy];

697

698

assert(IS_INTER(mb_type));

699

700

if(HAVE_PTHREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))

701

await_references(h);

702

prefetch_motion(h, 0, pixel_shift, chroma444);

703

704

if(IS_16X16(mb_type)){

705

mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,

706

qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],

707

weight_op, weight_avg,

708

IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),

709

pixel_shift, chroma444);

710

}else if(IS_16X8(mb_type)){

711

mc_part(h, 0, 0, 4, 8 << pixel_shift, dest_y, dest_cb, dest_cr, 0, 0,

712

qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],

713

&weight_op[1], &weight_avg[1],

714

IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),

715

pixel_shift, chroma444);

716

mc_part(h, 8, 0, 4, 8 << pixel_shift, dest_y, dest_cb, dest_cr, 0, 4,

717

qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],

718

&weight_op[1], &weight_avg[1],

719

IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1),

720

pixel_shift, chroma444);

721

}else if(IS_8X16(mb_type)){

722

mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,

723

qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

724

&weight_op[2], &weight_avg[2],

725

IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),

726

pixel_shift, chroma444);

727

mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,

728

qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

729

&weight_op[2], &weight_avg[2],

730

IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1),

731

pixel_shift, chroma444);

732

}else{

733

int i;

734

735

assert(IS_8X8(mb_type));

736

737

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

738

const int sub_mb_type= h->sub_mb_type[i];

739

const int n= 4*i;

740

int x_offset= (i&1)<<2;

741

int y_offset= (i&2)<<1;

742

743

if(IS_SUB_8X8(sub_mb_type)){

744

mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,

745

qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

746

&weight_op[3], &weight_avg[3],

747

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),

748

pixel_shift, chroma444);

749

}else if(IS_SUB_8X4(sub_mb_type)){

750

mc_part(h, n , 0, 2, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset,

751

qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],

752

&weight_op[4], &weight_avg[4],

753

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),

754

pixel_shift, chroma444);

755

mc_part(h, n+2, 0, 2, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,

756

qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],

757

&weight_op[4], &weight_avg[4],

758

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),

759

pixel_shift, chroma444);

760

}else if(IS_SUB_4X8(sub_mb_type)){

761

mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,

762

qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

763

&weight_op[5], &weight_avg[5],

764

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),

765

pixel_shift, chroma444);

766

mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,

767

qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

768

&weight_op[5], &weight_avg[5],

769

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),

770

pixel_shift, chroma444);

771

}else{

772

int j;

773

assert(IS_SUB_4X4(sub_mb_type));

774

for(j=0; j<4; j++){

775

int sub_x_offset= x_offset + 2*(j&1);

776

int sub_y_offset= y_offset + (j&2);

777

mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,

778

qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

779

&weight_op[6], &weight_avg[6],

780

IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),

781

pixel_shift, chroma444);

782

}

783

}

784

}

785

}

786

787

prefetch_motion(h, 1, pixel_shift, chroma444);

788

}

789

790

#define hl_motion_fn(sh, bits) \

791

static av_always_inline void hl_motion_ ## bits(H264Context *h, \

792

uint8_t *dest_y, \

793

uint8_t *dest_cb, uint8_t *dest_cr, \

794

qpel_mc_func (*qpix_put)[16], \

795

h264_chroma_mc_func (*chroma_put), \

796

qpel_mc_func (*qpix_avg)[16], \

797

h264_chroma_mc_func (*chroma_avg), \

798

h264_weight_func *weight_op, \

799

h264_biweight_func *weight_avg, \

800

int chroma444) \

801

{ \

802

hl_motion(h, dest_y, dest_cb, dest_cr, qpix_put, chroma_put, \

803

qpix_avg, chroma_avg, weight_op, weight_avg, sh, chroma444); \

804

}

805

hl_motion_fn(0, 8);

806

hl_motion_fn(1, 16);

807

808

static void free_tables(H264Context *h, int free_rbsp){

809

int i;

810

H264Context *hx;

811

812

av_freep(&h->intra4x4_pred_mode);

813

av_freep(&h->chroma_pred_mode_table);

814

av_freep(&h->cbp_table);

815

av_freep(&h->mvd_table[0]);

816

av_freep(&h->mvd_table[1]);

817

av_freep(&h->direct_table);

818

av_freep(&h->non_zero_count);

819

av_freep(&h->slice_table_base);

820

h->slice_table= NULL;

821

av_freep(&h->list_counts);

822

823

av_freep(&h->mb2b_xy);

824

av_freep(&h->mb2br_xy);

825

826

for(i = 0; i < MAX_THREADS; i++) {

827

hx = h->thread_context[i];

828

if(!hx) continue;

829

av_freep(&hx->top_borders[1]);

830

av_freep(&hx->top_borders[0]);

831

av_freep(&hx->s.obmc_scratchpad);

832

if (free_rbsp){

833

av_freep(&hx->rbsp_buffer[1]);

834

av_freep(&hx->rbsp_buffer[0]);

835

hx->rbsp_buffer_size[0] = 0;

836

hx->rbsp_buffer_size[1] = 0;

837

}

838

if (i) av_freep(&h->thread_context[i]);

839

}

840

}

841

842

static void init_dequant8_coeff_table(H264Context *h){

843

int i,j,q,x;

844

const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);

845

846

for(i=0; i<6; i++ ){

847

h->dequant8_coeff[i] = h->dequant8_buffer[i];

848

for(j=0; j<i; j++){

849

if(!memcmp(h->pps.scaling_matrix8[j], h->pps.scaling_matrix8[i], 64*sizeof(uint8_t))){

850

h->dequant8_coeff[i] = h->dequant8_buffer[j];

851

break;

852

}

853

}

854

if(j<i)

855

continue;

856

857

for(q=0; q<max_qp+1; q++){

858

int shift = div6[q];

859

int idx = rem6[q];

860

for(x=0; x<64; x++)

861

h->dequant8_coeff[i][q][(x>>3)|((x&7)<<3)] =

862

((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *

863

h->pps.scaling_matrix8[i][x]) << shift;

864

}

865

}

866

}

867

868

static void init_dequant4_coeff_table(H264Context *h){

869

int i,j,q,x;

870

const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);

871

for(i=0; i<6; i++ ){

872

h->dequant4_coeff[i] = h->dequant4_buffer[i];

873

for(j=0; j<i; j++){

874

if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){

875

h->dequant4_coeff[i] = h->dequant4_buffer[j];

876

break;

877

}

878

}

879

if(j<i)

880

continue;

881

882

for(q=0; q<max_qp+1; q++){

883

int shift = div6[q] + 2;

884

int idx = rem6[q];

885

for(x=0; x<16; x++)

886

h->dequant4_coeff[i][q][(x>>2)|((x<<2)&0xF)] =

887

((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *

888

h->pps.scaling_matrix4[i][x]) << shift;

889

}

890

}

891

}

892

893

static void init_dequant_tables(H264Context *h){

894

int i,x;

895

init_dequant4_coeff_table(h);

896

if(h->pps.transform_8x8_mode)

897

init_dequant8_coeff_table(h);

898

if(h->sps.transform_bypass){

899

for(i=0; i<6; i++)

900

for(x=0; x<16; x++)

901

h->dequant4_coeff[i][0][x] = 1<<6;

902

if(h->pps.transform_8x8_mode)

903

for(i=0; i<6; i++)

904

for(x=0; x<64; x++)

905

h->dequant8_coeff[i][0][x] = 1<<6;

906

}

907

}

908

909

910

int ff_h264_alloc_tables(H264Context *h){

911

MpegEncContext * const s = &h->s;

912

const int big_mb_num= s->mb_stride * (s->mb_height+1);

913

const int row_mb_num= 2*s->mb_stride*s->avctx->thread_count;

914

int x,y;

915

916

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode, row_mb_num * 8 * sizeof(uint8_t), fail)

917

918

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->non_zero_count , big_mb_num * 48 * sizeof(uint8_t), fail)

919

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base), fail)

920

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->cbp_table, big_mb_num * sizeof(uint16_t), fail)

921

922

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t), fail)

923

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[0], 16*row_mb_num * sizeof(uint8_t), fail);

924

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[1], 16*row_mb_num * sizeof(uint8_t), fail);

925

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->direct_table, 4*big_mb_num * sizeof(uint8_t) , fail);

926

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->list_counts, big_mb_num * sizeof(uint8_t), fail)

927

928

memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base));

929

h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;

930

931

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2b_xy , big_mb_num * sizeof(uint32_t), fail);

932

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2br_xy , big_mb_num * sizeof(uint32_t), fail);

933

for(y=0; y<s->mb_height; y++){

934

for(x=0; x<s->mb_width; x++){

935

const int mb_xy= x + y*s->mb_stride;

936

const int b_xy = 4*x + 4*y*h->b_stride;

937

938

h->mb2b_xy [mb_xy]= b_xy;

939

h->mb2br_xy[mb_xy]= 8*(FMO ? mb_xy : (mb_xy % (2*s->mb_stride)));

940

}

941

}

942

943

s->obmc_scratchpad = NULL;

944

945

if(!h->dequant4_coeff[0])

946

init_dequant_tables(h);

947

948

return 0;

949

fail:

950

free_tables(h, 1);

951

return -1;

952

}

953

954

/**

955

* Mimic alloc_tables(), but for every context thread.

956

957

static void clone_tables(H264Context *dst, H264Context *src, int i){

958

MpegEncContext * const s = &src->s;

959

dst->intra4x4_pred_mode = src->intra4x4_pred_mode + i*8*2*s->mb_stride;

960

dst->non_zero_count = src->non_zero_count;

961

dst->slice_table = src->slice_table;

962

dst->cbp_table = src->cbp_table;

963

dst->mb2b_xy = src->mb2b_xy;

964

dst->mb2br_xy = src->mb2br_xy;

965

dst->chroma_pred_mode_table = src->chroma_pred_mode_table;

966

dst->mvd_table[0] = src->mvd_table[0] + i*8*2*s->mb_stride;

967

dst->mvd_table[1] = src->mvd_table[1] + i*8*2*s->mb_stride;

968

dst->direct_table = src->direct_table;

969

dst->list_counts = src->list_counts;

970

971

dst->s.obmc_scratchpad = NULL;

972

ff_h264_pred_init(&dst->hpc, src->s.codec_id, src->sps.bit_depth_luma);

973

}

974

975

/**

976

* Init context

977

* Allocate buffers which are not shared amongst multiple threads.

978

979

static int context_init(H264Context *h){

980

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[0], h->s.mb_width * 16*3 * sizeof(uint8_t)*2, fail)

981

FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[1], h->s.mb_width * 16*3 * sizeof(uint8_t)*2, fail)

982

983

h->ref_cache[0][scan8[5 ]+1] = h->ref_cache[0][scan8[7 ]+1] = h->ref_cache[0][scan8[13]+1] =

984

h->ref_cache[1][scan8[5 ]+1] = h->ref_cache[1][scan8[7 ]+1] = h->ref_cache[1][scan8[13]+1] = PART_NOT_AVAILABLE;

985

986

return 0;

987

fail:

988

return -1; // free_tables will clean up for us

989

}

990

991

static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size);

992

993

static av_cold void common_init(H264Context *h){

994

MpegEncContext * const s = &h->s;

995

996

s->width = s->avctx->width;

997

s->height = s->avctx->height;

998

s->codec_id= s->avctx->codec->id;

999

1000

ff_h264dsp_init(&h->h264dsp, 8);

1001

ff_h264_pred_init(&h->hpc, s->codec_id, 8);

1002

1003

h->dequant_coeff_pps= -1;

1004

s->unrestricted_mv=1;

1005

s->decode=1; //FIXME

1006

1007

dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early

1008

1009

memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));

1010

memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));

1011

}

1012

1013

int ff_h264_decode_extradata(H264Context *h)

1014

{

1015

AVCodecContext *avctx = h->s.avctx;

1016

1017

if(avctx->extradata[0] == 1){

1018

int i, cnt, nalsize;

1019

unsigned char *p = avctx->extradata;

1020

1021

h->is_avc = 1;

1022

1023

if(avctx->extradata_size < 7) {

1024

av_log(avctx, AV_LOG_ERROR, "avcC too short\n");

1025

return -1;

1026

}

1027

/* sps and pps in the avcC always have length coded with 2 bytes,

1028

so put a fake nal_length_size = 2 while parsing them */

1029

h->nal_length_size = 2;

1030

// Decode sps from avcC

1031

cnt = *(p+5) & 0x1f; // Number of sps

1032

p += 6;

1033

for (i = 0; i < cnt; i++) {

1034

nalsize = AV_RB16(p) + 2;

1035

if(decode_nal_units(h, p, nalsize) < 0) {

1036

av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);

1037

return -1;

1038

}

1039

p += nalsize;

1040

}

1041

// Decode pps from avcC

1042

cnt = *(p++); // Number of pps

1043

for (i = 0; i < cnt; i++) {

1044

nalsize = AV_RB16(p) + 2;

1045

if (decode_nal_units(h, p, nalsize) < 0) {

1046

av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);

1047

return -1;

1048

}

1049

p += nalsize;

1050

}

1051

// Now store right nal length size, that will be use to parse all other nals

1052

h->nal_length_size = (avctx->extradata[4] & 0x03) + 1;

1053

} else {

1054

h->is_avc = 0;

1055

if(decode_nal_units(h, avctx->extradata, avctx->extradata_size) < 0)

1056

return -1;

1057

}

1058

return 0;

1059

}

1060

1061

av_cold int ff_h264_decode_init(AVCodecContext *avctx){

1062

H264Context *h= avctx->priv_data;

1063

MpegEncContext * const s = &h->s;

1064

1065

MPV_decode_defaults(s);

1066

1067

s->avctx = avctx;

1068

common_init(h);

1069

1070

s->out_format = FMT_H264;

1071

s->workaround_bugs= avctx->workaround_bugs;

1072

1073

// set defaults

1074

// s->decode_mb= ff_h263_decode_mb;

1075

s->quarter_sample = 1;

1076

if(!avctx->has_b_frames)

1077

s->low_delay= 1;

1078

1079

avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

1080

1081

ff_h264_decode_init_vlc();

1082

1083

h->pixel_shift = 0;

1084

h->sps.bit_depth_luma = avctx->bits_per_raw_sample = 8;

1085

1086

h->thread_context[0] = h;

1087

h->outputed_poc = h->next_outputed_poc = INT_MIN;

1088

h->prev_poc_msb= 1<<16;

1089

h->x264_build = -1;

1090

ff_h264_reset_sei(h);

1091

if(avctx->codec_id == CODEC_ID_H264){

1092

if(avctx->ticks_per_frame == 1){

1093

s->avctx->time_base.den *=2;

1094

}

1095

avctx->ticks_per_frame = 2;

1096

}

1097

1098

if(avctx->extradata_size > 0 && avctx->extradata &&

1099

ff_h264_decode_extradata(h))

1100

return -1;

1101

1102

if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames < h->sps.num_reorder_frames){

1103

s->avctx->has_b_frames = h->sps.num_reorder_frames;

1104

s->low_delay = 0;

1105

}

1106

1107

return 0;

1108

}

1109

1110

#define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b)+(size))))

1111

static void copy_picture_range(Picture **to, Picture **from, int count, MpegEncContext *new_base, MpegEncContext *old_base)

1112

{

1113

int i;

1114

1115

for (i=0; i<count; i++){

1116

assert((IN_RANGE(from[i], old_base, sizeof(*old_base)) ||

1117

IN_RANGE(from[i], old_base->picture, sizeof(Picture) * old_base->picture_count) ||

1118

!from[i]));

1119

to[i] = REBASE_PICTURE(from[i], new_base, old_base);

1120

}

1121

}

1122

1123

static void copy_parameter_set(void **to, void **from, int count, int size)

1124

{

1125

int i;

1126

1127

for (i=0; i<count; i++){

1128

if (to[i] && !from[i]) av_freep(&to[i]);

1129

else if (from[i] && !to[i]) to[i] = av_malloc(size);

1130

1131

if (from[i]) memcpy(to[i], from[i], size);

1132

}

1133

}

1134

1135

static int decode_init_thread_copy(AVCodecContext *avctx){

1136

H264Context *h= avctx->priv_data;

1137

1138

if (!avctx->is_copy) return 0;

1139

memset(h->sps_buffers, 0, sizeof(h->sps_buffers));

1140

memset(h->pps_buffers, 0, sizeof(h->pps_buffers));

1141

1142

return 0;

1143

}

1144

1145

#define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)

1146

static int decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src){

1147

H264Context *h= dst->priv_data, *h1= src->priv_data;

1148

MpegEncContext * const s = &h->s, * const s1 = &h1->s;

1149

int inited = s->context_initialized, err;

1150

int i;

1151

1152

if(dst == src || !s1->context_initialized) return 0;

1153

1154

err = ff_mpeg_update_thread_context(dst, src);

1155

if(err) return err;

1156

1157

//FIXME handle width/height changing

1158

if(!inited){

1159

for(i = 0; i < MAX_SPS_COUNT; i++)

1160

av_freep(h->sps_buffers + i);

1161

1162

for(i = 0; i < MAX_PPS_COUNT; i++)

1163

av_freep(h->pps_buffers + i);

1164

1165

memcpy(&h->s + 1, &h1->s + 1, sizeof(H264Context) - sizeof(MpegEncContext)); //copy all fields after MpegEnc

1166

memset(h->sps_buffers, 0, sizeof(h->sps_buffers));

1167

memset(h->pps_buffers, 0, sizeof(h->pps_buffers));

1168

if (ff_h264_alloc_tables(h) < 0) {

1169

av_log(dst, AV_LOG_ERROR, "Could not allocate memory for h264\n");

1170

return AVERROR(ENOMEM);

1171

}

1172

context_init(h);

1173

1174

for(i=0; i<2; i++){

1175

h->rbsp_buffer[i] = NULL;

1176

h->rbsp_buffer_size[i] = 0;

1177

}

1178

1179

h->thread_context[0] = h;

1180

1181

// frame_start may not be called for the next thread (if it's decoding a bottom field)

1182

// so this has to be allocated here

1183

h->s.obmc_scratchpad = av_malloc(16*6*s->linesize);

1184

1185

s->dsp.clear_blocks(h->mb);

1186

s->dsp.clear_blocks(h->mb+(24*16<<h->pixel_shift));

1187

}

1188

1189

//extradata/NAL handling

1190

h->is_avc = h1->is_avc;

1191

1192

//SPS/PPS

1193

copy_parameter_set((void**)h->sps_buffers, (void**)h1->sps_buffers, MAX_SPS_COUNT, sizeof(SPS));

1194

h->sps = h1->sps;

1195

copy_parameter_set((void**)h->pps_buffers, (void**)h1->pps_buffers, MAX_PPS_COUNT, sizeof(PPS));

1196

h->pps = h1->pps;

1197

1198

//Dequantization matrices

1199

//FIXME these are big - can they be only copied when PPS changes?

1200

copy_fields(h, h1, dequant4_buffer, dequant4_coeff);

1201

1202

for(i=0; i<6; i++)

1203

h->dequant4_coeff[i] = h->dequant4_buffer[0] + (h1->dequant4_coeff[i] - h1->dequant4_buffer[0]);

1204

1205

for(i=0; i<6; i++)

1206

h->dequant8_coeff[i] = h->dequant8_buffer[0] + (h1->dequant8_coeff[i] - h1->dequant8_buffer[0]);

1207

1208

h->dequant_coeff_pps = h1->dequant_coeff_pps;

1209

1210

//POC timing

1211

copy_fields(h, h1, poc_lsb, redundant_pic_count);

1212

1213

//reference lists

1214

copy_fields(h, h1, ref_count, list_count);

1215

copy_fields(h, h1, ref_list, intra_gb);

1216

copy_fields(h, h1, short_ref, cabac_init_idc);

1217

1218

copy_picture_range(h->short_ref, h1->short_ref, 32, s, s1);

1219

copy_picture_range(h->long_ref, h1->long_ref, 32, s, s1);

1220

copy_picture_range(h->delayed_pic, h1->delayed_pic, MAX_DELAYED_PIC_COUNT+2, s, s1);

1221

1222

h->last_slice_type = h1->last_slice_type;

1223

1224

if(!s->current_picture_ptr) return 0;

1225

1226

if(!s->dropable) {

1227

ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);

1228

h->prev_poc_msb = h->poc_msb;

1229

h->prev_poc_lsb = h->poc_lsb;

1230

}

1231

h->prev_frame_num_offset= h->frame_num_offset;

1232

h->prev_frame_num = h->frame_num;

1233

h->outputed_poc = h->next_outputed_poc;

1234

1235

return 0;

1236

}

1237

1238

int ff_h264_frame_start(H264Context *h){

1239

MpegEncContext * const s = &h->s;

1240

int i;

1241

const int pixel_shift = h->pixel_shift;

1242

int thread_count = (s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1;

1243

1244

if(MPV_frame_start(s, s->avctx) < 0)

1245

return -1;

1246

ff_er_frame_start(s);

1247

1248

* MPV_frame_start uses pict_type to derive key_frame.

1249

* This is incorrect for H.264; IDR markings must be used.

1250

* Zero here; IDR markings per slice in frame or fields are ORed in later.

1251

* See decode_nal_units().

1252

1253

s->current_picture_ptr->key_frame= 0;

1254

s->current_picture_ptr->mmco_reset= 0;

1255

1256

assert(s->linesize && s->uvlinesize);

1257

1258

for(i=0; i<16; i++){

1259

h->block_offset[i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 4*s->linesize*((scan8[i] - scan8[0])>>3);

1260

h->block_offset[48+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 8*s->linesize*((scan8[i] - scan8[0])>>3);

1261

}

1262

for(i=0; i<16; i++){

1263

h->block_offset[16+i]=

1264

h->block_offset[32+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);

1265

h->block_offset[48+16+i]=

1266

h->block_offset[48+32+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);

1267

}

1268

1269

/* can't be in alloc_tables because linesize isn't known there.

1270

* FIXME: redo bipred weight to not require extra buffer? */

1271

for(i = 0; i < thread_count; i++)

1272

if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)

1273

h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*6*s->linesize);

1274

1275

/* some macroblocks can be accessed before they're available in case of lost slices, mbaff or threading*/

1276

memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));

1277

1278

// s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;

1279

1280

// We mark the current picture as non-reference after allocating it, so

1281

// that if we break out due to an error it can be released automatically

1282

// in the next MPV_frame_start().

1283

// SVQ3 as well as most other codecs have only last/next/current and thus

1284

// get released even with set reference, besides SVQ3 and others do not

1285

// mark frames as reference later "naturally".

1286

if(s->codec_id != CODEC_ID_SVQ3)

1287

s->current_picture_ptr->reference= 0;

1288

1289

s->current_picture_ptr->field_poc[0]=

1290

s->current_picture_ptr->field_poc[1]= INT_MAX;

1291

1292

h->next_output_pic = NULL;

1293

1294

assert(s->current_picture_ptr->long_ref==0);

1295

1296

return 0;

1297

}

1298

1299

/**

1300

* Run setup operations that must be run after slice header decoding.

1301

* This includes finding the next displayed frame.

1302

1303

* @param h h264 master context

1304

* @param setup_finished enough NALs have been read that we can call

1305

* ff_thread_finish_setup()

1306

1307

static void decode_postinit(H264Context *h, int setup_finished){

1308

MpegEncContext * const s = &h->s;

1309

Picture *out = s->current_picture_ptr;

1310

Picture *cur = s->current_picture_ptr;

1311

int i, pics, out_of_order, out_idx;

1312

1313

s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;

1314

s->current_picture_ptr->pict_type= s->pict_type;

1315

1316

if (h->next_output_pic) return;

1317

1318

if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {

1319

//FIXME: if we have two PAFF fields in one packet, we can't start the next thread here.

1320

//If we have one field per packet, we can. The check in decode_nal_units() is not good enough

1321

//to find this yet, so we assume the worst for now.

1322

//if (setup_finished)

1323

// ff_thread_finish_setup(s->avctx);

1324

return;

1325

}

1326

1327

cur->interlaced_frame = 0;

1328

cur->repeat_pict = 0;

1329

1330

/* Signal interlacing information externally. */

1331

/* Prioritize picture timing SEI information over used decoding process if it exists. */

1332

1333

if(h->sps.pic_struct_present_flag){

1334

switch (h->sei_pic_struct)

1335

{

1336

case SEI_PIC_STRUCT_FRAME:

1337

break;

1338

case SEI_PIC_STRUCT_TOP_FIELD:

1339

case SEI_PIC_STRUCT_BOTTOM_FIELD:

1340

cur->interlaced_frame = 1;

1341

break;

1342

case SEI_PIC_STRUCT_TOP_BOTTOM:

1343

case SEI_PIC_STRUCT_BOTTOM_TOP:

1344

if (FIELD_OR_MBAFF_PICTURE)

1345

cur->interlaced_frame = 1;

1346

else

1347

// try to flag soft telecine progressive

1348

cur->interlaced_frame = h->prev_interlaced_frame;

1349

break;

1350

case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

1351

case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:

1352

// Signal the possibility of telecined film externally (pic_struct 5,6)

1353

// From these hints, let the applications decide if they apply deinterlacing.

1354

cur->repeat_pict = 1;

1355

break;

1356

case SEI_PIC_STRUCT_FRAME_DOUBLING:

1357

// Force progressive here, as doubling interlaced frame is a bad idea.

1358

cur->repeat_pict = 2;

1359

break;

1360

case SEI_PIC_STRUCT_FRAME_TRIPLING:

1361

cur->repeat_pict = 4;

1362

break;

1363

}

1364

1365

if ((h->sei_ct_type & 3) && h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)

1366

cur->interlaced_frame = (h->sei_ct_type & (1<<1)) != 0;

1367

}else{

1368

/* Derive interlacing flag from used decoding process. */

1369

cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;

1370

}

1371

h->prev_interlaced_frame = cur->interlaced_frame;

1372

1373

if (cur->field_poc[0] != cur->field_poc[1]){

1374

/* Derive top_field_first from field pocs. */

1375

cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];

1376

}else{

1377

if(cur->interlaced_frame || h->sps.pic_struct_present_flag){

1378

/* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */

1379

if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM

1380

|| h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)

1381

cur->top_field_first = 1;

1382

else

1383

cur->top_field_first = 0;

1384

}else{

1385

/* Most likely progressive */

1386

cur->top_field_first = 0;

1387

}

1388

}

1389

1390

//FIXME do something with unavailable reference frames

1391

1392

/* Sort B-frames into display order */

1393

1394

if(h->sps.bitstream_restriction_flag

1395

&& s->avctx->has_b_frames < h->sps.num_reorder_frames){

1396

s->avctx->has_b_frames = h->sps.num_reorder_frames;

1397

s->low_delay = 0;

1398

}

1399

1400

if( s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT

1401

&& !h->sps.bitstream_restriction_flag){

1402

s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT;

1403

s->low_delay= 0;

1404

}

1405

1406

pics = 0;

1407

while(h->delayed_pic[pics]) pics++;

1408

1409

assert(pics <= MAX_DELAYED_PIC_COUNT);

1410

1411

h->delayed_pic[pics++] = cur;

1412

if(cur->reference == 0)

1413

cur->reference = DELAYED_PIC_REF;

1414

1415

out = h->delayed_pic[0];

1416

out_idx = 0;

1417

for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)

1418

if(h->delayed_pic[i]->poc < out->poc){

1419

out = h->delayed_pic[i];

1420

out_idx = i;

1421

}

1422

if(s->avctx->has_b_frames == 0 && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset))

1423

h->next_outputed_poc= INT_MIN;

1424

out_of_order = out->poc < h->next_outputed_poc;

1425

1426

if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)

1427

{ }

1428

else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT)

1429

|| (s->low_delay &&

1430

((h->next_outputed_poc != INT_MIN && out->poc > h->next_outputed_poc + 2)

1431

|| cur->pict_type == AV_PICTURE_TYPE_B)))

1432

{

1433

s->low_delay = 0;

1434

s->avctx->has_b_frames++;

1435

}

1436

1437

if(out_of_order || pics > s->avctx->has_b_frames){

1438

out->reference &= ~DELAYED_PIC_REF;

1439

out->owner2 = s; // for frame threading, the owner must be the second field's thread

1440

// or else the first thread can release the picture and reuse it unsafely

1441

for(i=out_idx; h->delayed_pic[i]; i++)

1442

h->delayed_pic[i] = h->delayed_pic[i+1];

1443

}

1444

if(!out_of_order && pics > s->avctx->has_b_frames){

1445

h->next_output_pic = out;

1446

if(out_idx==0 && h->delayed_pic[0] && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) {

1447

h->next_outputed_poc = INT_MIN;

1448

} else

1449

h->next_outputed_poc = out->poc;

1450

}else{

1451

av_log(s->avctx, AV_LOG_DEBUG, "no picture\n");

1452

}

1453

1454

if (setup_finished)

1455

ff_thread_finish_setup(s->avctx);

1456

}

1457

1458

static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int chroma444, int simple){

1459

MpegEncContext * const s = &h->s;

1460

uint8_t *top_border;

1461

int top_idx = 1;

1462

const int pixel_shift = h->pixel_shift;

1463

1464

src_y -= linesize;

1465

src_cb -= uvlinesize;

1466

src_cr -= uvlinesize;

1467

1468

if(!simple && FRAME_MBAFF){

1469

if(s->mb_y&1){

1470

if(!MB_MBAFF){

1471

top_border = h->top_borders[0][s->mb_x];

1472

AV_COPY128(top_border, src_y + 15*linesize);

1473

if (pixel_shift)

1474

AV_COPY128(top_border+16, src_y+15*linesize+16);

1475

if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

1476

if(chroma444){

1477

if (pixel_shift){

1478

AV_COPY128(top_border+32, src_cb + 15*uvlinesize);

1479

AV_COPY128(top_border+48, src_cb + 15*uvlinesize+16);

1480

AV_COPY128(top_border+64, src_cr + 15*uvlinesize);

1481

AV_COPY128(top_border+80, src_cr + 15*uvlinesize+16);

1482

} else {

1483

AV_COPY128(top_border+16, src_cb + 15*uvlinesize);

1484

AV_COPY128(top_border+32, src_cr + 15*uvlinesize);

1485

}

1486

} else {

1487

if (pixel_shift) {

1488

AV_COPY128(top_border+32, src_cb+7*uvlinesize);

1489

AV_COPY128(top_border+48, src_cr+7*uvlinesize);

1490

} else {

1491

AV_COPY64(top_border+16, src_cb+7*uvlinesize);

1492

AV_COPY64(top_border+24, src_cr+7*uvlinesize);

1493

}

1494

}

1495

}

1496

}

1497

}else if(MB_MBAFF){

1498

top_idx = 0;

1499

}else

1500

return;

1501

}

1502

1503

top_border = h->top_borders[top_idx][s->mb_x];

1504

// There are two lines saved, the line above the the top macroblock of a pair,

1505

// and the line above the bottom macroblock

1506

AV_COPY128(top_border, src_y + 16*linesize);

1507

if (pixel_shift)

1508

AV_COPY128(top_border+16, src_y+16*linesize+16);

1509

1510

if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

1511

if(chroma444){

1512

if (pixel_shift){

1513

AV_COPY128(top_border+32, src_cb + 16*linesize);

1514

AV_COPY128(top_border+48, src_cb + 16*linesize+16);

1515

AV_COPY128(top_border+64, src_cr + 16*linesize);

1516

AV_COPY128(top_border+80, src_cr + 16*linesize+16);

1517

} else {

1518

AV_COPY128(top_border+16, src_cb + 16*linesize);

1519

AV_COPY128(top_border+32, src_cr + 16*linesize);

1520

}

1521

} else {

1522

if (pixel_shift) {

1523

AV_COPY128(top_border+32, src_cb+8*uvlinesize);

1524

AV_COPY128(top_border+48, src_cr+8*uvlinesize);

1525

} else {

1526

AV_COPY64(top_border+16, src_cb+8*uvlinesize);

1527

AV_COPY64(top_border+24, src_cr+8*uvlinesize);

1528

}

1529

}

1530

}

1531

}

1532

1533

static inline void xchg_mb_border(H264Context *h, uint8_t *src_y,

1534

uint8_t *src_cb, uint8_t *src_cr,

1535

int linesize, int uvlinesize,

1536

int xchg, int chroma444,

1537

int simple, int pixel_shift){

1538

MpegEncContext * const s = &h->s;

1539

int deblock_topleft;

1540

int deblock_top;

1541

int top_idx = 1;

1542

uint8_t *top_border_m1;

1543

uint8_t *top_border;

1544

1545

if(!simple && FRAME_MBAFF){

1546

if(s->mb_y&1){

1547

if(!MB_MBAFF)

1548

return;

1549

}else{

1550

top_idx = MB_MBAFF ? 0 : 1;

1551

}

1552

}

1553

1554

if(h->deblocking_filter == 2) {

1555

deblock_topleft = h->slice_table[h->mb_xy - 1 - s->mb_stride] == h->slice_num;

1556

deblock_top = h->top_type;

1557

} else {

1558

deblock_topleft = (s->mb_x > 0);

1559

deblock_top = (s->mb_y > !!MB_FIELD);

1560

}

1561

1562

src_y -= linesize + 1 + pixel_shift;

1563

src_cb -= uvlinesize + 1 + pixel_shift;

1564

src_cr -= uvlinesize + 1 + pixel_shift;

1565

1566

top_border_m1 = h->top_borders[top_idx][s->mb_x-1];

1567

top_border = h->top_borders[top_idx][s->mb_x];

1568

1569

#define XCHG(a,b,xchg)\

1570

if (pixel_shift) {\

1571

if (xchg) {\

1572

AV_SWAP64(b+0,a+0);\

1573

AV_SWAP64(b+8,a+8);\

1574

} else {\

1575

AV_COPY128(b,a); \

1576

1577

} else \

1578

if (xchg) AV_SWAP64(b,a);\

1579

else AV_COPY64(b,a);

1580

1581

if(deblock_top){

1582

if(deblock_topleft){

1583

XCHG(top_border_m1 + (8 << pixel_shift), src_y - (7 << pixel_shift), 1);

1584

}

1585

XCHG(top_border + (0 << pixel_shift), src_y + (1 << pixel_shift), xchg);

1586

XCHG(top_border + (8 << pixel_shift), src_y + (9 << pixel_shift), 1);

1587

if(s->mb_x+1 < s->mb_width){

1588

XCHG(h->top_borders[top_idx][s->mb_x+1], src_y + (17 << pixel_shift), 1);

1589

}

1590

}

1591

if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

1592

if(chroma444){

1593

if(deblock_topleft){

1594

XCHG(top_border_m1 + (24 << pixel_shift), src_cb - (7 << pixel_shift), 1);

1595

XCHG(top_border_m1 + (40 << pixel_shift), src_cr - (7 << pixel_shift), 1);

1596

}

1597

XCHG(top_border + (16 << pixel_shift), src_cb + (1 << pixel_shift), xchg);

1598

XCHG(top_border + (24 << pixel_shift), src_cb + (9 << pixel_shift), 1);

1599

XCHG(top_border + (32 << pixel_shift), src_cr + (1 << pixel_shift), xchg);

1600

XCHG(top_border + (40 << pixel_shift), src_cr + (9 << pixel_shift), 1);

1601

if(s->mb_x+1 < s->mb_width){

1602

XCHG(h->top_borders[top_idx][s->mb_x+1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1);

1603

XCHG(h->top_borders[top_idx][s->mb_x+1] + (32 << pixel_shift), src_cr + (17 << pixel_shift), 1);

1604

}

1605

} else {

1606

if(deblock_top){

1607

if(deblock_topleft){

1608

XCHG(top_border_m1 + (16 << pixel_shift), src_cb - (7 << pixel_shift), 1);

1609

XCHG(top_border_m1 + (24 << pixel_shift), src_cr - (7 << pixel_shift), 1);

1610

}

1611

XCHG(top_border + (16 << pixel_shift), src_cb+1+pixel_shift, 1);

1612

XCHG(top_border + (24 << pixel_shift), src_cr+1+pixel_shift, 1);

1613

}

1614

}

1615

}

1616

}

1617

1618

static av_always_inline int dctcoef_get(DCTELEM *mb, int high_bit_depth, int index) {

1619

if (high_bit_depth) {

1620

return AV_RN32A(((int32_t*)mb) + index);

1621

} else

1622

return AV_RN16A(mb + index);

1623

}

1624

1625

static av_always_inline void dctcoef_set(DCTELEM *mb, int high_bit_depth, int index, int value) {

1626

if (high_bit_depth) {

1627

AV_WN32A(((int32_t*)mb) + index, value);

1628

} else

1629

AV_WN16A(mb + index, value);

1630

}

1631

1632

static av_always_inline void hl_decode_mb_predict_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass,

1633

int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p)

1634

{

1635

MpegEncContext * const s = &h->s;

1636

void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);

1637

void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);

1638

int i;

1639

int qscale = p == 0 ? s->qscale : h->chroma_qp[p-1];

1640

block_offset += 16*p;

1641

if(IS_INTRA4x4(mb_type)){

1642

if(simple || !s->encoding){

1643

if(IS_8x8DCT(mb_type)){

1644

if(transform_bypass){

1645

idct_dc_add =

1646

idct_add = s->dsp.add_pixels8;

1647

}else{

1648

idct_dc_add = h->h264dsp.h264_idct8_dc_add;

1649

idct_add = h->h264dsp.h264_idct8_add;

1650

}

1651

for(i=0; i<16; i+=4){

1652

uint8_t * const ptr= dest_y + block_offset[i];

1653

const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

1654

if(transform_bypass && h->sps.profile_idc==244 && dir<=1){

1655

h->hpc.pred8x8l_add[dir](ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);

1656

}else{

1657

const int nnz = h->non_zero_count_cache[ scan8[i+p*16] ];

1658

h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,

1659

(h->topright_samples_available<<i)&0x4000, linesize);

1660

if(nnz){

1661

if(nnz == 1 && dctcoef_get(h->mb, pixel_shift, i*16+p*256))

1662

idct_dc_add(ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);

1663

else

1664

idct_add (ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);

1665

}

1666

}

1667

}

1668

}else{

1669

if(transform_bypass){

1670

idct_dc_add =

1671

idct_add = s->dsp.add_pixels4;

1672

}else{

1673

idct_dc_add = h->h264dsp.h264_idct_dc_add;

1674

idct_add = h->h264dsp.h264_idct_add;

1675

}

1676

for(i=0; i<16; i++){

1677

uint8_t * const ptr= dest_y + block_offset[i];

1678

const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

1679

1680

if(transform_bypass && h->sps.profile_idc==244 && dir<=1){

1681

h->hpc.pred4x4_add[dir](ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);

1682

}else{

1683

uint8_t *topright;

1684

int nnz, tr;

1685

uint64_t tr_high;

1686

if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){

1687

const int topright_avail= (h->topright_samples_available<<i)&0x8000;

1688

assert(s->mb_y || linesize <= block_offset[i]);

1689

if(!topright_avail){

1690

if (pixel_shift) {

1691

tr_high= ((uint16_t*)ptr)[3 - linesize/2]*0x0001000100010001ULL;

1692

topright= (uint8_t*) &tr_high;

1693

} else {

1694

tr= ptr[3 - linesize]*0x01010101;

1695

topright= (uint8_t*) &tr;

1696

}

1697

}else

1698

topright= ptr + (4 << pixel_shift) - linesize;

1699

}else

1700

topright= NULL;

1701

1702

h->hpc.pred4x4[ dir ](ptr, topright, linesize);

1703

nnz = h->non_zero_count_cache[ scan8[i+p*16] ];

1704

if(nnz){

1705

if(is_h264){

1706

if(nnz == 1 && dctcoef_get(h->mb, pixel_shift, i*16+p*256))

1707

idct_dc_add(ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);

1708

else

1709

idct_add (ptr, h->mb + (i*16+p*256 << pixel_shift), linesize);

1710

}else

1711

ff_svq3_add_idct_c(ptr, h->mb + i*16+p*256, linesize, qscale, 0);

1712

}

1713

}

1714

}

1715

}

1716

}

1717

}else{

1718

h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);

1719

if(is_h264){

1720

if(h->non_zero_count_cache[ scan8[LUMA_DC_BLOCK_INDEX+p] ]){

1721

if(!transform_bypass)

1722

h->h264dsp.h264_luma_dc_dequant_idct(h->mb+(p*256 << pixel_shift), h->mb_luma_dc[p], h->dequant4_coeff[p][qscale][0]);

1723

else{

1724

static const uint8_t dc_mapping[16] = { 0*16, 1*16, 4*16, 5*16, 2*16, 3*16, 6*16, 7*16,

1725

8*16, 9*16,12*16,13*16,10*16,11*16,14*16,15*16};

1726

for(i = 0; i < 16; i++)

1727

dctcoef_set(h->mb+p*256, pixel_shift, dc_mapping[i], dctcoef_get(h->mb_luma_dc[p], pixel_shift, i));

1728

}

1729

}

1730

}else

1731

ff_svq3_luma_dc_dequant_idct_c(h->mb+p*256, h->mb_luma_dc[p], qscale);

1732

}

1733

}

1734

1735

static av_always_inline void hl_decode_mb_idct_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass,

1736

int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p)

1737

{

1738

MpegEncContext * const s = &h->s;

1739

void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);

1740

int i;

1741

block_offset += 16*p;

1742

if(!IS_INTRA4x4(mb_type)){

1743

if(is_h264){

1744

if(IS_INTRA16x16(mb_type)){

1745

if(transform_bypass){

1746

if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){

1747

h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb + (p*256 << pixel_shift), linesize);

1748

}else{

1749

for(i=0; i<16; i++){

1750

if(h->non_zero_count_cache[ scan8[i+p*16] ] || dctcoef_get(h->mb, pixel_shift, i*16+p*256))

1751

s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + (i*16+p*256 << pixel_shift), linesize);

1752

}

1753

}

1754

}else{

1755

h->h264dsp.h264_idct_add16intra(dest_y, block_offset, h->mb + (p*256 << pixel_shift), linesize, h->non_zero_count_cache+p*5*8);

1756

}

1757

}else if(h->cbp&15){

1758

if(transform_bypass){

1759

const int di = IS_8x8DCT(mb_type) ? 4 : 1;

1760

idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;

1761

for(i=0; i<16; i+=di){

1762

if(h->non_zero_count_cache[ scan8[i+p*16] ]){

1763

idct_add(dest_y + block_offset[i], h->mb + (i*16+p*256 << pixel_shift), linesize);

1764

}

1765

}

1766

}else{

1767

if(IS_8x8DCT(mb_type)){

1768

h->h264dsp.h264_idct8_add4(dest_y, block_offset, h->mb + (p*256 << pixel_shift), linesize, h->non_zero_count_cache+p*5*8);

1769

}else{

1770

h->h264dsp.h264_idct_add16(dest_y, block_offset, h->mb + (p*256 << pixel_shift), linesize, h->non_zero_count_cache+p*5*8);

1771

}

1772

}

1773

}

1774

}else{

1775

for(i=0; i<16; i++){

1776

if(h->non_zero_count_cache[ scan8[i+p*16] ] || h->mb[i*16+p*256]){ //FIXME benchmark weird rule, & below

1777

uint8_t * const ptr= dest_y + block_offset[i];

1778

ff_svq3_add_idct_c(ptr, h->mb + i*16 + p*256, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);

1779

}

1780

}

1781

}

1782

}

1783

}

1784

1785

static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple, int pixel_shift){

1786

MpegEncContext * const s = &h->s;

1787

const int mb_x= s->mb_x;

1788

const int mb_y= s->mb_y;

1789

const int mb_xy= h->mb_xy;

1790

const int mb_type= s->current_picture.mb_type[mb_xy];

1791

uint8_t *dest_y, *dest_cb, *dest_cr;

1792

int linesize, uvlinesize /*dct_offset*/;

1793

int i, j;

1794

int *block_offset = &h->block_offset[0];

1795

const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);

1796

/* is_h264 should always be true if SVQ3 is disabled. */

1797

const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264;

1798

void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);

1799

1800

dest_y = s->current_picture.data[0] + ((mb_x << pixel_shift) + mb_y * s->linesize ) * 16;

1801

dest_cb = s->current_picture.data[1] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * 8;

1802

dest_cr = s->current_picture.data[2] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * 8;

1803

1804

s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + (64 << pixel_shift), s->linesize, 4);

1805

s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + (64 << pixel_shift), dest_cr - dest_cb, 2);

1806

1807

h->list_counts[mb_xy]= h->list_count;

1808

1809

if (!simple && MB_FIELD) {

1810

linesize = h->mb_linesize = s->linesize * 2;

1811

uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;

1812

block_offset = &h->block_offset[48];

1813

if(mb_y&1){ //FIXME move out of this function?

1814

dest_y -= s->linesize*15;

1815

dest_cb-= s->uvlinesize*7;

1816

dest_cr-= s->uvlinesize*7;

1817

}

1818

if(FRAME_MBAFF) {

1819

int list;

1820

for(list=0; list<h->list_count; list++){

1821

if(!USES_LIST(mb_type, list))

1822

continue;

1823

if(IS_16X16(mb_type)){

1824

int8_t *ref = &h->ref_cache[list][scan8[0]];

1825

fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);

1826

}else{

1827

for(i=0; i<16; i+=4){

1828

int ref = h->ref_cache[list][scan8[i]];

1829

if(ref >= 0)

1830

fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);

1831

}

1832

}

1833

}

1834

}

1835

} else {

1836

linesize = h->mb_linesize = s->linesize;

1837

uvlinesize = h->mb_uvlinesize = s->uvlinesize;

1838

// dct_offset = s->linesize * 16;

1839

}

1840

1841

if (!simple && IS_INTRA_PCM(mb_type)) {

1842

if (pixel_shift) {

1843

const int bit_depth = h->sps.bit_depth_luma;

1844

int j;

1845

GetBitContext gb;

1846

init_get_bits(&gb, (uint8_t*)h->mb, 384*bit_depth);

1847

1848

for (i = 0; i < 16; i++) {

1849

uint16_t *tmp_y = (uint16_t*)(dest_y + i*linesize);

1850

for (j = 0; j < 16; j++)

1851

tmp_y[j] = get_bits(&gb, bit_depth);

1852

}

1853

if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

1854

for (i = 0; i < 8; i++) {

1855

uint16_t *tmp_cb = (uint16_t*)(dest_cb + i*uvlinesize);

1856

for (j = 0; j < 8; j++)

1857

tmp_cb[j] = get_bits(&gb, bit_depth);

1858

}

1859

for (i = 0; i < 8; i++) {

1860

uint16_t *tmp_cr = (uint16_t*)(dest_cr + i*uvlinesize);

1861

for (j = 0; j < 8; j++)

1862

tmp_cr[j] = get_bits(&gb, bit_depth);

1863

}

1864

}

1865

} else {

1866

for (i=0; i<16; i++) {

1867

memcpy(dest_y + i* linesize, h->mb + i*8, 16);

1868

}

1869

if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

1870

for (i=0; i<8; i++) {

1871

memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4, 8);

1872

memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4, 8);

1873

}

1874

}

1875

}

1876

} else {

1877

if(IS_INTRA(mb_type)){

1878

if(h->deblocking_filter)

1879

xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, 0, simple, pixel_shift);

1880

1881

if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

1882

h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);

1883

h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);

1884

}

1885

1886

hl_decode_mb_predict_luma(h, mb_type, is_h264, simple, transform_bypass, pixel_shift, block_offset, linesize, dest_y, 0);

1887

1888

if(h->deblocking_filter)

1889

xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, 0, simple, pixel_shift);

1890

}else if(is_h264){

1891

if (pixel_shift) {

1892

hl_motion_16(h, dest_y, dest_cb, dest_cr,

1893

s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,

1894

s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,

1895

h->h264dsp.weight_h264_pixels_tab,

1896

h->h264dsp.biweight_h264_pixels_tab, 0);

1897

} else

1898

hl_motion_8(h, dest_y, dest_cb, dest_cr,

1899

s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,

1900

s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,

1901

h->h264dsp.weight_h264_pixels_tab,

1902

h->h264dsp.biweight_h264_pixels_tab, 0);

1903

}

1904

1905

hl_decode_mb_idct_luma(h, mb_type, is_h264, simple, transform_bypass, pixel_shift, block_offset, linesize, dest_y, 0);

1906

1907

if((simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){

1908

uint8_t *dest[2] = {dest_cb, dest_cr};

1909

if(transform_bypass){

1910

if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){

1911

h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + (16*16*1 << pixel_shift), uvlinesize);

1912

h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 32, h->mb + (16*16*2 << pixel_shift), uvlinesize);

1913

}else{

1914

idct_add = s->dsp.add_pixels4;

1915

for(j=1; j<3; j++){

1916

for(i=j*16; i<j*16+4; i++){

1917

if(h->non_zero_count_cache[ scan8[i] ] || dctcoef_get(h->mb, pixel_shift, i*16))

1918

idct_add (dest[j-1] + block_offset[i], h->mb + (i*16 << pixel_shift), uvlinesize);

1919

}

1920

}

1921

}

1922

}else{

1923

if(is_h264){

1924

if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+0] ])

1925

h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16*16*1 << pixel_shift), h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);

1926

if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+1] ])

1927

h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16*16*2 << pixel_shift), h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);

1928

h->h264dsp.h264_idct_add8(dest, block_offset,

1929

h->mb, uvlinesize,

1930

h->non_zero_count_cache);

1931

}else{

1932

h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16*1, h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);

1933

h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16*2, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);

1934

for(j=1; j<3; j++){

1935

for(i=j*16; i<j*16+4; i++){

1936

if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){

1937

uint8_t * const ptr= dest[j-1] + block_offset[i];

1938

ff_svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);

1939

}

1940

}

1941

}

1942

}

1943

}

1944

}

1945

}

1946

if(h->cbp || IS_INTRA(mb_type))

1947

{

1948

s->dsp.clear_blocks(h->mb);

1949

s->dsp.clear_blocks(h->mb+(24*16<<pixel_shift));

1950

}

1951

}

1952

1953

static av_always_inline void hl_decode_mb_444_internal(H264Context *h, int simple, int pixel_shift){

1954

MpegEncContext * const s = &h->s;

1955

const int mb_x= s->mb_x;

1956

const int mb_y= s->mb_y;

1957

const int mb_xy= h->mb_xy;

1958

const int mb_type= s->current_picture.mb_type[mb_xy];

1959

uint8_t *dest[3];

1960

int linesize;

1961

int i, j, p;

1962

int *block_offset = &h->block_offset[0];

1963

const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);

1964

const int plane_count = (simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) ? 3 : 1;

1965

1966

for (p = 0; p < plane_count; p++)

1967

{

1968

dest[p] = s->current_picture.data[p] + ((mb_x << pixel_shift) + mb_y * s->linesize) * 16;

1969

s->dsp.prefetch(dest[p] + (s->mb_x&3)*4*s->linesize + (64 << pixel_shift), s->linesize, 4);

1970

}

1971

1972

h->list_counts[mb_xy]= h->list_count;

1973

1974

if (!simple && MB_FIELD) {

1975

linesize = h->mb_linesize = h->mb_uvlinesize = s->linesize * 2;

1976

block_offset = &h->block_offset[48];

1977

if(mb_y&1) //FIXME move out of this function?

1978

for (p = 0; p < 3; p++)

1979

dest[p] -= s->linesize*15;

1980

if(FRAME_MBAFF) {

1981

int list;

1982

for(list=0; list<h->list_count; list++){

1983

if(!USES_LIST(mb_type, list))

1984

continue;

1985

if(IS_16X16(mb_type)){

1986

int8_t *ref = &h->ref_cache[list][scan8[0]];

1987

fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);

1988

}else{

1989

for(i=0; i<16; i+=4){

1990

int ref = h->ref_cache[list][scan8[i]];

1991

if(ref >= 0)

1992

fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);

1993

}

1994

}

1995

}

1996

}

1997

} else {

1998

linesize = h->mb_linesize = h->mb_uvlinesize = s->linesize;

1999

}

2000

2001

if (!simple && IS_INTRA_PCM(mb_type)) {

2002

if (pixel_shift) {

2003

const int bit_depth = h->sps.bit_depth_luma;

2004

GetBitContext gb;

2005

init_get_bits(&gb, (uint8_t*)h->mb, 768*bit_depth);

2006

2007

for (p = 0; p < plane_count; p++) {

2008

for (i = 0; i < 16; i++) {

2009

uint16_t *tmp = (uint16_t*)(dest[p] + i*linesize);

2010

for (j = 0; j < 16; j++)

2011

tmp[j] = get_bits(&gb, bit_depth);

2012

}

2013

}

2014

} else {

2015

for (p = 0; p < plane_count; p++) {

2016

for (i = 0; i < 16; i++) {

2017

memcpy(dest[p] + i*linesize, h->mb + p*128 + i*8, 16);

2018

}

2019

}

2020

}

2021

} else {

2022

if(IS_INTRA(mb_type)){

2023

if(h->deblocking_filter)

2024

xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, linesize, 1, 1, simple, pixel_shift);

2025

2026

for (p = 0; p < plane_count; p++)

2027

hl_decode_mb_predict_luma(h, mb_type, 1, simple, transform_bypass, pixel_shift, block_offset, linesize, dest[p], p);

2028

2029

if(h->deblocking_filter)

2030

xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, linesize, 0, 1, simple, pixel_shift);

2031

}else{

2032

if (pixel_shift) {

2033

hl_motion_16(h, dest[0], dest[1], dest[2],

2034

s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,

2035

s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,

2036

h->h264dsp.weight_h264_pixels_tab,

2037

h->h264dsp.biweight_h264_pixels_tab, 1);

2038

} else

2039

hl_motion_8(h, dest[0], dest[1], dest[2],

2040

s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,

2041

s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,

2042

h->h264dsp.weight_h264_pixels_tab,

2043

h->h264dsp.biweight_h264_pixels_tab, 1);

2044

}

2045

2046

for (p = 0; p < plane_count; p++)

2047

hl_decode_mb_idct_luma(h, mb_type, 1, simple, transform_bypass, pixel_shift, block_offset, linesize, dest[p], p);

2048

}

2049

if(h->cbp || IS_INTRA(mb_type))

2050

{

2051

s->dsp.clear_blocks(h->mb);

2052

s->dsp.clear_blocks(h->mb+(24*16<<pixel_shift));

2053

}

2054

}

2055

2056

/**

2057

* Process a macroblock; this case avoids checks for expensive uncommon cases.

2058

2059

#define hl_decode_mb_simple(sh, bits) \

2060

static void hl_decode_mb_simple_ ## bits(H264Context *h){ \

2061

hl_decode_mb_internal(h, 1, sh); \

2062

}

2063

hl_decode_mb_simple(0, 8);

2064

hl_decode_mb_simple(1, 16);

2065

2066

/**

2067

* Process a macroblock; this handles edge cases, such as interlacing.

2068

2069

static void av_noinline hl_decode_mb_complex(H264Context *h){

2070

hl_decode_mb_internal(h, 0, h->pixel_shift);

2071

}

2072

2073

static void av_noinline hl_decode_mb_444_complex(H264Context *h){

2074

hl_decode_mb_444_internal(h, 0, h->pixel_shift);

2075

}

2076

2077

static void av_noinline hl_decode_mb_444_simple(H264Context *h){

2078

hl_decode_mb_444_internal(h, 1, 0);

2079

}

2080

2081

void ff_h264_hl_decode_mb(H264Context *h){

2082

MpegEncContext * const s = &h->s;

2083

const int mb_xy= h->mb_xy;

2084

const int mb_type= s->current_picture.mb_type[mb_xy];

2085

int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;

2086

2087

if (CHROMA444) {

2088

if(is_complex || h->pixel_shift)

2089

hl_decode_mb_444_complex(h);

2090

else

2091

hl_decode_mb_444_simple(h);

2092

} else if (is_complex) {

2093

hl_decode_mb_complex(h);

2094

} else if (h->pixel_shift) {

2095

hl_decode_mb_simple_16(h);

2096

} else

2097

hl_decode_mb_simple_8(h);

2098

}

2099

2100

static int pred_weight_table(H264Context *h){

2101

MpegEncContext * const s = &h->s;

2102

int list, i;

2103

int luma_def, chroma_def;

2104

2105

h->use_weight= 0;

2106

h->use_weight_chroma= 0;

2107

h->luma_log2_weight_denom= get_ue_golomb(&s->gb);

2108

if(h->sps.chroma_format_idc)

2109

h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);

2110

luma_def = 1<<h->luma_log2_weight_denom;

2111

chroma_def = 1<<h->chroma_log2_weight_denom;

2112

2113

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

2114

h->luma_weight_flag[list] = 0;

2115

h->chroma_weight_flag[list] = 0;

2116

for(i=0; i<h->ref_count[list]; i++){

2117

int luma_weight_flag, chroma_weight_flag;

2118

2119

luma_weight_flag= get_bits1(&s->gb);

2120

if(luma_weight_flag){

2121

h->luma_weight[i][list][0]= get_se_golomb(&s->gb);

2122

h->luma_weight[i][list][1]= get_se_golomb(&s->gb);

2123

if( h->luma_weight[i][list][0] != luma_def

2124

|| h->luma_weight[i][list][1] != 0) {

2125

h->use_weight= 1;

2126

h->luma_weight_flag[list]= 1;

2127

}

2128

}else{

2129

h->luma_weight[i][list][0]= luma_def;

2130

h->luma_weight[i][list][1]= 0;

2131

}

2132

2133

if(h->sps.chroma_format_idc){

2134

chroma_weight_flag= get_bits1(&s->gb);

2135

if(chroma_weight_flag){

2136

int j;

2137

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

2138

h->chroma_weight[i][list][j][0]= get_se_golomb(&s->gb);

2139

h->chroma_weight[i][list][j][1]= get_se_golomb(&s->gb);

2140

if( h->chroma_weight[i][list][j][0] != chroma_def

2141

|| h->chroma_weight[i][list][j][1] != 0) {

2142

h->use_weight_chroma= 1;

2143

h->chroma_weight_flag[list]= 1;

2144

}

2145

}

2146

}else{

2147

int j;

2148

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

2149

h->chroma_weight[i][list][j][0]= chroma_def;

2150

h->chroma_weight[i][list][j][1]= 0;

2151

}

2152

}

2153

}

2154

}

2155

if(h->slice_type_nos != AV_PICTURE_TYPE_B) break;

2156

}

2157

h->use_weight= h->use_weight || h->use_weight_chroma;

2158

return 0;

2159

}

2160

2161

/**

2162

* Initialize implicit_weight table.

2163

* @param field 0/1 initialize the weight for interlaced MBAFF

2164

* -1 initializes the rest

2165

2166

static void implicit_weight_table(H264Context *h, int field){

2167

MpegEncContext * const s = &h->s;

2168

int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;

2169

2170

for (i = 0; i < 2; i++) {

2171

h->luma_weight_flag[i] = 0;

2172

h->chroma_weight_flag[i] = 0;

2173

}

2174

2175

if(field < 0){

2176

cur_poc = s->current_picture_ptr->poc;

2177

if( h->ref_count[0] == 1 && h->ref_count[1] == 1 && !FRAME_MBAFF

2178

&& h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){

2179

h->use_weight= 0;

2180

h->use_weight_chroma= 0;

2181

return;

2182

}

2183

ref_start= 0;

2184

ref_count0= h->ref_count[0];

2185

ref_count1= h->ref_count[1];

2186

}else{

2187

cur_poc = s->current_picture_ptr->field_poc[field];

2188

ref_start= 16;

2189

ref_count0= 16+2*h->ref_count[0];

2190

ref_count1= 16+2*h->ref_count[1];

2191

}

2192

2193

h->use_weight= 2;

2194

h->use_weight_chroma= 2;

2195

h->luma_log2_weight_denom= 5;

2196

h->chroma_log2_weight_denom= 5;

2197

2198

for(ref0=ref_start; ref0 < ref_count0; ref0++){

2199

int poc0 = h->ref_list[0][ref0].poc;

2200

for(ref1=ref_start; ref1 < ref_count1; ref1++){

2201

int w = 32;

2202

if (!h->ref_list[0][ref0].long_ref && !h->ref_list[1][ref1].long_ref) {

2203

int poc1 = h->ref_list[1][ref1].poc;

2204

int td = av_clip(poc1 - poc0, -128, 127);

2205

if(td){

2206

int tb = av_clip(cur_poc - poc0, -128, 127);

2207

int tx = (16384 + (FFABS(td) >> 1)) / td;

2208

int dist_scale_factor = (tb*tx + 32) >> 8;

2209

if(dist_scale_factor >= -64 && dist_scale_factor <= 128)

2210

w = 64 - dist_scale_factor;

2211

}

2212

}

2213

if(field<0){

2214

h->implicit_weight[ref0][ref1][0]=

2215

h->implicit_weight[ref0][ref1][1]= w;

2216

}else{

2217

h->implicit_weight[ref0][ref1][field]=w;

2218

}

2219

}

2220

}

2221

}

2222

2223

/**

2224

* instantaneous decoder refresh.

2225

2226

static void idr(H264Context *h){

2227

ff_h264_remove_all_refs(h);

2228

h->prev_frame_num= 0;

2229

h->prev_frame_num_offset= 0;

2230

h->prev_poc_msb=

2231

h->prev_poc_lsb= 0;

2232

}

2233

2234

/* forget old pics after a seek */

2235

static void flush_dpb(AVCodecContext *avctx){

2236

H264Context *h= avctx->priv_data;

2237

int i;

2238

for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {

2239

if(h->delayed_pic[i])

2240

h->delayed_pic[i]->reference= 0;

2241

h->delayed_pic[i]= NULL;

2242

}

2243

h->outputed_poc=h->next_outputed_poc= INT_MIN;

2244

h->prev_interlaced_frame = 1;

2245

idr(h);

2246

if(h->s.current_picture_ptr)

2247

h->s.current_picture_ptr->reference= 0;

2248

h->s.first_field= 0;

2249

ff_h264_reset_sei(h);

2250

ff_mpeg_flush(avctx);

2251

}

2252

2253

static int init_poc(H264Context *h){

2254

MpegEncContext * const s = &h->s;

2255

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

2256

int field_poc[2];

2257

Picture *cur = s->current_picture_ptr;

2258

2259

h->frame_num_offset= h->prev_frame_num_offset;

2260

if(h->frame_num < h->prev_frame_num)

2261

h->frame_num_offset += max_frame_num;

2262

2263

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

2264

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

2265

2266

if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)

2267

h->poc_msb = h->prev_poc_msb + max_poc_lsb;

2268

else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)

2269

h->poc_msb = h->prev_poc_msb - max_poc_lsb;

2270

else

2271

h->poc_msb = h->prev_poc_msb;

2272

//printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);

2273

field_poc[0] =

2274

field_poc[1] = h->poc_msb + h->poc_lsb;

2275

if(s->picture_structure == PICT_FRAME)

2276

field_poc[1] += h->delta_poc_bottom;

2277

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

2278

int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;

2279

int i;

2280

2281

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

2282

abs_frame_num = h->frame_num_offset + h->frame_num;

2283

else

2284

abs_frame_num = 0;

2285

2286

if(h->nal_ref_idc==0 && abs_frame_num > 0)

2287

abs_frame_num--;

2288

2289

expected_delta_per_poc_cycle = 0;

2290

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

2291

expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse

2292

2293

if(abs_frame_num > 0){

2294

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

2295

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

2296

2297

expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;

2298

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

2299

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

2300

} else

2301

expectedpoc = 0;

2302

2303

if(h->nal_ref_idc == 0)

2304

expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;

2305

2306

field_poc[0] = expectedpoc + h->delta_poc[0];

2307

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

2308

2309

if(s->picture_structure == PICT_FRAME)

2310

field_poc[1] += h->delta_poc[1];

2311

}else{

2312

int poc= 2*(h->frame_num_offset + h->frame_num);

2313

2314

if(!h->nal_ref_idc)

2315

poc--;

2316

2317

field_poc[0]= poc;

2318

field_poc[1]= poc;

2319

}

2320

2321

if(s->picture_structure != PICT_BOTTOM_FIELD)

2322

s->current_picture_ptr->field_poc[0]= field_poc[0];

2323

if(s->picture_structure != PICT_TOP_FIELD)

2324

s->current_picture_ptr->field_poc[1]= field_poc[1];

2325

cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]);

2326

2327

return 0;

2328

}

2329

2330

2331

/**

2332

* initialize scan tables

2333

2334

static void init_scan_tables(H264Context *h){

2335

int i;

2336

for(i=0; i<16; i++){

2337

#define T(x) (x>>2) | ((x<<2) & 0xF)

2338

h->zigzag_scan[i] = T(zigzag_scan[i]);

2339

h-> field_scan[i] = T( field_scan[i]);

2340

#undef T

2341

}

2342

for(i=0; i<64; i++){

2343

#define T(x) (x>>3) | ((x&7)<<3)

2344

h->zigzag_scan8x8[i] = T(ff_zigzag_direct[i]);

2345

h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);

2346

h->field_scan8x8[i] = T(field_scan8x8[i]);

2347

h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]);

2348

#undef T

2349

}

2350

if(h->sps.transform_bypass){ //FIXME same ugly

2351

h->zigzag_scan_q0 = zigzag_scan;

2352

h->zigzag_scan8x8_q0 = ff_zigzag_direct;

2353

h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;

2354

h->field_scan_q0 = field_scan;

2355

h->field_scan8x8_q0 = field_scan8x8;

2356

h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc;

2357

}else{

2358

h->zigzag_scan_q0 = h->zigzag_scan;

2359

h->zigzag_scan8x8_q0 = h->zigzag_scan8x8;

2360

h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;

2361

h->field_scan_q0 = h->field_scan;

2362

h->field_scan8x8_q0 = h->field_scan8x8;

2363

h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc;

2364

}

2365

}

2366

2367

static void field_end(H264Context *h, int in_setup){

2368

MpegEncContext * const s = &h->s;

2369

AVCodecContext * const avctx= s->avctx;

2370

s->mb_y= 0;

2371

2372

if (!in_setup && !s->dropable)

2373

ff_thread_report_progress((AVFrame*)s->current_picture_ptr, (16*s->mb_height >> FIELD_PICTURE) - 1,

2374

s->picture_structure==PICT_BOTTOM_FIELD);

2375

2376

if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)

2377

ff_vdpau_h264_set_reference_frames(s);

2378

2379

if(in_setup || !(avctx->active_thread_type&FF_THREAD_FRAME)){

2380

if(!s->dropable) {

2381

ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);

2382

h->prev_poc_msb= h->poc_msb;

2383

h->prev_poc_lsb= h->poc_lsb;

2384

}

2385

h->prev_frame_num_offset= h->frame_num_offset;

2386

h->prev_frame_num= h->frame_num;

2387

h->outputed_poc = h->next_outputed_poc;

2388

}

2389

2390

if (avctx->hwaccel) {

2391

if (avctx->hwaccel->end_frame(avctx) < 0)

2392

av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");

2393

}

2394

2395

if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)

2396

ff_vdpau_h264_picture_complete(s);

2397

2398

2399

* FIXME: Error handling code does not seem to support interlaced

2400

* when slices span multiple rows

2401

* The ff_er_add_slice calls don't work right for bottom

2402

* fields; they cause massive erroneous error concealing

2403

* Error marking covers both fields (top and bottom).

2404

* This causes a mismatched s->error_count

2405

* and a bad error table. Further, the error count goes to

2406

* INT_MAX when called for bottom field, because mb_y is

2407

* past end by one (callers fault) and resync_mb_y != 0

2408

* causes problems for the first MB line, too.

2409

2410

if (!FIELD_PICTURE)

2411

ff_er_frame_end(s);

2412

2413

MPV_frame_end(s);

2414

2415

h->current_slice=0;

2416

}

2417

2418

/**

2419

* Replicate H264 "master" context to thread contexts.

2420

2421

static void clone_slice(H264Context *dst, H264Context *src)

2422

{

2423

memcpy(dst->block_offset, src->block_offset, sizeof(dst->block_offset));

2424

dst->s.current_picture_ptr = src->s.current_picture_ptr;

2425

dst->s.current_picture = src->s.current_picture;

2426

dst->s.linesize = src->s.linesize;

2427

dst->s.uvlinesize = src->s.uvlinesize;

2428

dst->s.first_field = src->s.first_field;

2429

2430

dst->prev_poc_msb = src->prev_poc_msb;

2431

dst->prev_poc_lsb = src->prev_poc_lsb;

2432

dst->prev_frame_num_offset = src->prev_frame_num_offset;

2433

dst->prev_frame_num = src->prev_frame_num;

2434

dst->short_ref_count = src->short_ref_count;

2435

2436

memcpy(dst->short_ref, src->short_ref, sizeof(dst->short_ref));

2437

memcpy(dst->long_ref, src->long_ref, sizeof(dst->long_ref));

2438

memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list));

2439

memcpy(dst->ref_list, src->ref_list, sizeof(dst->ref_list));

2440

2441

memcpy(dst->dequant4_coeff, src->dequant4_coeff, sizeof(src->dequant4_coeff));

2442

memcpy(dst->dequant8_coeff, src->dequant8_coeff, sizeof(src->dequant8_coeff));

2443

}

2444

2445

/**

2446

* computes profile from profile_idc and constraint_set?_flags

2447

2448

* @param sps SPS

2449

2450

* @return profile as defined by FF_PROFILE_H264_*

2451

2452

int ff_h264_get_profile(SPS *sps)

2453

{

2454

int profile = sps->profile_idc;

2455

2456

switch(sps->profile_idc) {

2457

case FF_PROFILE_H264_BASELINE:

2458

// constraint_set1_flag set to 1

2459

profile |= (sps->constraint_set_flags & 1<<1) ? FF_PROFILE_H264_CONSTRAINED : 0;

2460

break;

2461

case FF_PROFILE_H264_HIGH_10:

2462

case FF_PROFILE_H264_HIGH_422:

2463

case FF_PROFILE_H264_HIGH_444_PREDICTIVE:

2464

// constraint_set3_flag set to 1

2465

profile |= (sps->constraint_set_flags & 1<<3) ? FF_PROFILE_H264_INTRA : 0;

2466

break;

2467

}

2468

2469

return profile;

2470

}

2471

2472

/**

2473

* decodes a slice header.

2474

* This will also call MPV_common_init() and frame_start() as needed.

2475

2476

* @param h h264context

2477

* @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding)

2478

2479

* @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded

2480

2481

static int decode_slice_header(H264Context *h, H264Context *h0){

2482

MpegEncContext * const s = &h->s;

2483

MpegEncContext * const s0 = &h0->s;

2484

unsigned int first_mb_in_slice;

2485

unsigned int pps_id;

2486

int num_ref_idx_active_override_flag;

2487

unsigned int slice_type, tmp, i, j;

2488

int default_ref_list_done = 0;

2489

int last_pic_structure;

2490

2491

s->dropable= h->nal_ref_idc == 0;

2492

2493

/* FIXME: 2tap qpel isn't implemented for high bit depth. */

2494

if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc && !h->pixel_shift){

2495

s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;

2496

s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;

2497

}else{

2498

s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;

2499

s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;

2500

}

2501

2502

first_mb_in_slice= get_ue_golomb(&s->gb);

2503

2504

if(first_mb_in_slice == 0){ //FIXME better field boundary detection

2505

if(h0->current_slice && FIELD_PICTURE){

2506

field_end(h, 1);

2507

}

2508

2509

h0->current_slice = 0;

2510

if (!s0->first_field)

2511

s->current_picture_ptr= NULL;

2512

}

2513

2514

slice_type= get_ue_golomb_31(&s->gb);

2515

if(slice_type > 9){

2516

av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);

2517

return -1;

2518

}

2519

if(slice_type > 4){

2520

slice_type -= 5;

2521

h->slice_type_fixed=1;

2522

}else

2523

h->slice_type_fixed=0;

2524

2525

slice_type= golomb_to_pict_type[ slice_type ];

2526

if (slice_type == AV_PICTURE_TYPE_I

2527

|| (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {

2528

default_ref_list_done = 1;

2529

}

2530

h->slice_type= slice_type;

2531

h->slice_type_nos= slice_type & 3;

2532

2533

s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though

2534

2535

pps_id= get_ue_golomb(&s->gb);

2536

if(pps_id>=MAX_PPS_COUNT){

2537

av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");

2538

return -1;

2539

}

2540

if(!h0->pps_buffers[pps_id]) {

2541

av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS %u referenced\n", pps_id);

2542

return -1;

2543

}

2544

h->pps= *h0->pps_buffers[pps_id];

2545

2546

if(!h0->sps_buffers[h->pps.sps_id]) {

2547

av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS %u referenced\n", h->pps.sps_id);

2548

return -1;

2549

}

2550

h->sps = *h0->sps_buffers[h->pps.sps_id];

2551

2552

s->avctx->profile = ff_h264_get_profile(&h->sps);

2553

s->avctx->level = h->sps.level_idc;

2554

s->avctx->refs = h->sps.ref_frame_count;

2555

2556

if(h == h0 && h->dequant_coeff_pps != pps_id){

2557

h->dequant_coeff_pps = pps_id;

2558

init_dequant_tables(h);

2559

}

2560

2561

s->mb_width= h->sps.mb_width;

2562

s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);

2563

2564

h->b_stride= s->mb_width*4;

2565

2566

s->width = 16*s->mb_width - (2>>CHROMA444)*FFMIN(h->sps.crop_right, (8<<CHROMA444)-1);

2567

if(h->sps.frame_mbs_only_flag)

2568

s->height= 16*s->mb_height - (2>>CHROMA444)*FFMIN(h->sps.crop_bottom, (8<<CHROMA444)-1);

2569

else

2570

s->height= 16*s->mb_height - (4>>CHROMA444)*FFMIN(h->sps.crop_bottom, (8<<CHROMA444)-1);

2571

2572

if (s->context_initialized

2573

&& ( s->width != s->avctx->width || s->height != s->avctx->height

2574

|| av_cmp_q(h->sps.sar, s->avctx->sample_aspect_ratio))) {

2575

if(h != h0) {

2576

av_log_missing_feature(s->avctx, "Width/height changing with threads is", 0);

2577

return -1; // width / height changed during parallelized decoding

2578

}

2579

free_tables(h, 0);

2580

flush_dpb(s->avctx);

2581

MPV_common_end(s);

2582

}

2583

if (!s->context_initialized) {

2584

if (h != h0) {

2585

av_log(h->s.avctx, AV_LOG_ERROR, "Cannot (re-)initialize context during parallel decoding.\n");

2586

return -1;

2587

}

2588

2589

avcodec_set_dimensions(s->avctx, s->width, s->height);

2590

s->avctx->sample_aspect_ratio= h->sps.sar;

2591

av_assert0(s->avctx->sample_aspect_ratio.den);

2592

2593

h->s.avctx->coded_width = 16*s->mb_width;

2594

h->s.avctx->coded_height = 16*s->mb_height;

2595

2596

if(h->sps.video_signal_type_present_flag){

2597

s->avctx->color_range = h->sps.full_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;

2598

if(h->sps.colour_description_present_flag){

2599

s->avctx->color_primaries = h->sps.color_primaries;

2600

s->avctx->color_trc = h->sps.color_trc;

2601

s->avctx->colorspace = h->sps.colorspace;

2602

}

2603

}

2604

2605

if(h->sps.timing_info_present_flag){

2606

int64_t den= h->sps.time_scale;

2607

if(h->x264_build < 44U)

2608

den *= 2;

2609

av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,

2610

h->sps.num_units_in_tick, den, 1<<30);

2611

}

2612

2613

switch (h->sps.bit_depth_luma) {

2614

case 9 :

2615

s->avctx->pix_fmt = CHROMA444 ? PIX_FMT_YUV444P9 : PIX_FMT_YUV420P9;

2616

break;

2617

case 10 :

2618

s->avctx->pix_fmt = CHROMA444 ? PIX_FMT_YUV444P10 : PIX_FMT_YUV420P10;

2619

break;

2620

default:

2621

if (CHROMA444){

2622

s->avctx->pix_fmt = s->avctx->color_range == AVCOL_RANGE_JPEG ? PIX_FMT_YUVJ444P : PIX_FMT_YUV444P;

2623

}else{

2624

s->avctx->pix_fmt = s->avctx->get_format(s->avctx,

2625

s->avctx->codec->pix_fmts ?

2626

s->avctx->codec->pix_fmts :

2627

s->avctx->color_range == AVCOL_RANGE_JPEG ?

2628

hwaccel_pixfmt_list_h264_jpeg_420 :

2629

ff_hwaccel_pixfmt_list_420);

2630

}

2631

}

2632

2633

s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);

2634

2635

if (MPV_common_init(s) < 0) {

2636

av_log(h->s.avctx, AV_LOG_ERROR, "MPV_common_init() failed.\n");

2637

return -1;

2638

}

2639

s->first_field = 0;

2640

h->prev_interlaced_frame = 1;

2641

2642

init_scan_tables(h);

2643

if (ff_h264_alloc_tables(h) < 0) {

2644

av_log(h->s.avctx, AV_LOG_ERROR, "Could not allocate memory for h264\n");

2645

return AVERROR(ENOMEM);

2646

}

2647

2648

if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_SLICE)) {

2649

if (context_init(h) < 0) {

2650

av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");

2651

return -1;

2652

}

2653

} else {

2654

for(i = 1; i < s->avctx->thread_count; i++) {

2655

H264Context *c;

2656

c = h->thread_context[i] = av_malloc(sizeof(H264Context));

2657

memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));

2658

memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));

2659

c->h264dsp = h->h264dsp;

2660

c->sps = h->sps;

2661

c->pps = h->pps;

2662

c->pixel_shift = h->pixel_shift;

2663

init_scan_tables(c);

2664

clone_tables(c, h, i);

2665

}

2666

2667

for(i = 0; i < s->avctx->thread_count; i++)

2668

if (context_init(h->thread_context[i]) < 0) {

2669

av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");

2670

return -1;

2671

}

2672

}

2673

}

2674

2675

h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);

2676

2677

h->mb_mbaff = 0;

2678

h->mb_aff_frame = 0;

2679

last_pic_structure = s0->picture_structure;

2680

if(h->sps.frame_mbs_only_flag){

2681

s->picture_structure= PICT_FRAME;

2682

}else{

2683

if(get_bits1(&s->gb)) { //field_pic_flag

2684

s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag

2685

} else {

2686

s->picture_structure= PICT_FRAME;

2687

h->mb_aff_frame = h->sps.mb_aff;

2688

}

2689

}

2690

h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;

2691

2692

if(h0->current_slice == 0){

2693

// Shorten frame num gaps so we don't have to allocate reference frames just to throw them away

2694

if(h->frame_num != h->prev_frame_num) {

2695

int unwrap_prev_frame_num = h->prev_frame_num, max_frame_num = 1<<h->sps.log2_max_frame_num;

2696

2697

if (unwrap_prev_frame_num > h->frame_num) unwrap_prev_frame_num -= max_frame_num;

2698

2699

if ((h->frame_num - unwrap_prev_frame_num) > h->sps.ref_frame_count) {

2700

unwrap_prev_frame_num = (h->frame_num - h->sps.ref_frame_count) - 1;

2701

if (unwrap_prev_frame_num < 0)

2702

unwrap_prev_frame_num += max_frame_num;

2703

2704

h->prev_frame_num = unwrap_prev_frame_num;

2705

}

2706

}

2707

2708

while(h->frame_num != h->prev_frame_num &&

2709

h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){

2710

Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;

2711

av_log(h->s.avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n", h->frame_num, h->prev_frame_num);

2712

if (ff_h264_frame_start(h) < 0)

2713

return -1;

2714

h->prev_frame_num++;

2715

h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;

2716

s->current_picture_ptr->frame_num= h->prev_frame_num;

2717

ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 0);

2718

ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 1);

2719

ff_generate_sliding_window_mmcos(h);

2720

ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);

2721

/* Error concealment: if a ref is missing, copy the previous ref in its place.

2722

* FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions

2723

* about there being no actual duplicates.

2724

* FIXME: this doesn't copy padding for out-of-frame motion vectors. Given we're

2725

* concealing a lost frame, this probably isn't noticable by comparison, but it should

2726

* be fixed. */

2727

if (h->short_ref_count) {

2728

if (prev) {

2729

av_image_copy(h->short_ref[0]->data, h->short_ref[0]->linesize,

2730

(const uint8_t**)prev->data, prev->linesize,

2731

s->avctx->pix_fmt, s->mb_width*16, s->mb_height*16);

2732

h->short_ref[0]->poc = prev->poc+2;

2733

}

2734

h->short_ref[0]->frame_num = h->prev_frame_num;

2735

}

2736

}

2737

2738

/* See if we have a decoded first field looking for a pair... */

2739

if (s0->first_field) {

2740

assert(s0->current_picture_ptr);

2741

assert(s0->current_picture_ptr->data[0]);

2742

assert(s0->current_picture_ptr->reference != DELAYED_PIC_REF);

2743

2744

/* figure out if we have a complementary field pair */

2745

if (!FIELD_PICTURE || s->picture_structure == last_pic_structure) {

2746

2747

* Previous field is unmatched. Don't display it, but let it

2748

* remain for reference if marked as such.

2749

2750

s0->current_picture_ptr = NULL;

2751

s0->first_field = FIELD_PICTURE;

2752

2753

} else {

2754

if (h->nal_ref_idc &&

2755

s0->current_picture_ptr->reference &&

2756

s0->current_picture_ptr->frame_num != h->frame_num) {

2757

2758

* This and previous field were reference, but had

2759

* different frame_nums. Consider this field first in

2760

* pair. Throw away previous field except for reference

2761

* purposes.

2762

2763

s0->first_field = 1;

2764

s0->current_picture_ptr = NULL;

2765

2766

} else {

2767

/* Second field in complementary pair */

2768

s0->first_field = 0;

2769

}

2770

}

2771

2772

} else {

2773

/* Frame or first field in a potentially complementary pair */

2774

assert(!s0->current_picture_ptr);

2775

s0->first_field = FIELD_PICTURE;

2776

}

2777

2778

if(!FIELD_PICTURE || s0->first_field) {

2779

if (ff_h264_frame_start(h) < 0) {

2780

s0->first_field = 0;

2781

return -1;

2782

}

2783

} else {

2784

ff_release_unused_pictures(s, 0);

2785

}

2786

}

2787

if(h != h0)

2788

clone_slice(h, h0);

2789

2790

s->current_picture_ptr->frame_num= h->frame_num; //FIXME frame_num cleanup

2791

2792

assert(s->mb_num == s->mb_width * s->mb_height);

2793

if(first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num ||

2794

first_mb_in_slice >= s->mb_num){

2795

av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");

2796

return -1;

2797

}

2798

s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;

2799

s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << FIELD_OR_MBAFF_PICTURE;

2800

if (s->picture_structure == PICT_BOTTOM_FIELD)

2801

s->resync_mb_y = s->mb_y = s->mb_y + 1;

2802

assert(s->mb_y < s->mb_height);

2803

2804

if(s->picture_structure==PICT_FRAME){

2805

h->curr_pic_num= h->frame_num;

2806

h->max_pic_num= 1<< h->sps.log2_max_frame_num;

2807

}else{

2808

h->curr_pic_num= 2*h->frame_num + 1;

2809

h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);

2810

}

2811

2812

if(h->nal_unit_type == NAL_IDR_SLICE){

2813

get_ue_golomb(&s->gb); /* idr_pic_id */

2814

}

2815

2816

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

2817

h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);

2818

2819

if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){

2820

h->delta_poc_bottom= get_se_golomb(&s->gb);

2821

}

2822

}

2823

2824

if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){

2825

h->delta_poc[0]= get_se_golomb(&s->gb);

2826

2827

if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)

2828

h->delta_poc[1]= get_se_golomb(&s->gb);

2829

}

2830

2831

init_poc(h);

2832

2833

if(h->pps.redundant_pic_cnt_present){

2834

h->redundant_pic_count= get_ue_golomb(&s->gb);

2835

}

2836

2837

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

2838

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

2839

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

2840

2841

if(h->slice_type_nos != AV_PICTURE_TYPE_I){

2842

if(h->slice_type_nos == AV_PICTURE_TYPE_B){

2843

h->direct_spatial_mv_pred= get_bits1(&s->gb);

2844

}

2845

num_ref_idx_active_override_flag= get_bits1(&s->gb);

2846

2847

if(num_ref_idx_active_override_flag){

2848

h->ref_count[0]= get_ue_golomb(&s->gb) + 1;

2849

if(h->slice_type_nos==AV_PICTURE_TYPE_B)

2850

h->ref_count[1]= get_ue_golomb(&s->gb) + 1;

2851

2852

if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){

2853

av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");

2854

h->ref_count[0]= h->ref_count[1]= 1;

2855

return -1;

2856

}

2857

}

2858

if(h->slice_type_nos == AV_PICTURE_TYPE_B)

2859

h->list_count= 2;

2860

else

2861

h->list_count= 1;

2862

}else

2863

h->list_count= 0;

2864

2865

if(!default_ref_list_done){

2866

ff_h264_fill_default_ref_list(h);

2867

}

2868

2869

if(h->slice_type_nos!=AV_PICTURE_TYPE_I && ff_h264_decode_ref_pic_list_reordering(h) < 0)

2870

return -1;

2871

2872

if(h->slice_type_nos!=AV_PICTURE_TYPE_I){

2873

s->last_picture_ptr= &h->ref_list[0][0];

2874

ff_copy_picture(&s->last_picture, s->last_picture_ptr);

2875

}

2876

if(h->slice_type_nos==AV_PICTURE_TYPE_B){

2877

s->next_picture_ptr= &h->ref_list[1][0];

2878

ff_copy_picture(&s->next_picture, s->next_picture_ptr);

2879

}

2880

2881

if( (h->pps.weighted_pred && h->slice_type_nos == AV_PICTURE_TYPE_P )

2882

|| (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== AV_PICTURE_TYPE_B ) )

2883

pred_weight_table(h);

2884

else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== AV_PICTURE_TYPE_B){

2885

implicit_weight_table(h, -1);

2886

}else {

2887

h->use_weight = 0;

2888

for (i = 0; i < 2; i++) {

2889

h->luma_weight_flag[i] = 0;

2890

h->chroma_weight_flag[i] = 0;

2891

}

2892

}

2893

2894

if(h->nal_ref_idc)

2895

ff_h264_decode_ref_pic_marking(h0, &s->gb);

2896

2897

if(FRAME_MBAFF){

2898

ff_h264_fill_mbaff_ref_list(h);

2899

2900

if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== AV_PICTURE_TYPE_B){

2901

implicit_weight_table(h, 0);

2902

implicit_weight_table(h, 1);

2903

}

2904

}

2905

2906

if(h->slice_type_nos==AV_PICTURE_TYPE_B && !h->direct_spatial_mv_pred)

2907

ff_h264_direct_dist_scale_factor(h);

2908

ff_h264_direct_ref_list_init(h);

2909

2910

if( h->slice_type_nos != AV_PICTURE_TYPE_I && h->pps.cabac ){

2911

tmp = get_ue_golomb_31(&s->gb);

2912

if(tmp > 2){

2913

av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");

2914

return -1;

2915

}

2916

h->cabac_init_idc= tmp;

2917

}

2918

2919

h->last_qscale_diff = 0;

2920

tmp = h->pps.init_qp + get_se_golomb(&s->gb);

2921

if(tmp>51+6*(h->sps.bit_depth_luma-8)){

2922

av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);

2923

return -1;

2924

}

2925

s->qscale= tmp;

2926

h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);

2927

h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);

2928

//FIXME qscale / qp ... stuff

2929

if(h->slice_type == AV_PICTURE_TYPE_SP){

2930

get_bits1(&s->gb); /* sp_for_switch_flag */

2931

}

2932

if(h->slice_type==AV_PICTURE_TYPE_SP || h->slice_type == AV_PICTURE_TYPE_SI){

2933

get_se_golomb(&s->gb); /* slice_qs_delta */

2934

}

2935

2936

h->deblocking_filter = 1;

2937

h->slice_alpha_c0_offset = 52;

2938

h->slice_beta_offset = 52;

2939

if( h->pps.deblocking_filter_parameters_present ) {

2940

tmp= get_ue_golomb_31(&s->gb);

2941

if(tmp > 2){

2942

av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp);

2943

return -1;

2944

}

2945

h->deblocking_filter= tmp;

2946

if(h->deblocking_filter < 2)

2947

h->deblocking_filter^= 1; // 1<->0

2948

2949

if( h->deblocking_filter ) {

2950

h->slice_alpha_c0_offset += get_se_golomb(&s->gb) << 1;

2951

h->slice_beta_offset += get_se_golomb(&s->gb) << 1;

2952

if( h->slice_alpha_c0_offset > 104U

2953

|| h->slice_beta_offset > 104U){

2954

av_log(s->avctx, AV_LOG_ERROR, "deblocking filter parameters %d %d out of range\n", h->slice_alpha_c0_offset, h->slice_beta_offset);

2955

return -1;

2956

}

2957

}

2958

}

2959

2960

if( s->avctx->skip_loop_filter >= AVDISCARD_ALL

2961

||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != AV_PICTURE_TYPE_I)

2962

||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type_nos == AV_PICTURE_TYPE_B)

2963

||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))

2964

h->deblocking_filter= 0;

2965

2966

if(h->deblocking_filter == 1 && h0->max_contexts > 1) {

2967

if(s->avctx->flags2 & CODEC_FLAG2_FAST) {

2968

/* Cheat slightly for speed:

2969

Do not bother to deblock across slices. */

2970

h->deblocking_filter = 2;

2971

} else {

2972

h0->max_contexts = 1;

2973

if(!h0->single_decode_warning) {

2974

av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");

2975

h0->single_decode_warning = 1;

2976

}

2977

if (h != h0) {

2978

av_log(h->s.avctx, AV_LOG_ERROR, "Deblocking switched inside frame.\n");

2979

return 1;

2980

}

2981

}

2982

}

2983

h->qp_thresh= 15 + 52 - FFMIN(h->slice_alpha_c0_offset, h->slice_beta_offset) - FFMAX3(0, h->pps.chroma_qp_index_offset[0], h->pps.chroma_qp_index_offset[1]);

2984

2985

#if 0 //FMO

2986

if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)

2987

slice_group_change_cycle= get_bits(&s->gb, ?);

2988

#endif

2989

2990

h0->last_slice_type = slice_type;

2991

h->slice_num = ++h0->current_slice;

2992

if(h->slice_num >= MAX_SLICES){

2993

av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n");

2994

}

2995

2996

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

2997

int id_list[16];

2998

int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j];

2999

for(i=0; i<16; i++){

3000

id_list[i]= 60;

3001

if(h->ref_list[j][i].data[0]){

3002

int k;

3003

uint8_t *base= h->ref_list[j][i].base[0];

3004

for(k=0; k<h->short_ref_count; k++)

3005

if(h->short_ref[k]->base[0] == base){

3006

id_list[i]= k;

3007

break;

3008

}

3009

for(k=0; k<h->long_ref_count; k++)

3010

if(h->long_ref[k] && h->long_ref[k]->base[0] == base){

3011

id_list[i]= h->short_ref_count + k;

3012

break;

3013

}

3014

}

3015

}

3016

3017

ref2frm[0]=

3018

ref2frm[1]= -1;

3019

for(i=0; i<16; i++)

3020

ref2frm[i+2]= 4*id_list[i]

3021

+(h->ref_list[j][i].reference&3);

3022

ref2frm[18+0]=

3023

ref2frm[18+1]= -1;

3024

for(i=16; i<48; i++)

3025

ref2frm[i+4]= 4*id_list[(i-16)>>1]

3026

+(h->ref_list[j][i].reference&3);

3027

}

3028

3029

//FIXME: fix draw_edges+PAFF+frame threads

3030

h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE || (!h->sps.frame_mbs_only_flag && s->avctx->active_thread_type)) ? 0 : 16;

3031

h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;

3032

3033

if(s->avctx->debug&FF_DEBUG_PICT_INFO){

3034

av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",

3035

h->slice_num,

3036

(s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),

3037

first_mb_in_slice,

3038

av_get_picture_type_char(h->slice_type), h->slice_type_fixed ? " fix" : "", h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",

3039

pps_id, h->frame_num,

3040

s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],

3041

h->ref_count[0], h->ref_count[1],

3042

s->qscale,

3043

h->deblocking_filter, h->slice_alpha_c0_offset/2-26, h->slice_beta_offset/2-26,

3044

h->use_weight,

3045

h->use_weight==1 && h->use_weight_chroma ? "c" : "",

3046

h->slice_type == AV_PICTURE_TYPE_B ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : ""

3047

);

3048

}

3049

3050

return 0;

3051

}

3052

3053

int ff_h264_get_slice_type(const H264Context *h)

3054

{

3055

switch (h->slice_type) {

3056

case AV_PICTURE_TYPE_P: return 0;

3057

case AV_PICTURE_TYPE_B: return 1;

3058

case AV_PICTURE_TYPE_I: return 2;

3059

case AV_PICTURE_TYPE_SP: return 3;

3060

case AV_PICTURE_TYPE_SI: return 4;

3061

default: return -1;

3062

}

3063

}

3064

3065

/**

3066

3067

* @return non zero if the loop filter can be skiped

3068

3069

static int fill_filter_caches(H264Context *h, int mb_type){

3070

MpegEncContext * const s = &h->s;

3071

const int mb_xy= h->mb_xy;

3072

int top_xy, left_xy[2];

3073

int top_type, left_type[2];

3074

3075

top_xy = mb_xy - (s->mb_stride << MB_FIELD);

3076

3077

//FIXME deblocking could skip the intra and nnz parts.

3078

3079

/* Wow, what a mess, why didn't they simplify the interlacing & intra

3080

* stuff, I can't imagine that these complex rules are worth it. */

3081

3082

left_xy[1] = left_xy[0] = mb_xy-1;

3083

if(FRAME_MBAFF){

3084

const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);

3085

const int curr_mb_field_flag = IS_INTERLACED(mb_type);

3086

if(s->mb_y&1){

3087

if (left_mb_field_flag != curr_mb_field_flag) {

3088

left_xy[0] -= s->mb_stride;

3089

}

3090

}else{

3091

if(curr_mb_field_flag){

3092

top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1);

3093

}

3094

if (left_mb_field_flag != curr_mb_field_flag) {

3095

left_xy[1] += s->mb_stride;

3096

}

3097

}

3098

}

3099

3100

h->top_mb_xy = top_xy;

3101

h->left_mb_xy[0] = left_xy[0];

3102

h->left_mb_xy[1] = left_xy[1];

3103

{

3104

//for sufficiently low qp, filtering wouldn't do anything

3105

//this is a conservative estimate: could also check beta_offset and more accurate chroma_qp

3106

int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice

3107

int qp = s->current_picture.qscale_table[mb_xy];

3108

if(qp <= qp_thresh

3109

&& (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)

3110

&& (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){

3111

if(!FRAME_MBAFF)

3112

return 1;

3113

if( (left_xy[0]< 0 || ((qp + s->current_picture.qscale_table[left_xy[1] ] + 1)>>1) <= qp_thresh)

3114

&& (top_xy < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy -s->mb_stride] + 1)>>1) <= qp_thresh))

3115

return 1;

3116

}

3117

}

3118

3119

top_type = s->current_picture.mb_type[top_xy] ;

3120

left_type[0] = s->current_picture.mb_type[left_xy[0]];

3121

left_type[1] = s->current_picture.mb_type[left_xy[1]];

3122

if(h->deblocking_filter == 2){

3123

if(h->slice_table[top_xy ] != h->slice_num) top_type= 0;

3124

if(h->slice_table[left_xy[0] ] != h->slice_num) left_type[0]= left_type[1]= 0;

3125

}else{

3126

if(h->slice_table[top_xy ] == 0xFFFF) top_type= 0;

3127

if(h->slice_table[left_xy[0] ] == 0xFFFF) left_type[0]= left_type[1] =0;

3128

}

3129

h->top_type = top_type ;

3130

h->left_type[0]= left_type[0];

3131

h->left_type[1]= left_type[1];

3132

3133

if(IS_INTRA(mb_type))

3134

return 0;

3135

3136

AV_COPY32(&h->non_zero_count_cache[4+8* 1], &h->non_zero_count[mb_xy][ 0]);

3137

AV_COPY32(&h->non_zero_count_cache[4+8* 2], &h->non_zero_count[mb_xy][ 4]);

3138

AV_COPY32(&h->non_zero_count_cache[4+8* 3], &h->non_zero_count[mb_xy][ 8]);

3139

AV_COPY32(&h->non_zero_count_cache[4+8* 4], &h->non_zero_count[mb_xy][12]);

3140

3141

h->cbp= h->cbp_table[mb_xy];

3142

3143

{

3144

int list;

3145

for(list=0; list<h->list_count; list++){

3146

int8_t *ref;

3147

int y, b_stride;

3148

int16_t (*mv_dst)[2];

3149

int16_t (*mv_src)[2];

3150

3151

if(!USES_LIST(mb_type, list)){

3152

fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);

3153

AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);

3154

AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);

3155

AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);

3156

AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);

3157

continue;

3158

}

3159

3160

ref = &s->current_picture.ref_index[list][4*mb_xy];

3161

{

3162

int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);

3163

AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);

3164

AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);

3165

ref += 2;

3166

AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);

3167

AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);

3168

}

3169

3170

b_stride = h->b_stride;

3171

mv_dst = &h->mv_cache[list][scan8[0]];

3172

mv_src = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];

3173

for(y=0; y<4; y++){

3174

AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);

3175

}

3176

3177

}

3178

}

3179

3180

3181

3182

0 . T T. T T T T

3183

1 L . .L . . . .

3184

2 L . .L . . . .

3185

3 . T TL . . . .

3186

4 L . .L . . . .

3187

5 L . .. . . . .

3188

3189

//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)

3190

if(top_type){

3191

AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][3*4]);

3192

}

3193

3194

if(left_type[0]){

3195

h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][3+0*4];

3196

h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][3+1*4];

3197

h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][3+2*4];

3198

h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][3+3*4];

3199

}

3200

3201

// CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs

3202

if(!CABAC && h->pps.transform_8x8_mode){

3203

if(IS_8x8DCT(top_type)){

3204

h->non_zero_count_cache[4+8*0]=

3205

h->non_zero_count_cache[5+8*0]= (h->cbp_table[top_xy] & 0x4000) >> 12;

3206

h->non_zero_count_cache[6+8*0]=

3207

h->non_zero_count_cache[7+8*0]= (h->cbp_table[top_xy] & 0x8000) >> 12;

3208

}

3209

if(IS_8x8DCT(left_type[0])){

3210

h->non_zero_count_cache[3+8*1]=

3211

h->non_zero_count_cache[3+8*2]= (h->cbp_table[left_xy[0]]&0x2000) >> 12; //FIXME check MBAFF

3212

}

3213

if(IS_8x8DCT(left_type[1])){

3214

h->non_zero_count_cache[3+8*3]=

3215

h->non_zero_count_cache[3+8*4]= (h->cbp_table[left_xy[1]]&0x8000) >> 12; //FIXME check MBAFF

3216

}

3217

3218

if(IS_8x8DCT(mb_type)){

3219

h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]=

3220

h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= (h->cbp & 0x1000) >> 12;

3221

3222

h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=

3223

h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= (h->cbp & 0x2000) >> 12;

3224

3225

h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=

3226

h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= (h->cbp & 0x4000) >> 12;

3227

3228

h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=

3229

h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= (h->cbp & 0x8000) >> 12;

3230

}

3231

}

3232

3233

if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){

3234

int list;

3235

for(list=0; list<h->list_count; list++){

3236

if(USES_LIST(top_type, list)){

3237

const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;

3238

const int b8_xy= 4*top_xy + 2;

3239

int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);

3240

AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);

3241

h->ref_cache[list][scan8[0] + 0 - 1*8]=

3242

h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];

3243

h->ref_cache[list][scan8[0] + 2 - 1*8]=

3244

h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];

3245

}else{

3246

AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);

3247

AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);

3248

}

3249

3250

if(!IS_INTERLACED(mb_type^left_type[0])){

3251

if(USES_LIST(left_type[0], list)){

3252

const int b_xy= h->mb2b_xy[left_xy[0]] + 3;

3253

const int b8_xy= 4*left_xy[0] + 1;

3254

int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);

3255

AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]);

3256

AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]);

3257

AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]);

3258

AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]);

3259

h->ref_cache[list][scan8[0] - 1 + 0 ]=

3260

h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]];

3261

h->ref_cache[list][scan8[0] - 1 +16 ]=

3262

h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]];

3263

}else{

3264

AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]);

3265

AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]);

3266

AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]);

3267

AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]);

3268

h->ref_cache[list][scan8[0] - 1 + 0 ]=

3269

h->ref_cache[list][scan8[0] - 1 + 8 ]=

3270

h->ref_cache[list][scan8[0] - 1 + 16 ]=

3271

h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;

3272

}

3273

}

3274

}

3275

}

3276

3277

return 0;

3278

}

3279

3280

static void loop_filter(H264Context *h, int start_x, int end_x){

3281

MpegEncContext * const s = &h->s;

3282

uint8_t *dest_y, *dest_cb, *dest_cr;

3283

int linesize, uvlinesize, mb_x, mb_y;

3284

const int end_mb_y= s->mb_y + FRAME_MBAFF;

3285

const int old_slice_type= h->slice_type;

3286

const int pixel_shift = h->pixel_shift;

3287

3288

if(h->deblocking_filter) {

3289

for(mb_x= start_x; mb_x<end_x; mb_x++){

3290

for(mb_y=end_mb_y - FRAME_MBAFF; mb_y<= end_mb_y; mb_y++){

3291

int mb_xy, mb_type;

3292

mb_xy = h->mb_xy = mb_x + mb_y*s->mb_stride;

3293

h->slice_num= h->slice_table[mb_xy];

3294

mb_type= s->current_picture.mb_type[mb_xy];

3295

h->list_count= h->list_counts[mb_xy];

3296

3297

if(FRAME_MBAFF)

3298

h->mb_mbaff = h->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);

3299

3300

s->mb_x= mb_x;

3301

s->mb_y= mb_y;

3302

dest_y = s->current_picture.data[0] + ((mb_x << pixel_shift) + mb_y * s->linesize ) * 16;

3303

dest_cb = s->current_picture.data[1] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * (8 << CHROMA444);

3304

dest_cr = s->current_picture.data[2] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * (8 << CHROMA444);

3305

//FIXME simplify above

3306

3307

if (MB_FIELD) {

3308

linesize = h->mb_linesize = s->linesize * 2;

3309

uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;

3310

if(mb_y&1){ //FIXME move out of this function?

3311

dest_y -= s->linesize*15;

3312

dest_cb-= s->uvlinesize*((8 << CHROMA444)-1);

3313

dest_cr-= s->uvlinesize*((8 << CHROMA444)-1);

3314

}

3315

} else {

3316

linesize = h->mb_linesize = s->linesize;

3317

uvlinesize = h->mb_uvlinesize = s->uvlinesize;

3318

}

3319

backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, CHROMA444, 0);

3320

if(fill_filter_caches(h, mb_type))

3321

continue;

3322

h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);

3323

h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);

3324

3325

if (FRAME_MBAFF) {

3326

ff_h264_filter_mb (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);

3327

} else {

3328

ff_h264_filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);

3329

}

3330

}

3331

}

3332

}

3333

h->slice_type= old_slice_type;

3334

s->mb_x= end_x;

3335

s->mb_y= end_mb_y - FRAME_MBAFF;

3336

h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);

3337

h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);

3338

}

3339

3340

static void predict_field_decoding_flag(H264Context *h){

3341

MpegEncContext * const s = &h->s;

3342

const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

3343

int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)

3344

? s->current_picture.mb_type[mb_xy-1]

3345

: (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)

3346

? s->current_picture.mb_type[mb_xy-s->mb_stride]

3347

: 0;

3348

h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;

3349

}

3350

3351

/**

3352

* Draw edges and report progress for the last MB row.

3353

3354

static void decode_finish_row(H264Context *h){

3355

MpegEncContext * const s = &h->s;

3356

int top = 16*(s->mb_y >> FIELD_PICTURE);

3357

int height = 16 << FRAME_MBAFF;

3358

int deblock_border = (16 + 4) << FRAME_MBAFF;

3359

int pic_height = 16*s->mb_height >> FIELD_PICTURE;

3360

3361

if (h->deblocking_filter) {

3362

if((top + height) >= pic_height)

3363

height += deblock_border;

3364

3365

top -= deblock_border;

3366

}

3367

3368

if (top >= pic_height || (top + height) < h->emu_edge_height)

3369

return;

3370

3371

height = FFMIN(height, pic_height - top);

3372

if (top < h->emu_edge_height) {

3373

height = top+height;

3374

top = 0;

3375

}

3376

3377

ff_draw_horiz_band(s, top, height);

3378

3379

if (s->dropable) return;

3380

3381

ff_thread_report_progress((AVFrame*)s->current_picture_ptr, top + height - 1,

3382

s->picture_structure==PICT_BOTTOM_FIELD);

3383

}

3384

3385

static int decode_slice(struct AVCodecContext *avctx, void *arg){

3386

H264Context *h = *(void**)arg;

3387

MpegEncContext * const s = &h->s;

3388

const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;

3389

int lf_x_start = s->mb_x;

3390

3391

s->mb_skip_run= -1;

3392

3393

h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||

3394

(CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY));

3395

3396

if( h->pps.cabac ) {

3397

/* realign */

3398

align_get_bits( &s->gb );

3399

3400

/* init cabac */

3401

ff_init_cabac_states( &h->cabac);

3402

ff_init_cabac_decoder( &h->cabac,

3403

s->gb.buffer + get_bits_count(&s->gb)/8,

3404

(get_bits_left(&s->gb) + 7)/8);

3405

3406

ff_h264_init_cabac_states(h);

3407

3408

for(;;){

3409

//START_TIMER

3410

int ret = ff_h264_decode_mb_cabac(h);

3411

int eos;

3412

//STOP_TIMER("decode_mb_cabac")

3413

3414

if(ret>=0) ff_h264_hl_decode_mb(h);

3415

3416

if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?

3417

s->mb_y++;

3418

3419

ret = ff_h264_decode_mb_cabac(h);

3420

3421

if(ret>=0) ff_h264_hl_decode_mb(h);

3422

s->mb_y--;

3423

}

3424

eos = get_cabac_terminate( &h->cabac );

3425

3426

if((s->workaround_bugs & FF_BUG_TRUNCATED) && h->cabac.bytestream > h->cabac.bytestream_end + 2){

3427

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

3428

if (s->mb_x >= lf_x_start) loop_filter(h, lf_x_start, s->mb_x + 1);

3429

return 0;

3430

}

3431

if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {

3432

av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%td)\n", s->mb_x, s->mb_y, h->cabac.bytestream_end - h->cabac.bytestream);

3433

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

3434

return -1;

3435

}

3436

3437

if( ++s->mb_x >= s->mb_width ) {

3438

loop_filter(h, lf_x_start, s->mb_x);

3439

s->mb_x = lf_x_start = 0;

3440

decode_finish_row(h);

3441

++s->mb_y;

3442

if(FIELD_OR_MBAFF_PICTURE) {

3443

++s->mb_y;

3444

if(FRAME_MBAFF && s->mb_y < s->mb_height)

3445

predict_field_decoding_flag(h);

3446

}

3447

}

3448

3449

if( eos || s->mb_y >= s->mb_height ) {

3450

tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);

3451

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

3452

if (s->mb_x > lf_x_start) loop_filter(h, lf_x_start, s->mb_x);

3453

return 0;

3454

}

3455

}

3456

3457

} else {

3458

for(;;){

3459

int ret = ff_h264_decode_mb_cavlc(h);

3460

3461

if(ret>=0) ff_h264_hl_decode_mb(h);

3462

3463

if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?

3464

s->mb_y++;

3465

ret = ff_h264_decode_mb_cavlc(h);

3466

3467

if(ret>=0) ff_h264_hl_decode_mb(h);

3468

s->mb_y--;

3469

}

3470

3471

if(ret<0){

3472

av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);

3473

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

3474

return -1;

3475

}

3476

3477

if(++s->mb_x >= s->mb_width){

3478

loop_filter(h, lf_x_start, s->mb_x);

3479

s->mb_x = lf_x_start = 0;

3480

decode_finish_row(h);

3481

++s->mb_y;

3482

if(FIELD_OR_MBAFF_PICTURE) {

3483

++s->mb_y;

3484

if(FRAME_MBAFF && s->mb_y < s->mb_height)

3485

predict_field_decoding_flag(h);

3486

}

3487

if(s->mb_y >= s->mb_height){

3488

tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);

3489

3490

if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {

3491

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

3492

3493

return 0;

3494

}else{

3495

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

3496

3497

return -1;

3498

}

3499

}

3500

}

3501

3502

if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){

3503

tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);

3504

if(get_bits_count(&s->gb) == s->gb.size_in_bits ){

3505

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

3506

if (s->mb_x > lf_x_start) loop_filter(h, lf_x_start, s->mb_x);

3507

3508

return 0;

3509

}else{

3510

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

3511

3512

return -1;

3513

}

3514

}

3515

}

3516

}

3517

3518

#if 0

3519

for(;s->mb_y < s->mb_height; s->mb_y++){

3520

for(;s->mb_x < s->mb_width; s->mb_x++){

3521

int ret= decode_mb(h);

3522

3523

ff_h264_hl_decode_mb(h);

3524

3525

if(ret<0){

3526

av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);

3527

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

3528

3529

return -1;

3530

}

3531

3532

if(++s->mb_x >= s->mb_width){

3533

s->mb_x=0;

3534

if(++s->mb_y >= s->mb_height){

3535

if(get_bits_count(s->gb) == s->gb.size_in_bits){

3536

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

3537

3538

return 0;

3539

}else{

3540

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

3541

3542

return -1;

3543

}

3544

}

3545

}

3546

3547

if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){

3548

if(get_bits_count(s->gb) == s->gb.size_in_bits){

3549

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

3550

3551

return 0;

3552

}else{

3553

ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

3554

3555

return -1;

3556

}

3557

}

3558

}

3559

s->mb_x=0;

3560

ff_draw_horiz_band(s, 16*s->mb_y, 16);

3561

}

3562

#endif

3563

return -1; //not reached

3564

}

3565

3566

/**

3567

* Call decode_slice() for each context.

3568

3569

* @param h h264 master context

3570

* @param context_count number of contexts to execute

3571

3572

static void execute_decode_slices(H264Context *h, int context_count){

3573

MpegEncContext * const s = &h->s;

3574

AVCodecContext * const avctx= s->avctx;

3575

H264Context *hx;

3576

int i;

3577

3578

if (s->avctx->hwaccel)

3579

return;

3580

if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)

3581

return;

3582

if(context_count == 1) {

3583

decode_slice(avctx, &h);

3584

} else {

3585

for(i = 1; i < context_count; i++) {

3586

hx = h->thread_context[i];

3587

hx->s.error_recognition = avctx->error_recognition;

3588

hx->s.error_count = 0;

3589

}

3590

3591

avctx->execute(avctx, (void *)decode_slice,

3592

h->thread_context, NULL, context_count, sizeof(void*));

3593

3594

/* pull back stuff from slices to master context */

3595

hx = h->thread_context[context_count - 1];

3596

s->mb_x = hx->s.mb_x;

3597

s->mb_y = hx->s.mb_y;

3598

s->dropable = hx->s.dropable;

3599

s->picture_structure = hx->s.picture_structure;

3600

for(i = 1; i < context_count; i++)

3601

h->s.error_count += h->thread_context[i]->s.error_count;

3602

}

3603

}

3604

3605

3606

static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){

3607

MpegEncContext * const s = &h->s;

3608

AVCodecContext * const avctx= s->avctx;

3609

H264Context *hx; ///< thread context

3610

int buf_index;

3611

int context_count;

3612

int next_avc;

3613

int pass = !(avctx->active_thread_type & FF_THREAD_FRAME);

3614

int nals_needed=0; ///< number of NALs that need decoding before the next frame thread starts

3615

int nal_index;

3616

3617

h->max_contexts = (HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_SLICE)) ? avctx->thread_count : 1;

3618

if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){

3619

h->current_slice = 0;

3620

if (!s->first_field)

3621

s->current_picture_ptr= NULL;

3622

ff_h264_reset_sei(h);

3623

}

3624

3625

for(;pass <= 1;pass++){

3626

buf_index = 0;

3627

context_count = 0;

3628

next_avc = h->is_avc ? 0 : buf_size;

3629

nal_index = 0;

3630

for(;;){

3631

int consumed;

3632

int dst_length;

3633

int bit_length;

3634

const uint8_t *ptr;

3635

int i, nalsize = 0;

3636

int err;

3637

3638

if(buf_index >= next_avc) {

3639

if(buf_index >= buf_size) break;

3640

nalsize = 0;

3641

for(i = 0; i < h->nal_length_size; i++)

3642

nalsize = (nalsize << 8) | buf[buf_index++];

3643

if(nalsize <= 0 || nalsize > buf_size - buf_index){

3644

av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);

3645

break;

3646

}

3647

next_avc= buf_index + nalsize;

3648

} else {

3649

// start code prefix search

3650

for(; buf_index + 3 < next_avc; buf_index++){

3651

// This should always succeed in the first iteration.

3652

if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)

3653

break;

3654

}

3655

3656

if(buf_index+3 >= buf_size) break;

3657

3658

buf_index+=3;

3659

if(buf_index >= next_avc) continue;

3660

}

3661

3662

hx = h->thread_context[context_count];

3663

3664

ptr= ff_h264_decode_nal(hx, buf + buf_index, &dst_length, &consumed, next_avc - buf_index);

3665

if (ptr==NULL || dst_length < 0){

3666

return -1;

3667

}

3668

i= buf_index + consumed;

3669

if((s->workaround_bugs & FF_BUG_AUTODETECT) && i+3<next_avc &&

3670

buf[i]==0x00 && buf[i+1]==0x00 && buf[i+2]==0x01 && buf[i+3]==0xE0)

3671

s->workaround_bugs |= FF_BUG_TRUNCATED;

3672

3673

if(!(s->workaround_bugs & FF_BUG_TRUNCATED)){

3674

while(ptr[dst_length - 1] == 0 && dst_length > 0)

3675

dst_length--;

3676

}

3677

bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1));

3678

3679

if(s->avctx->debug&FF_DEBUG_STARTCODE){

3680

av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", hx->nal_unit_type, buf_index, buf_size, dst_length);

3681

}

3682

3683

if (h->is_avc && (nalsize != consumed) && nalsize){

3684

av_log(h->s.avctx, AV_LOG_DEBUG, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);

3685

}

3686

3687

buf_index += consumed;

3688

nal_index++;

3689

3690

if(pass == 0) {

3691

// packets can sometimes contain multiple PPS/SPS

3692

// e.g. two PAFF field pictures in one packet, or a demuxer which splits NALs strangely

3693

// if so, when frame threading we can't start the next thread until we've read all of them

3694

switch (hx->nal_unit_type) {

3695

case NAL_SPS:

3696

case NAL_PPS:

3697

case NAL_IDR_SLICE:

3698

case NAL_SLICE:

3699

nals_needed = nal_index;

3700

}

3701

continue;

3702

}

3703

3704

//FIXME do not discard SEI id

3705

if(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)

3706

continue;

3707

3708

again:

3709

err = 0;

3710

switch(hx->nal_unit_type){

3711

case NAL_IDR_SLICE:

3712

if (h->nal_unit_type != NAL_IDR_SLICE) {

3713

av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mix of idr and non-idr slices");

3714

return -1;

3715

}

3716

idr(h); //FIXME ensure we don't loose some frames if there is reordering

3717

case NAL_SLICE:

3718

init_get_bits(&hx->s.gb, ptr, bit_length);

3719

hx->intra_gb_ptr=

3720

hx->inter_gb_ptr= &hx->s.gb;

3721

hx->s.data_partitioning = 0;

3722

3723

if((err = decode_slice_header(hx, h)))

3724

break;

3725

3726

s->current_picture_ptr->key_frame |=

3727

(hx->nal_unit_type == NAL_IDR_SLICE) ||

3728

(h->sei_recovery_frame_cnt >= 0);

3729

3730

if (h->current_slice == 1) {

3731

if(!(s->flags2 & CODEC_FLAG2_CHUNKS)) {

3732

decode_postinit(h, nal_index >= nals_needed);

3733

}

3734

3735

if (s->avctx->hwaccel && s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0)

3736

return -1;

3737

if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)

3738

ff_vdpau_h264_picture_start(s);

3739

}

3740

3741

if(hx->redundant_pic_count==0

3742

&& (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)

3743

&& (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type_nos!=AV_PICTURE_TYPE_B)

3744

&& (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==AV_PICTURE_TYPE_I)

3745

&& avctx->skip_frame < AVDISCARD_ALL){

3746

if(avctx->hwaccel) {

3747

if (avctx->hwaccel->decode_slice(avctx, &buf[buf_index - consumed], consumed) < 0)

3748

return -1;

3749

}else

3750

if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){

3751

static const uint8_t start_code[] = {0x00, 0x00, 0x01};

3752

ff_vdpau_add_data_chunk(s, start_code, sizeof(start_code));

3753

ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed], consumed );

3754

}else

3755

context_count++;

3756

}

3757

break;

3758

case NAL_DPA:

3759

init_get_bits(&hx->s.gb, ptr, bit_length);

3760

hx->intra_gb_ptr=

3761

hx->inter_gb_ptr= NULL;

3762

3763

if ((err = decode_slice_header(hx, h)) < 0)

3764

break;

3765

3766

hx->s.data_partitioning = 1;

3767

3768

break;

3769

case NAL_DPB:

3770

init_get_bits(&hx->intra_gb, ptr, bit_length);

3771

hx->intra_gb_ptr= &hx->intra_gb;

3772

break;

3773

case NAL_DPC:

3774

init_get_bits(&hx->inter_gb, ptr, bit_length);

3775

hx->inter_gb_ptr= &hx->inter_gb;

3776

3777

if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning

3778

&& s->context_initialized

3779

&& (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)

3780

&& (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type_nos!=AV_PICTURE_TYPE_B)

3781

&& (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==AV_PICTURE_TYPE_I)

3782

&& avctx->skip_frame < AVDISCARD_ALL)

3783

context_count++;

3784

break;

3785

case NAL_SEI:

3786

init_get_bits(&s->gb, ptr, bit_length);

3787

ff_h264_decode_sei(h);

3788

break;

3789

case NAL_SPS:

3790

init_get_bits(&s->gb, ptr, bit_length);

3791

ff_h264_decode_seq_parameter_set(h);

3792

3793

if (s->flags& CODEC_FLAG_LOW_DELAY ||

3794

(h->sps.bitstream_restriction_flag && !h->sps.num_reorder_frames))

3795

s->low_delay=1;

3796

3797

if(avctx->has_b_frames < 2)

3798

avctx->has_b_frames= !s->low_delay;

3799

3800

if (avctx->bits_per_raw_sample != h->sps.bit_depth_luma) {

3801

if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {

3802

avctx->bits_per_raw_sample = h->sps.bit_depth_luma;

3803

h->pixel_shift = h->sps.bit_depth_luma > 8;

3804

3805

ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma);

3806

ff_h264_pred_init(&h->hpc, s->codec_id, h->sps.bit_depth_luma);

3807

dsputil_init(&s->dsp, s->avctx);

3808

} else {

3809

av_log(avctx, AV_LOG_DEBUG, "Unsupported bit depth: %d\n", h->sps.bit_depth_luma);

3810

return -1;

3811

}

3812

}

3813

break;

3814

case NAL_PPS:

3815

init_get_bits(&s->gb, ptr, bit_length);

3816

3817

ff_h264_decode_picture_parameter_set(h, bit_length);

3818

3819

break;

3820

case NAL_AUD:

3821

case NAL_END_SEQUENCE:

3822

case NAL_END_STREAM:

3823

case NAL_FILLER_DATA:

3824

case NAL_SPS_EXT:

3825

case NAL_AUXILIARY_SLICE:

3826

break;

3827

default:

3828

av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", hx->nal_unit_type, bit_length);

3829

}

3830

3831

if(context_count == h->max_contexts) {

3832

execute_decode_slices(h, context_count);

3833

context_count = 0;

3834

}

3835

3836

if (err < 0)

3837

av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");

3838

else if(err == 1) {

3839

/* Slice could not be decoded in parallel mode, copy down

3840

* NAL unit stuff to context 0 and restart. Note that

3841

* rbsp_buffer is not transferred, but since we no longer

3842

* run in parallel mode this should not be an issue. */

3843

h->nal_unit_type = hx->nal_unit_type;

3844

h->nal_ref_idc = hx->nal_ref_idc;

3845

hx = h;

3846

goto again;

3847

}

3848

}

3849

}

3850

if(context_count)

3851

execute_decode_slices(h, context_count);

3852

return buf_index;

3853

}

3854

3855

/**

3856

* returns the number of bytes consumed for building the current frame

3857

3858

static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){

3859

if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)

3860

if(pos+10>buf_size) pos=buf_size; // oops ;)

3861

3862

return pos;

3863

}

3864

3865

static int decode_frame(AVCodecContext *avctx,

3866

void *data, int *data_size,

3867

AVPacket *avpkt)

3868

{

3869

const uint8_t *buf = avpkt->data;

3870

int buf_size = avpkt->size;

3871

H264Context *h = avctx->priv_data;

3872

MpegEncContext *s = &h->s;

3873

AVFrame *pict = data;

3874

int buf_index;

3875

3876

s->flags= avctx->flags;

3877

s->flags2= avctx->flags2;

3878

3879

/* end of stream, output what is still in the buffers */

3880

out:

3881

if (buf_size == 0) {

3882

Picture *out;

3883

int i, out_idx;

3884

3885

s->current_picture_ptr = NULL;

3886

3887

//FIXME factorize this with the output code below

3888

out = h->delayed_pic[0];

3889

out_idx = 0;

3890

for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)

3891

if(h->delayed_pic[i]->poc < out->poc){

3892

out = h->delayed_pic[i];

3893

out_idx = i;

3894

}

3895

3896

for(i=out_idx; h->delayed_pic[i]; i++)

3897

h->delayed_pic[i] = h->delayed_pic[i+1];

3898

3899

if(out){

3900

*data_size = sizeof(AVFrame);

3901

*pict= *(AVFrame*)out;

3902

}

3903

3904

return 0;

3905

}

3906

3907

buf_index=decode_nal_units(h, buf, buf_size);

3908

if(buf_index < 0)

3909

return -1;

3910

3911

if (!s->current_picture_ptr && h->nal_unit_type == NAL_END_SEQUENCE) {

3912

buf_size = 0;

3913

goto out;

3914

}

3915

3916

if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){

3917

if (avctx->skip_frame >= AVDISCARD_NONREF)

3918

return 0;

3919

av_log(avctx, AV_LOG_ERROR, "no frame!\n");

3920

return -1;

3921

}

3922

3923

if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){

3924

3925

if(s->flags2 & CODEC_FLAG2_CHUNKS) decode_postinit(h, 1);

3926

3927

field_end(h, 0);

3928

3929

if (!h->next_output_pic) {

3930

/* Wait for second field. */

3931

*data_size = 0;

3932

3933

} else {

3934

*data_size = sizeof(AVFrame);

3935

*pict = *(AVFrame*)h->next_output_pic;

3936

}

3937

}

3938

3939

assert(pict->data[0] || !*data_size);

3940

ff_print_debug_info(s, pict);

3941

//printf("out %d\n", (int)pict->data[0]);

3942

3943

return get_consumed_bytes(s, buf_index, buf_size);

3944

}

3945

#if 0

3946

static inline void fill_mb_avail(H264Context *h){

3947

MpegEncContext * const s = &h->s;

3948

const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;

3949

3950

if(s->mb_y){

3951

h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;

3952

h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num;

3953

h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;

3954

}else{

3955

h->mb_avail[0]=

3956

h->mb_avail[1]=

3957

h->mb_avail[2]= 0;

3958

}

3959

h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;

3960

h->mb_avail[4]= 1; //FIXME move out

3961

h->mb_avail[5]= 0; //FIXME move out

3962

}

3963

#endif

3964

3965

#ifdef TEST

3966

#undef printf

3967

#undef random

3968

#define COUNT 8000

3969

#define SIZE (COUNT*40)

3970

int main(void){

3971

int i;

3972

uint8_t temp[SIZE];

3973

PutBitContext pb;

3974

GetBitContext gb;

3975

// int int_temp[10000];

3976

DSPContext dsp;

3977

AVCodecContext avctx;

3978

3979

dsputil_init(&dsp, &avctx);

3980

3981

init_put_bits(&pb, temp, SIZE);

3982

printf("testing unsigned exp golomb\n");

3983

for(i=0; i<COUNT; i++){

3984

START_TIMER

3985

set_ue_golomb(&pb, i);

3986

STOP_TIMER("set_ue_golomb");

3987

}

3988

flush_put_bits(&pb);

3989

3990

init_get_bits(&gb, temp, 8*SIZE);

3991

for(i=0; i<COUNT; i++){

3992

int j, s;

3993

3994

s= show_bits(&gb, 24);

3995

3996

START_TIMER

3997

j= get_ue_golomb(&gb);

3998

if(j != i){

3999

printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);

4000

// return -1;

4001

}

4002

STOP_TIMER("get_ue_golomb");

4003

}

4004

4005

4006

init_put_bits(&pb, temp, SIZE);

4007

printf("testing signed exp golomb\n");

4008

for(i=0; i<COUNT; i++){

4009

START_TIMER

4010

set_se_golomb(&pb, i - COUNT/2);

4011

STOP_TIMER("set_se_golomb");

4012

}

4013

flush_put_bits(&pb);

4014

4015

init_get_bits(&gb, temp, 8*SIZE);

4016

for(i=0; i<COUNT; i++){

4017

int j, s;

4018

4019

s= show_bits(&gb, 24);

4020

4021

START_TIMER

4022

j= get_se_golomb(&gb);

4023

if(j != i - COUNT/2){

4024

printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);

4025

// return -1;

4026

}

4027

STOP_TIMER("get_se_golomb");

4028

}

4029

4030

#if 0

4031

printf("testing 4x4 (I)DCT\n");

4032

4033

DCTELEM block[16];

4034

uint8_t src[16], ref[16];

4035

uint64_t error= 0, max_error=0;

4036

4037

for(i=0; i<COUNT; i++){

4038

int j;

4039

// printf("%d %d %d\n", r1, r2, (r2-r1)*16);

4040

for(j=0; j<16; j++){

4041

ref[j]= random()%255;

4042

src[j]= random()%255;

4043

}

4044

4045

h264_diff_dct_c(block, src, ref, 4);

4046

4047

//normalize

4048

for(j=0; j<16; j++){

4049

// printf("%d ", block[j]);

4050

block[j]= block[j]*4;

4051

if(j&1) block[j]= (block[j]*4 + 2)/5;

4052

if(j&4) block[j]= (block[j]*4 + 2)/5;

4053

}

4054

// printf("\n");

4055

4056

h->h264dsp.h264_idct_add(ref, block, 4);

4057

/* for(j=0; j<16; j++){

4058

printf("%d ", ref[j]);

4059

}

4060

printf("\n");*/

4061

4062

for(j=0; j<16; j++){

4063

int diff= FFABS(src[j] - ref[j]);

4064

4065

error+= diff*diff;

4066

max_error= FFMAX(max_error, diff);

4067

}

4068

}

4069

printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );

4070

printf("testing quantizer\n");

4071

for(qp=0; qp<52; qp++){

4072

for(i=0; i<16; i++)

4073

src1_block[i]= src2_block[i]= random()%255;

4074

4075

}

4076

printf("Testing NAL layer\n");

4077

4078

uint8_t bitstream[COUNT];

4079

uint8_t nal[COUNT*2];

4080

H264Context h;

4081

memset(&h, 0, sizeof(H264Context));

4082

4083

for(i=0; i<COUNT; i++){

4084

int zeros= i;

4085

int nal_length;

4086

int consumed;

4087

int out_length;

4088

uint8_t *out;

4089

int j;

4090

4091

for(j=0; j<COUNT; j++){

4092

bitstream[j]= (random() % 255) + 1;

4093

}

4094

4095

for(j=0; j<zeros; j++){

4096

int pos= random() % COUNT;

4097

while(bitstream[pos] == 0){

4098

pos++;

4099

pos %= COUNT;

4100

}

4101

bitstream[pos]=0;

4102

}

4103

4104

START_TIMER

4105

4106

nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);

4107

if(nal_length<0){

4108

printf("encoding failed\n");

4109

return -1;

4110

}

4111

4112

out= ff_h264_decode_nal(&h, nal, &out_length, &consumed, nal_length);

4113

4114

STOP_TIMER("NAL")

4115

4116

if(out_length != COUNT){

4117

printf("incorrect length %d %d\n", out_length, COUNT);

4118

return -1;

4119

}

4120

4121

if(consumed != nal_length){

4122

printf("incorrect consumed length %d %d\n", nal_length, consumed);

4123

return -1;

4124

}

4125

4126

if(memcmp(bitstream, out, COUNT)){

4127

printf("mismatch\n");

4128

return -1;

4129

}

4130

}

4131

#endif

4132

4133

printf("Testing RBSP\n");

4134

4135

4136

return 0;

4137

}

4138

#endif /* TEST */

4139

4140

4141

av_cold void ff_h264_free_context(H264Context *h)

4142

{

4143

int i;

4144

4145

free_tables(h, 1); //FIXME cleanup init stuff perhaps

4146

4147

for(i = 0; i < MAX_SPS_COUNT; i++)

4148

av_freep(h->sps_buffers + i);

4149

4150

for(i = 0; i < MAX_PPS_COUNT; i++)

4151

av_freep(h->pps_buffers + i);

4152

}

4153

4154

av_cold int ff_h264_decode_end(AVCodecContext *avctx)

4155

{

4156

H264Context *h = avctx->priv_data;

4157

MpegEncContext *s = &h->s;

4158

4159

ff_h264_free_context(h);

4160

4161

MPV_common_end(s);

4162

4163

// memset(h, 0, sizeof(H264Context));

4164

4165

return 0;

4166

}

4167

4168

static const AVProfile profiles[] = {

4169

{ FF_PROFILE_H264_BASELINE, "Baseline" },

4170

{ FF_PROFILE_H264_CONSTRAINED_BASELINE, "Constrained Baseline" },

4171

{ FF_PROFILE_H264_MAIN, "Main" },

4172

{ FF_PROFILE_H264_EXTENDED, "Extended" },

4173

{ FF_PROFILE_H264_HIGH, "High" },

4174

{ FF_PROFILE_H264_HIGH_10, "High 10" },

4175

{ FF_PROFILE_H264_HIGH_10_INTRA, "High 10 Intra" },

4176

{ FF_PROFILE_H264_HIGH_422, "High 4:2:2" },

4177

{ FF_PROFILE_H264_HIGH_422_INTRA, "High 4:2:2 Intra" },

4178

{ FF_PROFILE_H264_HIGH_444, "High 4:4:4" },

4179

{ FF_PROFILE_H264_HIGH_444_PREDICTIVE, "High 4:4:4 Predictive" },

4180

{ FF_PROFILE_H264_HIGH_444_INTRA, "High 4:4:4 Intra" },

4181

{ FF_PROFILE_H264_CAVLC_444, "CAVLC 4:4:4" },

4182

{ FF_PROFILE_UNKNOWN },

4183

};

4184

4185

AVCodec ff_h264_decoder = {

4186

"h264",

4187

AVMEDIA_TYPE_VIDEO,

4188

CODEC_ID_H264,

4189

sizeof(H264Context),

4190

ff_h264_decode_init,

4191

NULL,

4192

ff_h264_decode_end,

4193

decode_frame,

4194

/*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |

4195

CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,

4196

.flush= flush_dpb,

4197

.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),

4198

.init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),

4199

.update_thread_context = ONLY_IF_THREADS_ENABLED(decode_update_thread_context),

4200

.profiles = NULL_IF_CONFIG_SMALL(profiles),

4201

};

4202

4203

#if CONFIG_H264_VDPAU_DECODER

4204

AVCodec ff_h264_vdpau_decoder = {

4205

"h264_vdpau",

4206

AVMEDIA_TYPE_VIDEO,

4207

CODEC_ID_H264,

4208

sizeof(H264Context),

4209

ff_h264_decode_init,

4210

NULL,

4211

ff_h264_decode_end,

4212

decode_frame,

4213

CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,

4214

.flush= flush_dpb,

4215

.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),

4216

.pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_H264, PIX_FMT_NONE},

4217

.profiles = NULL_IF_CONFIG_SMALL(profiles),

4218

};

4219

#endif

Older »