[第4波]幽魂系列汉化的有关资料

shane007

7 ]! t# V  D0 g最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
也许将来可以用于汉化。

2 j+ Z7 r- l( z6 @! R) D) m2 j/ Q和日文版有关的信息
2 ~& Z. P1 X: T" `, qhttp://anthonylarme.tripod.com/phantas/phintgtp.html

相关工具
! P3 R6 p# G; X! u& }/ f8 O+ thttp://anthonylarme.tripod.com/phantas/phcheats.html
1 k" h+ I+ Y9 o; J  ~3 Q-----------------------------------------------------------------------
2012/1/2  更新
- I$ p9 _1 J$ k% ?8 I& C关于幽魂游戏的字幕
1 B* l" Z, X# B( Z/ w& aPhantasmagoria subtitles function discovered - ScummVM :: Forums
+ g- d- s3 F9 }; B. {; k3 c
0 X( P7 l+ L; p# u' I4 j: oVMD文件
Subtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki

: G# A, s; t/ l字幕
( m5 f' ^+ P! V- h3 @9 {Subtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)

FFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub

1. /*
   
2. * subtitle-rbt.c
   
3. *  by Mike Melanson (mike -at- multimedia.cx)
   + c2 `4 U' s( _7 s  B- ?
4. *
   : z/ [* y% I1 g* u: K
5. * build with this command:
   
6. *   gcc -g -Wall subtitle-rbt.c -o subtitle-rbt -lm -lass
   , D9 S$ ?6 T) \* @; p' `  a
7. */
   * B9 ]& e: s7 _
8. 
   
9. #include <inttypes.h>
   
10. #include <math.h>
    2 _$ {. a0 S! k* F# s" [
11. #include <stdio.h>
    
12. #include <stdlib.h>
    
13. #include <string.h>
    ! B7 c1 @& y9 {8 p
14. 
    
15. #include <ass/ass.h>
    
16. 
    
17. #define LE_16(x) ((((uint8_t*)(x))[1] <<  8) | ((uint8_t*)(x))[0])
    
18. 
    7 A% K8 |1 \# z) G
19. #define LE_32(x) (((uint32_t)(((uint8_t*)(x))[3]) << 24) |  \
    
20.                              (((uint8_t*)(x))[2]  << 16) |  \
    1 N& x$ O3 z% s# t% ~6 A
21.                              (((uint8_t*)(x))[1]  <<  8) |  \
    
22.                               ((uint8_t*)(x))[0])
    4 I3 g1 h" H2 j  I5 q; Z; w
23. 
    9 O# `2 i6 g! \4 D/ r& u
24. /*********************************************************************/
    5 w& o2 I- ?7 h* k  r% j  ^
25. 
    . ^- A# ~/ v/ ]
26. /* Bit reader stuff */
    
27. 
    ) U, Z' L2 a- e6 a3 W; j
28. typedef struct
    / b6 S1 [/ y$ i9 j) q
29. {
    
30.     uint8_t *bytestream;
    4 M) |6 g5 j. t' n6 Q7 k
31.     int bytestream_size;
    
32.     int index;
    
33.     uint32_t bits;
    - W( G4 r5 R8 t* I
34.     int bits_in_buffer;
    
35. } get_bits_context;
    
36. 
    5 E0 F6 O) m/ V* Z6 R
37. static inline void reload_bits(get_bits_context *gb)
    * ^3 d  W( W, x! r
38. {
    
39.     while (gb->bits_in_buffer <= 24)
    
40.     {
    
41.         if (gb->index < gb->bytestream_size)
    ) ?, g. }$ A$ U% n! @% r
42.             gb->bits |= (gb->bytestream[gb->index++] << (24 - gb->bits_in_buffer));
    
43.         gb->bits_in_buffer += 8;
    , S9 V7 K+ k# O5 \4 R" a" }
44.     }
    
45. }
    
46. 
    
47. static void init_get_bits(get_bits_context *gb, uint8_t *bytestream, int size)
    5 k) l% E) y/ ]- m6 i9 n
48. {
    
49.     gb->bytestream = malloc(size);
    ) p$ B/ R/ r3 @" ]6 e/ }
50.     memcpy(gb->bytestream, bytestream, size);
      r6 b9 N: B# x; [+ q" }' X
51.     gb->bytestream_size = size;
    
52.     gb->index = 0;
    
53.     gb->bits = 0;
    
54.     gb->bits_in_buffer = 0;
    " e' T5 C1 B8 J! }0 R4 |
55. 
    ( |0 P9 \6 L6 F% `/ H
56.     reload_bits(gb);
    . b2 n7 M- F6 j) v% n
57. }
    ( X; P: S8 Y5 a  E2 v' y9 F
58. 
    5 ^$ g9 s) m; b$ ?3 |$ _1 G1 n
59. /* read bits without consuming them from the stream */
    " Q8 P6 W' g$ Q  z* Y3 \
60. static int view_bits(get_bits_context *gb, int count)
    
61. {
    ' I. q9 p. X7 b6 E: ?
62.     if (count >= 24)
    
63.         return -1;
    
64.     if (gb->bits_in_buffer < count)
    
65.         reload_bits(gb);
    
66.     return (gb->bits >> (32 - count));
    
67. }
    
68. 
    / I8 i$ m! [9 h9 m0 g
69. /* read and consume bits from the stream */
    : a& @4 ?% e/ Y! l( G. v8 ?
70. static int read_bits(get_bits_context *gb, int count)
    5 y! @3 B/ o# }: s, X, @% G
71. {
    
72.     int value;
    ; X( n% e4 C) a5 h2 n
73. 
    ' j$ \# }0 l; A, I
74.     if (count >= 24)
    
75.         return -1;
    
76. 
    
77.     value = view_bits(gb, count);
    
78.     gb->bits <<= count;
    ' V6 H4 s1 R7 `1 E7 R8 j4 W2 u1 k
79.     gb->bits_in_buffer -= count;
    
80. 
    
81.     return value;
    9 o- v+ Q) X3 S# I8 e' X; \
82. }
    5 G& M9 z+ Q" j& E; V, `* Q3 z
83. 
    7 l6 S1 j( l: c
84. static void delete_get_bits(get_bits_context *gb)
    
85. {
    + q6 e  v6 g% q0 T' p9 J' ?
86.     free(gb->bytestream);
    6 [% J' q) ]3 W5 f6 \
87. }
    
88. 
    
89. /*********************************************************************/
    
90. 
    
91. /* Bit writer stuff */
    
92. 
    
93. #define MAX_PUT_BITS_BYTES 63000
    & c, s! R. p6 s5 h* ^
94. typedef struct
    ; w/ r. _" W* a8 q5 _
95. {
    # a" P- y+ {" `- N
96.     uint8_t bytes[MAX_PUT_BITS_BYTES];
    # R) X" Q% _2 L
97.     int byte_index;
    - q3 p0 O. p2 a  N
98.     uint32_t bit_buffer;
    
99.     int bits_buffered;
    
100. } put_bits_context;
     
101. 
     
102. static void reset_put_bits(put_bits_context *pb)
     
103. {
     
104.     memset(pb->bytes, 0, MAX_PUT_BITS_BYTES);
     
105.     pb->byte_index = 0;
     + `( w0 o$ f  ?* F1 E
106.     pb->bit_buffer = 0;
     
107.     pb->bits_buffered = 0;
     0 j2 g$ k3 n4 _& `
108. }
     . d' {+ Y' j$ f6 J4 k% v% m
109. 
     
110. static put_bits_context *init_put_bits()
     
111. {
     ( |$ t9 A) c# O5 {" V; y
112.     put_bits_context *pb;
     
113. 
     
114.     pb = malloc(sizeof(put_bits_context));
     
115.     reset_put_bits(pb);
     8 @! T' J6 v" G" o8 w/ E! I1 m
116. 
     , N8 S9 [4 S: J
117.     return pb;
     / |% Y9 o: I! Y2 z% w5 C
118. }
     % ~( h) ~& d# E* q
119. 
     % h, Z2 |7 {0 Q' L$ V4 _8 w
120. static void put_bits(put_bits_context *pb, int bits, int count)
     
121. {
     
122.     pb->bit_buffer <<= count;
     
123.     pb->bit_buffer |= (bits & (~(0xFFFFFFFF << count)));
     3 f  ]9 G: y2 i5 n5 Q- m
124.     pb->bits_buffered += count;
     
125. 
     
126.     while (pb->bits_buffered >= 8)
     $ _, j6 T/ d6 O& Z1 r, u! x
127.     {
     # W+ m' p* |# q4 d3 u
128.         pb->bytes[pb->byte_index++] = pb->bit_buffer >> (pb->bits_buffered - 8);
     7 T# [4 z" ~8 M/ ?. G% X; Q
129.         pb->bit_buffer &= (~(0xFFFFFFFF << (pb->bits_buffered - 8)));
       R: q1 B: u0 A1 e* b% Z/ `
130.         pb->bits_buffered -= 8;
     
131.     }
     . {3 o# _( c9 ~& `  o
132. 
     
133.     if (pb->byte_index >= MAX_PUT_BITS_BYTES)
       Z& \5 W2 w" d1 t7 w* q
134.     {
     
135.         printf("HELP! Bit overflow\n");
     ) Q! w2 u8 j# m7 d& J2 i7 f( f* I) \
136.         exit(1);
     
137.     }
     
138. }
     
139. 
     
140. static void put_bits_flush(put_bits_context *pb)
     
141. {
     
142.     if (pb->bits_buffered > 0)
     3 F6 R2 ^" @5 h
143.         pb->bytes[pb->byte_index++] = pb->bit_buffer << (8 - pb->bits_buffered);
     
144. }
     
145. 
     " W0 g! D4 x3 w  e
146. static void delete_put_bits(put_bits_context *pb)
       G3 ?1 y& T: n5 Q. b' F5 R; v
147. {
     
148.     free(pb->bytes);
     
149. }
     
150. 
     
151. /*********************************************************************/
     
152. 
     7 A* o' Y" o' `/ J3 _% S& m
153. /* RBT functions */
     & c) A6 L; s0 [& b7 P  [2 y
154. 
     
155. #define PALETTE_COUNT 256
     4 W6 k- {0 e# c, |) J+ o4 R  w
156. #define RBT_HEADER_SIZE 60
     8 z( x1 o5 K7 a
157. #define UNKNOWN_TABLE_SIZE (1024+512)
     
158. #define SUBTITLE_THRESHOLD 0x70
     
159. #define MILLISECONDS_PER_FRAME 100
     
160. 
     
161. /* VLC table */
     
162. #define VLC_SIZE 4
     
163. static struct
     
164. {
     
165.     int count;
     
166.     int value;
       J* I5 _7 i3 |0 z# W9 D
167. } lzs_vlc_table[] =
     ) v! g$ R, |6 v$ Z6 W8 \1 W/ D8 Q
168. {
     * t6 {5 ]7 A8 N3 ~8 ^. L# r
169.     /* code length = 2 bits; value = 2 */
     
170.     /* 0000 */ { 2, 2 },
     " d1 d! X9 }+ L3 P. e5 M2 ]
171.     /* 0001 */ { 2, 2 },
     
172.     /* 0010 */ { 2, 2 },
     
173.     /* 0011 */ { 2, 2 },
     
174. 
     
175.     /* code length = 2 bits; value = 3 */
     2 k: s: b& b4 W% k" \
176.     /* 0100 */ { 2, 3 },
     3 t. B# r4 J: M+ u$ o: P
177.     /* 0101 */ { 2, 3 },
     ( i3 o/ G3 |+ i  c% Z; |
178.     /* 0110 */ { 2, 3 },
     
179.     /* 0111 */ { 2, 3 },
     % M! I; w5 r* ^5 ~' Q" w
180. 
     ) b/ J8 I- M$ |# L- H0 F7 S4 _
181.     /* code length = 2 bits; value = 4 */
     3 Y) q) w% g8 O" g5 k9 \4 F
182.     /* 1000 */ { 2, 4 },
     8 ^) S* p) [4 Z1 y
183.     /* 1001 */ { 2, 4 },
     ; w' t# l/ L$ R4 K8 C2 [* u( C
184.     /* 1010 */ { 2, 4 },
     ) _4 b; {  e0 q/ F; y, C
185.     /* 1011 */ { 2, 4 },
     
186. 
     % ^. x. s- w% y/ Z0 ^
187.     /* code length = 4 bits; value = 5 */
     / m9 d, {: L- i2 I1 ?) r, P! |" L
188.     /* 1100 */ { 4, 5 },
     . O  L$ d, n" [/ _- \( y
189. 
     6 m; ?! Z# H" d. _( n
190.     /* code length = 4 bits; value = 6 */
     
191.     /* 1101 */ { 4, 6 },
     
192. 
     
193.     /* code length = 4 bits; value = 7 */
     
194.     /* 1110 */ { 4, 7 },
     
195. 
     ! r! q& r6 O% D/ H0 L$ k
196.     /* special case */
     
197.     /* 1111 */ { 4, 8 }
     . c& I8 b. W. c; w: s
198. };
     
199. 
     
200. typedef struct
     
201. {
     $ P- k; K, y. ^: }1 ^* a; _
202.     int version;
     " _- g- Y4 |% ~! H! Z" b4 k/ P$ n
203.     int width;
     % m8 W+ Q. i3 S8 T( U
204.     int height;
     + Q, N! a4 \0 H
205.     int frame_count;
     1 Y) {' _: D! \5 w0 w+ U, e
206.     int audio_chunk_size;
     # v# z! X" {( i6 j. M' [
207.     uint8_t palette[PALETTE_COUNT * 3];
     
208.     off_t video_frame_size_table_offset;
     
209.     uint8_t *video_frame_size_table;
     
210.     off_t frame_size_table_offset;
     
211.     uint8_t *frame_size_table;
     6 w2 y1 `. z# K; \  n' C
212.     uint8_t *frame_load_buffer;
     ) u; k: C4 P& p* H
213.     int dump_frames;
     
214. 
     
215.     /* subtitle library */
     
216.     ASS_Library *ass_lib;
     
217.     ASS_Renderer *ass_renderer;
     ' d! U2 T/ f; X- Q* v; n0 c! `
218.     ASS_Track *ass_track;
     
219. } rbt_dec_context;
     - i) ]: Z7 I# p
220. 
     : G! u: T9 V: k& k
221. static void dump_pnm_file(char *filename, rbt_dec_context *rbt,
     
222.     uint8_t *image, int width, int height)
     
223. {
     
224.     FILE *outfile;
     5 U' H: b( ]) ]- e
225.     uint8_t bytes[3];
     " d5 S  G' ]) U
226.     int p;
     0 ~2 Q( X' S0 L; B  ^
227.     uint8_t pixel;
     # R  F" o, T1 L4 p; |- m6 V
228. 
     $ t* ?3 e/ z% P) i) X
229.     outfile = fopen(filename, "wb");
     
230.     fprintf(outfile, "P6\n%d %d\n255\n", width, height);
     8 l- k, \1 M* k0 R5 {6 V$ C
231.     for (p = 0; p < width * height; p++)
     * s, D# f2 ~% V/ E  F+ W7 ]" o$ i
232.     {
     - J  q5 w& |% _6 ~% {  `
233.         pixel = image[p];
     
234.         bytes[0] = rbt->palette[pixel*3+0];
     7 W  d4 X& x% ?' C4 X4 ?5 s
235.         bytes[1] = rbt->palette[pixel*3+1];
     3 P# {7 J7 f, r/ [, S
236.         bytes[2] = rbt->palette[pixel*3+2];
     $ Y; r5 \( D+ g7 H% _
237.         fwrite(bytes, 3, 1, outfile);
     
238.     }
     
239.     fclose(outfile);
     
240. }
     8 z7 v; c$ Y5 }) P
241. 
     
242. static int load_and_copy_rbt_header(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file)
     2 y' `" T5 c8 n% a* U
243. {
     
244.     uint8_t header[RBT_HEADER_SIZE];
     
245.     int palette_data_size;
     
246.     uint8_t *palette_chunk;
     , Y: H2 X$ o" P3 r9 T2 ?  i/ x+ g
247.     int unknown_chunk_size;
     
248.     uint8_t *unknown_chunk;
     
249.     uint8_t unknown_table[UNKNOWN_TABLE_SIZE];
     
250.     off_t padding_size;
     
251.     uint8_t *padding;
     
252.     int i;
     1 G- e! ~- ~* d% ~1 E" G& e0 U
253.     int frame_size;
     $ S% r9 T' P" i. T/ {( y) w2 a" t
254.     int max_frame_size;
     5 C0 x; }" m5 M2 w
255.     int first_palette_index;
     9 k! |' e! H% t# q: m
256.     int palette_count;
     
257.     int palette_type;
     , G& O* c  N3 `5 V% G
258.     int palette_index;
     ! C! R5 M+ b1 O! i2 r4 |- a% @
259. 
     & I# Y7 E# d& E, a( o
260.     fseek(inrbt_file, 0, SEEK_SET);
     
261.     fseek(outrbt_file, 0, SEEK_SET);
     
262. 
     * g& y9 k4 m0 B+ {' G( O
263.     /* load the header */
     
264.     if (fread(header, RBT_HEADER_SIZE, 1, inrbt_file) != 1)
     4 [) W: ]# K: j3 z4 H
265.     {
     # l0 ^  ^3 t9 d* q
266.         printf("problem reading initial RBT header\n");
     3 r) n( J1 m6 o$ S* R" n$ u
267.         return 0;
     
268.     }
     
269. 
     
270.     /* copy header to the output */
     
271.     if (fwrite(header, RBT_HEADER_SIZE, 1, outrbt_file) != 1)
     # X$ H" I& m6 G9 F
272.     {
     
273.         printf("problem writing initial RBT header\n");
     
274.         return 0;
     
275.     }
     
276. 
     / U, G& `4 J7 T5 u( \6 v
277.     rbt->version = LE_16(&header[6]);
     
278.     rbt->audio_chunk_size = LE_16(&header[8]);
     
279.     rbt->frame_count = LE_16(&header[14]);
     1 _* v! E1 e. E6 T
280. 
     ; k  b2 i+ V0 i  x; D
281.     /* transfer the unknown data, if it's there */
     1 \+ Q9 c2 l! ^2 d
282.     unknown_chunk_size = LE_16(&header[18]);
     2 N9 i7 f2 Z1 z2 K/ M
283.     if (unknown_chunk_size > 0)
     
284.     {
     
285.         unknown_chunk = malloc(unknown_chunk_size);
     2 u) m1 O. x$ v* C; C& s
286.         if (fread(unknown_chunk, unknown_chunk_size, 1, inrbt_file) != 1)
     
287.         {
     # r) F7 P! |: X* C- r! P/ ^2 `( A
288.             printf("problem reading unknown data\n");
     
289.             return 0;
     % C4 }. R# Y, Y
290.         }
     
291.         if (fwrite(unknown_chunk, unknown_chunk_size, 1, outrbt_file) != 1)
     
292.         {
     
293.             printf("problem writing unknown data\n");
     . e' I6 P, C) t. W
294.             return 0;
     
295.         }
     
296.         free(unknown_chunk);
     
297.     }
     
298. 
     
299.     /* transfer the palette chunk */
     
300.     palette_data_size = LE_16(&header[16]);
     9 J/ Q; t' ~! u$ @; W4 E! k
301.     palette_chunk = malloc(palette_data_size);
     # A. [+ U4 a" K1 k4 i- [( I
302.     if (fread(palette_chunk, palette_data_size, 1, inrbt_file) != 1)
     & K+ A. G$ Q. v, y# y
303.     {
     & y5 a1 E2 i) `
304.         printf("problem reading palette\n");
     
305.         return 0;
     ' ~; T  l5 N' ~1 v
306.     }
     2 j, J- k- J' B) p) @1 a
307.     if (fwrite(palette_chunk, palette_data_size, 1, outrbt_file) != 1)
     
308.     {
     * V) }* @. n. h: h# [7 O
309.         printf("problem writing palette\n");
     
310.         return 0;
     
311.     }
     ( _$ U1 X+ L' [3 m# Y" ^" W
312.     /* load the palette into the internal context */
     ! f2 ?6 ?; [  O9 \  T
313.     memset(rbt->palette, 0, PALETTE_COUNT * 3);
     
314.     first_palette_index = palette_chunk[25];
     # r7 X5 d7 m2 u3 O' [0 y0 x% }
315.     palette_count = LE_16(&palette_chunk[29]);
     
316.     palette_type = palette_chunk[32];
     
317.     palette_index = (palette_type == 0) ? 38 : 37;
     
318.     for (i = first_palette_index; i < first_palette_index + palette_count; i++)
     ( b; R/ b) u8 i+ w4 N7 Z. m
319.     {
     8 h. x5 e7 i5 p
320.         rbt->palette[i*3+0] = palette_chunk[palette_index++];
     
321.         rbt->palette[i*3+1] = palette_chunk[palette_index++];
     
322.         rbt->palette[i*3+2] = palette_chunk[palette_index++];
     
323.     }
     
324.     free(palette_chunk);
     7 j; d' c" n9 @3 h6 i& G; y
325. 
     
326.     /* copy the video frame size table (2 bytes per frame), as a placeholder */
     
327.     rbt->video_frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     ! b' }# m$ L4 N2 K; `% Y1 d! H
328.     if (fread(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     ( o2 D2 {8 E, Z5 G  Q- Z
329.     {
     4 n! \" Y1 R/ [3 O* _3 C
330.         printf("problem reading frame table\n");
     # T: z  k/ R0 n) \8 i6 Y
331.         return 0;
     % w4 `: A+ t/ u/ Q! b/ x! n8 a
332.     }
     
333.     rbt->video_frame_size_table_offset = ftell(outrbt_file);
     
334.     if (fwrite(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     
335.     {
     , [1 [* T+ p4 L! m+ U7 j
336.         printf("problem writing frame table\n");
     9 B- E' b, N) g8 h( j; Y
337.         return 0;
     3 W7 d6 p1 |1 W- B8 {; v
338.     }
     + e4 S8 b) q8 Q5 [0 ^: i& O
339. 
     
340.     /* copy the frame size table (2 bytes per frame), as a placeholder */
     ) g3 \" a+ c( s& a
341.     rbt->frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     ( J/ M! `1 y" b. P/ k/ _% T
342.     if (fread(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     
343.     {
     
344.         printf("problem reading frame table\n");
     * o5 j4 d# ?5 U0 M
345.         return 0;
     9 C  D4 s- W9 M/ N1 e7 p
346.     }
     0 r0 b. E3 Y. X9 i% D8 B# O6 h
347.     rbt->frame_size_table_offset = ftell(outrbt_file);
     
348.     if (fwrite(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     & o2 G6 ^( U- Z( N9 y
349.     {
     9 [# M. ]3 R. r# z4 ^+ t/ ]
350.         printf("problem writing frame table\n");
     / C1 d$ Y7 u/ ?
351.         return 0;
     
352.     }
     
353. 
     1 r8 [5 ]: e- {" n
354.     /* find the max frame size */
     . }0 f4 i0 ~' R. _
355.     max_frame_size = 0;
     
356.     for (i = 0; i < rbt->frame_count; i++)
     / a6 |8 U8 j4 y1 E0 l- m
357.     {
     . F3 m8 U1 |; W0 r  s
358.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     
359.         if (frame_size > max_frame_size)
     
360.             max_frame_size = frame_size;
     " j( C' |& U/ s- k$ n4 D- L( w
361.     }
     
362.     rbt->frame_load_buffer = malloc(max_frame_size);
     4 g1 C$ N$ x  T; `7 z
363. 
     ( h  p; S  M( M- C# I
364.     /* transfer the unknown table(s) */
       T% w/ ?# ?0 T) r0 [& {
365.     if (fread(unknown_table, UNKNOWN_TABLE_SIZE, 1, inrbt_file) != 1)
     9 H; G- Q' r: u! G& o- b5 G& v% O
366.     {
     
367.         printf("problem reading unknown table\n");
     
368.         return 0;
     , T, i% m( z) n* j& D
369.     }
     
370.     if (fwrite(unknown_table, UNKNOWN_TABLE_SIZE, 1, outrbt_file) != 1)
     6 ^8 ]/ M( j# }* r. e: R
371.     {
     
372.         printf("problem writing unknown table\n");
     
373.         return 0;
     2 s5 Y1 M3 p# I# h6 f
374.     }
     & z) l, _& E% T2 K' A. @
375. 
     + r7 D$ Y/ Y9 M
376.     /* copy over padding */
     ; ~2 e) q$ R8 G! V( X
377.     padding_size = 0x800 - (ftell(inrbt_file) & 0x7FF);
     
378.     if (padding_size)
     5 S" f% m/ B% L
379.     {
     + B/ E* h- }4 [5 f- H3 X
380.         padding = malloc(padding_size);
     & I5 ^* o  A( B1 G& B1 j/ @
381.         if (fread(padding, padding_size, 1, inrbt_file) != 1)
       H7 x3 O. N+ R6 n/ E
382.         {
     
383.             printf("problem reading padding\n");
     ! u( f3 a* ?/ s) M9 v) M
384.             return 0;
     $ }  {# [. K4 m! C/ i8 v2 @2 L2 t
385.         }
     
386.         if (fwrite(padding, padding_size, 1, outrbt_file) != 1)
     * Q/ N/ @1 T, L, w6 L5 ]! Z; P
387.         {
     : u3 \5 Y7 q* r$ |; U# v; B
388.             printf("problem writing padding\n");
     
389.             return 0;
     
390.         }
     6 R' k$ c& h/ c1 d/ D6 p. W/ Z) U
391.         free(padding);
     
392.     }
     , I& I7 Z9 X6 k: D
393. 
     
394.     return 1;
     $ h7 R/ j7 K  a/ ?6 {! `, G
395. }
     ) _4 k# c3 M8 @3 l2 K
396. 
     " B# s) n5 ^/ y' S. v' H
397. static int get_lzs_back_ref_length(get_bits_context *gb)
     / T& i" W7 s/ r* K
398. {
     1 v: W: A6 q' i! v5 H+ Y2 u' x
399.     int vlc;
     ' N* L+ l0 s$ L# q) T' D( e8 b
400.     int count;
     
401.     int value;
     8 w+ K% f) ~$ u" O
402. 
     
403.     vlc = view_bits(gb, VLC_SIZE);
     
404.     count = lzs_vlc_table[vlc].count;
     
405.     value = lzs_vlc_table[vlc].value;
     
406. 
     3 t3 x+ q& B4 [. f
407.     read_bits(gb, count);
     
408.     if (value == 8)
     $ Z: t; O) B2 @' I" P6 Q* d
409.     {
     * F6 N" k, Y4 }% M7 j. F
410.         do
     " u7 S2 G2 S2 N+ Z2 W
411.         {
     
412.             vlc = read_bits(gb, VLC_SIZE);
     & p9 u( t* B3 p
413.             value += vlc;
     # K' u9 Q: S3 k; A) f# n9 E
414.         }
     ' Q& [$ {$ Q/ y
415.         while (vlc == 0xF);
     
416.     }
     
417. 
     9 |6 y& ?, t0 C4 z3 ]$ {: s; w2 `
418.     return value;
     ) w+ U# ~/ R" Y$ S
419. }
     
420. 
     
421. static void compress_window(put_bits_context *pb, uint8_t *full_window,
     
422.     int full_window_stride,
     - A1 a0 S5 }7 Y5 ^: m7 O
423.     int window_top, int window_bottom, int window_left, int window_right)
     & `. M$ a' A# K
424. {
     
425.     int last_pixel;
     $ G! Y. t3 @" E
426.     int run_size;
     7 d- g4 j/ |9 E$ O) b: \& s- L
427.     int x;
     6 K4 \- m/ {) l2 K
428.     int y;
     
429.     int start_index;
     ) b5 f) S0 v: y% H- n) S4 V+ z
430.     int end_index;
     ( H" d3 G. @) S- m
431.     int encode_last_run;
     
432. 
     
433.     last_pixel = full_window[0];
     
434.     run_size = 1;
     
435.     for (y = window_top; y <= window_bottom; y++)
     6 F3 L. e& D- v/ J; R; t0 L
436.     {
     2 z/ t9 Y4 A0 D
437.         start_index = y * full_window_stride + window_left;
     
438.         if (y == window_top)
     4 ~9 q# b  O/ ?2 Y( ^$ J
439.             start_index += 1;
     
440.         end_index = y * full_window_stride + window_right;
     $ a$ q5 ]: n+ u! {% Q6 O( ~' }
441.         if (y == window_bottom)
     
442.             encode_last_run = 1;
     9 ^+ ?% d( f; Q, }9 a
443.         else
     0 G4 U" L' Q. R; F: g/ `2 N3 m
444.             encode_last_run = 0;
     7 T' k! o% o* V( L
445.         for (x = start_index; x < end_index; x++)
     
446.         {
     
447.             if (!encode_last_run && full_window[x] == last_pixel)
     
448.                 run_size++;
     $ f1 g, Y, ^8 \8 [0 P& G
449.             else
     * J. D# w$ M, _: \
450.             {
     + B( G2 W$ p! z! Q3 Q; N
451.                 if (run_size == 1)
     * T0 u4 ^& A+ W2 p! p! r6 ^4 i
452.                 {
     $ {3 o# r5 a0 \% s: X9 d
453.                     /* encode a 0 bit followed by raw pixel byte */
     9 t( D& ~' K; |& s$ P
454.                     put_bits(pb, 0, 1);
     ! a. R  W- D0 t1 T. D8 m- l+ a  ?
455.                     put_bits(pb, last_pixel, 8);
     
456.                 }
     9 u+ G9 g0 ^5 s4 t0 Q; f
457.                 else if (run_size == 2)
     
458.                 {
     ) x, ]6 T+ b6 E& \) V' g
459.                     /* encode a 0 bit followed by raw pixel byte */
     
460.                     put_bits(pb, 0, 1);
     
461.                     put_bits(pb, last_pixel, 8);
     % [; K; Z# P9 \/ F: U
462.                     put_bits(pb, 0, 1);
     : a9 v9 d+ Z' J9 [% M0 {
463.                     put_bits(pb, last_pixel, 8);
     ; O, e4 i) A# l5 }8 ?5 x4 [
464.                 }
     / `) j5 S3 G# E
465.                 else
     1 p  P' g2 y. M4 z4 Q5 ?8 A3 G( W2 J
466.                 {
     / i( N1 ^# b3 i
467.                     /* encode a 0 bit followed by raw pixel byte */
     
468.                     put_bits(pb, 0, 1);
     
469.                     put_bits(pb, last_pixel, 8);
     
470.                     run_size--;
     ; l, B$ {; `. M
471.                     /* encode a run: a 1 bit, followed by a back reference
     
472.                      * offset (-1), followed by a length */
     
473.                     put_bits(pb, 1, 1);
     
474.                     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     . l9 }. F: D1 w; K
475.                     put_bits(pb, 1, 7);
     8 g( S8 Y# K% D* f3 b# y
476.                     if (run_size <= 4)
     
477.                     {
     0 l4 y% |! s! G$ s0 @' c
478.                         /* lengths 2, 3, and 4 are 2 bits */
     0 M6 D! _7 N4 j' q( u; s8 k4 t
479.                         put_bits(pb, run_size - 2, 2);
     
480.                     }
     5 v* `# ?0 }7 |$ a. V6 K
481.                     else if (run_size <= 7)
     6 p) z8 H: u, `" h& z
482.                     {
     , s3 z" v# H% C- q$ L
483.                         /* lengths 5, 6, and 7 are 4 bits */
     4 `, u. L/ d& Q6 Z# e
484.                         put_bits(pb, run_size + 7, 4);
     0 O8 m# q( T# f! B/ @0 S
485.                     }
     9 l0 L# I0 H. q! E7 Q) W( _4 H
486.                     else
     - t0 s: i2 f/ \' Z
487.                     {
     
488.                         /* arbitrary length; start by encoding 0xF which
     
489.                          * stands in for an initial version of 8 */
     % `" A" q6 K8 N% Z. W( }
490.                         put_bits(pb, 0xF, 4);
     
491.                         run_size -= 8;
     
492. 
     . R/ P/ m5 {& L# G! h7 l* M8 ~6 J
493.                         /* encode blocks of 4 bits until run_size is 0 */
     
494.                         while (run_size >= 0)
     8 I) Q) H9 ~0 s. M. C3 q
495.                         {
     
496.                             if (run_size >= 15)
     
497.                             {
     
498.                                 put_bits(pb, 0xF, 4);
     
499.                                 run_size -= 0xF;
     
500.                             }
     
501.                             else
     
502.                             {
       d+ L) ]) N* F# p: q# S. A: ^- z. S
503.                                 put_bits(pb, run_size, 4);
     
504.                                 run_size = -1;
     
505.                             }
     3 \' J7 \* m& R* L# y/ {
506.                         }
     & L' H7 @  u1 X& k
507.                     }
       t0 D* I$ l4 n9 |. g) o$ g
508.                 }
     
509. 
     $ ^+ y: r0 ?; V4 s4 T) S* Z5 r" v( N; u
510.                 last_pixel = full_window[x];
     6 V3 @7 ?; o, U# n  M% n3 }+ B" z( J
511.                 run_size = 1;
     
512. 
     
513.                 /* this single x iteration was only here to close the final run */
     
514.                 if (y == window_bottom)
     
515.                     break;
     
516.             }
     
517.         }
     
518.     }
     
519. 
     
520.     /* close the bitstream by encoding a back reference with length 0 */
     
521.     put_bits(pb, 1, 1);  /* back reference run */
     ! x/ w% L( W' Z, {( f
522.     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     
523.     put_bits(pb, 0, 7);  /* length 0 */
     ) T) W, W* Y/ i( |1 q) W" q
524. 
     * J: R) k! q3 N! O0 O% G
525.     put_bits_flush(pb);
     
526. }
     7 k& Y3 s2 P. @' h- X8 a+ F& w
527. 
     2 @: x! t+ f0 ~# t7 j' J
528. /* compute Euclidean distance between an RGB color and the desired target */
     ; T+ f! |% w& N- q) ^& b
529. static int compute_rgb_distance(int r1, int r2, int g1, int g2, int b1, int b2)
     + V# t0 Z  r, D
530. {
     
531.     return sqrt((r1 - r2) * (r1 - r2) +
     7 v5 Q/ T3 f: y" I* t+ z: \+ n
532.                 (g1 - g2) * (g1 - g2) +
     
533.                 (b1 - b2) * (b1 - b2));
     
534. }
     ) }0 e6 E, [: T% l( {1 Y
535. 
     
536. static uint8_t find_nearest_color(rbt_dec_context *rbt, int r, int g, int b)
     
537. {
     
538.     int i;
     5 `2 B9 f4 s5 k, K- L
539.     int nearest_distance;
     
540.     int distance;
     ; Q' S. @! l- K$ ^
541.     int rp;
     : M1 V* p+ W2 s9 j% d9 J
542.     int gp;
     3 t# u6 R' V! X! I1 A
543.     int bp;
     . j, {: |6 S" Q: K5 ~
544.     uint8_t palette_index;
     
545. 
     
546.     nearest_distance = 999999999;
     - [( z/ ~! V0 `6 s2 y7 d! p9 k
547.     palette_index = 0;
     
548.     for (i = 0; i < 256; i++)
     1 E2 [" w& j1 D7 X) x
549.     {
     * s9 R0 V- n8 _5 {
550.         rp = rbt->palette[i * 3 + 0];
     + M5 C' D& w7 {) ^
551.         gp = rbt->palette[i * 3 + 1];
     
552.         bp = rbt->palette[i * 3 + 2];
     5 m* \9 g' W; K0 Y* c
553.         distance = compute_rgb_distance(r, rp, g, gp, b, bp);
     - X: \) C  y0 n3 P8 r
554.         if (distance < nearest_distance)
     
555.         {
     : T! X1 B8 c/ M( z7 M1 {7 i% P! T
556.             nearest_distance = distance;
     , _/ C+ L  T3 [7 g- }: j
557.             palette_index = i;
     
558.         }
     
559.         /* can't get closer than 0; break early */
     * c2 J) x" Y- x* c  n& Y: S: d% B
560.         if (distance == 0)
     
561.             break;
     8 k% {9 q7 M& V  l7 K  a
562.     }
     " \6 w5 @! O! K4 I/ _5 W& w
563. 
     
564.     return palette_index;
     / u. \" O1 G: M6 t4 f8 V' Z
565. }
     
566. 
     2 B- n8 Q0 b' g
567. static void subtitle_frame(rbt_dec_context *rbt, uint8_t *frame,
     
568.     int width, int height, int timestamp)
     
569. {
     
570.     ASS_Image *subtitles;
     
571.     int detect_change;
     
572.     uint8_t subtitle_pixel;
     
573.     int x, y;
     8 a# P6 O2 Z! z" x& B
574.     uint8_t *frame_ptr;
     
575.     uint8_t *subtitle_ptr;
     % X2 g  ]& C4 n8 B
576. 
     6 h* M: B% s3 c3 S
577.     /* ask library for the subtitle for this timestamp */
     
578.     subtitles = ass_render_frame(rbt->ass_renderer, rbt->ass_track,
     2 Q0 [& [5 A/ |5 U% S. e2 Y- f
579.         timestamp, &detect_change);
     % b. k$ ?: ]- {  K5 s2 M5 ^; O
580. 
     + J, D" C1 u( u9 D9 Y  V; c+ \  |4 @
581.     /* render the list of subtitles onto the decoded frame */
     
582.     while (subtitles)
     : _5 s, ?  B: c  V, i9 O7 H
583.     {
     & T7 }& B$ J3 u0 C! R5 ?
584.         /* palette components are only 6 bits, so shift an extra 2
     
585.          * bits off each component */
     6 P% l/ r  n: k$ s  _
586.         subtitle_pixel = find_nearest_color(rbt,
     
587.             (subtitles->color >> 10) & 0xFF,
     
588.             (subtitles->color >> 18) & 0xFF,
     
589.             (subtitles->color >> 26) & 0xFF);
     ; Y8 t& X2 b/ E! {8 Q
590.         for (y = 0; y < subtitles->h; y++)
     ) t" m! T- R9 R+ d$ ~
591.         {
     : @1 k  i4 B8 ?+ y7 m! |
592.             subtitle_ptr = &subtitles->bitmap[y * subtitles->stride];
     
593.             frame_ptr = &frame[(subtitles->dst_y + y) * width + subtitles->dst_x];
     ) r, w; ~3 K& W! Z2 P: o. @3 f
594.             for (x = 0; x < subtitles->w; x++, frame_ptr++, subtitle_ptr++)
     
595.             {
     / q- d! u9 i2 p5 z; y2 H
596.                 if (*subtitle_ptr >= SUBTITLE_THRESHOLD)
     3 }1 t; z$ }, j. s
597.                     *frame_ptr = subtitle_pixel;
     
598.             }
     ' X: B, x/ h0 `
599.         }
     0 H: @# h$ U( o+ E$ ]# ^9 X
600.         subtitles = subtitles->next;
     
601.     }
     " _/ F. _! J4 W% h) [2 {
602. }
     
603. 
     
604. static int copy_frames(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file,
     
605.     int origin_x, int origin_y, int window_width, int window_height)
     9 _* g+ e/ d; }% P6 s+ ~7 k
606. {
     & F* F" ]6 E' F9 h; P- b3 W
607.     int i;
     
608.     int j;
     
609.     int scale;
     
610.     int width;
     ; B  o3 m2 ~; `/ J" {, D
611.     int height;
     
612.     int max_width;
     
613.     int max_height;
     
614.     int frame_x;
     
615.     int frame_y;
     + t# R, v1 }0 d
616.     int fragment_count;
       O! T7 w/ J" d2 k8 X/ j
617.     int decoded_size;
     
618.     uint8_t *decoded_frame;
     
619.     int fragment;
     6 R5 d4 ^/ c5 a; w
620.     int fragment_compressed_size;
     
621.     int fragment_decompressed_size;
     4 a6 l- C2 l8 h6 i8 V) o
622.     int compression_type;
     
623.     int index;
     
624.     int out_index;
     
625.     get_bits_context gb;
     
626.     int frame_size;
     
627.     int video_frame_size;
     
628.     int audio_frame_size;
     
629. 
     . c% Z3 H% E7 T
630.     int back_ref_offset_type;
     6 u# R5 N4 P2 Q# N) |
631.     int back_ref_offset;
     & J7 Z9 q2 a! C$ [2 V" m2 o: q
632.     int back_ref_length;
     + d  H. N6 R( C- X" _
633.     int back_ref_start;
     5 d- n% n+ \2 w/ N! }+ \
634.     int back_ref_end;
     # {! b& c, t  D4 I  m" W" f. Q6 R
635. 
     
636.     uint8_t *full_window;
     
637.     int full_window_size;
     ! f: Q. C: r% K1 ?$ Q7 Y( Y" n+ Q
638.     int y;
     
639.     int window_top;
     $ m" v* D) o5 d* V: {' ~/ c2 n
640.     int window_bottom;
     ! H2 w6 q7 a4 ?& d
641.     int window_left;
     
642.     int window_right;
     
643.     int window_size;
     
644. 
     - q5 Y# M! C) t
645.     char filename[30];
     6 a2 T: J9 O5 T+ ], b, B1 M: f
646. 
     ! t4 `3 l! y# [- @. i) B0 [
647.     put_bits_context *pb;
     
648. 
     ( X9 I/ b& {% K0 i% |
649.     full_window_size = window_width * window_height;
     
650.     full_window = malloc(full_window_size);
     # l% V3 g! i% z' v) ^
651.     pb = init_put_bits();
     $ _/ N* ~# u$ ~, ]" f7 V% h
652. 
     
653.     max_width = 0;
       S2 z  Z7 p6 s9 t- G
654.     max_height = 0;
     9 ?3 P! U( W4 p8 `6 h  @: F
655. 
     
656.     for (i = 0; i < rbt->frame_count; i++)
     0 w7 @2 P) y0 e2 g  D( Y
657.     {
     
658.         /* read the entire frame (includes audio and video) */
     
659.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     $ R6 I* R! V- x7 p- L6 a) k4 {4 `
660.         video_frame_size = LE_16(&rbt->video_frame_size_table[i*2]);
       z6 z8 z3 h) U$ Y* e. _: Q0 y* r
661.         audio_frame_size = frame_size - video_frame_size;
     
662.         if (fread(rbt->frame_load_buffer, frame_size, 1, inrbt_file) != 1)
     
663.         {
     
664.             printf("problem reading frame %d\n", i);
     
665.             return 0;
     4 [  V$ t5 [" o
666.         }
     
667. 
     
668.         scale = rbt->frame_load_buffer[3];
     8 G/ m# x! |0 K, @( v7 b8 A
669.         width = LE_16(&rbt->frame_load_buffer[4]);
     
670.         if (max_width < width)
     
671.             max_width = width;
     
672.         if (max_height < height)
     
673.             max_height = height;
     7 \- W9 p7 p5 W  i! i( H8 }
674.         height = LE_16(&rbt->frame_load_buffer[6]);
     
675.         frame_x = LE_16(&rbt->frame_load_buffer[12]);
     % M7 W) m2 O" P: e9 x/ z
676.         frame_y = LE_16(&rbt->frame_load_buffer[14]);
     ! W+ |% ?0 @( W% V
677.         fragment_count = LE_16(&rbt->frame_load_buffer[18]);
     
678.         decoded_size = width * height;
     # U+ h$ J! D& f! z7 v5 M9 G
679. 
     
680.         printf("processing frame %d: %d%%, %dx%d, origin @ (%d, %d), %d fragments\n", i, scale, width, height, frame_x, frame_y, fragment_count);
     
681. 
     
682.         /* decode the frame */
     
683.         decoded_frame = malloc(decoded_size);
     
684.         index = 24;
     ) j) Y( w- y+ m" y+ F3 D/ ^
685.         out_index = 0;
     
686.         for (fragment = 0; fragment < fragment_count; fragment++)
     
687.         {
     
688.             fragment_compressed_size = LE_32(&rbt->frame_load_buffer[index]);
     
689.             index += 4;
     
690.             fragment_decompressed_size = LE_32(&rbt->frame_load_buffer[index]);
     1 W. D7 B$ h. e9 L
691.             index += 4;
     3 u& c- X5 K; V# s+ F) v
692.             compression_type = LE_16(&rbt->frame_load_buffer[index]);
     4 }! c# k$ N( F5 b3 I8 b* I
693.             index += 2;
     
694. 
     
695.             if (compression_type == 0)
     " C! S* l3 @. x" `; D
696.             {
     0 e+ v' j# t# s; T$ E- r
697.                 init_get_bits(&gb, &rbt->frame_load_buffer[index],
     " i; k& e# g0 g7 Q% B& b. T
698.                     fragment_compressed_size);
     
699. 
     6 ]! a2 Y- u  r1 Q! y5 Z
700.                 while (out_index < fragment_decompressed_size)
     
701.                 {
     7 m9 K4 @- ]8 r8 j7 q  d, @; u
702.                     if (read_bits(&gb, 1))
     
703.                     {
     % ~5 F6 d7 l! Z5 C4 S
704.                         /* decode back reference offset type */
     ; n0 c4 Q9 x. A  L  q
705.                         back_ref_offset_type = read_bits(&gb, 1);
     
706. 
     
707.                         /* back reference offset is 7 or 11 bits */
     
708.                         back_ref_offset = read_bits(&gb,
     
709.                             (back_ref_offset_type) ? 7 : 11);
     
710. 
     
711.                         /* get the length of the back reference */
     8 k4 |% c$ I& N
712.                         back_ref_length = get_lzs_back_ref_length(&gb);
     ! D) ^3 s: V5 \  ^3 X, p9 T
713.                         back_ref_start = out_index - back_ref_offset;
     1 v2 b$ ^- h  \# |
714.                         back_ref_end = back_ref_start + back_ref_length;
     
715. 
     
716.                         /* copy the back reference, byte by byte */
     + ^! I+ Z& I0 @! Q& |
717.                         for (j = back_ref_start; j < back_ref_end; j++)
     
718.                             decoded_frame[out_index++] = decoded_frame[j];
     
719.                     }
     & U0 u- Q% a# u; s  [/ {; @
720.                     else
     
721.                     {
     
722.                         /* read raw pixel byte */
     
723.                         decoded_frame[out_index++] = read_bits(&gb, 8) & 0xFF;
     : K3 g& P# `9 U5 o5 Q' A
724.                     }
     $ E$ u5 ^$ I7 \! D2 z7 p: }# U# t
725.                 }
     - s, a7 e: m4 c
726. 
     8 e: m+ P2 H* Y# [  d
727.                 delete_get_bits(&gb);
     $ @, w- B/ ^6 I6 g1 ~1 N0 P
728.             }
     2 \* T3 }- d3 _
729. 
     
730.             /* next fragment */
     % e' _# N7 m4 |  b
731.             index += fragment_compressed_size;
     
732.         }
     
733. 
     4 Q- b* X1 O; p, p& F& t& a- e
734.         if (rbt->dump_frames)
     
735.         {
     
736.             /* dump the original frame */
     / d. a5 [5 M' X: [7 _
737.             sprintf(filename, "original-frame-%03d.pnm", i);
     
738.             dump_pnm_file(filename, rbt, decoded_frame, width, height);
     2 o& l. _% K+ u& V. ?
739.         }
     5 n1 l4 e1 p1 w- u- }: {! t4 q
740. 
     
741.         /* transfer the image onto the frame window */
     
742.         memset(full_window, 0xFF, full_window_size);
     
743.         index = 0;
     ) ~/ o9 G/ f% p
744.         for (y = 0; y < height; y++)
     
745.         {
     # u- e6 f* j6 t7 A: b
746.             out_index = window_width * (frame_y + y) + frame_x;
     
747.             memcpy(&full_window[out_index], &decoded_frame[index], width);
     ; d/ U, v0 p* J2 p2 @8 V* m' y0 V0 m
748.             index += width;
     6 k; h8 n/ S/ \% v# q7 U! f
749.         }
     : |6 L5 i6 n& S$ ^% }
750. 
     
751.         /* write the subtitle */
     8 B; S/ O9 s- W( [0 G4 Z7 W
752.         subtitle_frame(rbt, full_window, window_width, window_height,
     ) R0 c/ j# o  U9 c7 P
753.             i * MILLISECONDS_PER_FRAME);
     
754. 
     
755.         /* figure out the smallest change window */
     . K: F4 O) Y; s! i
756.         window_top = frame_y;
     3 ^/ w1 i, O7 l5 @5 h
757.         window_bottom = window_height;
     
758.         window_left = 0;
     
759.         window_right = window_width;
     
760.         window_size = (window_right - window_left) * (window_bottom - window_top);
     
761. 
     
762.         /* compress the frame */
     ' `) F2 e' p' q6 \8 U
763.         reset_put_bits(pb);
     + [6 f5 O- L( q) [
764.         compress_window(pb, full_window, window_width, window_top,
     
765.             window_bottom, window_left, window_right);
     
766. 
     ' C2 ]6 V" b% i5 t; N4 [
767.         if (rbt->dump_frames)
     ' C9 u: D5 j: I0 k
768.         {
     
769.             /* dump the frame plotted onto the full window prior to encoding,
     ' j9 [* }% W! V& i1 ?
770.              * with subtitle */
       ~( G) d+ u+ ]5 ]7 ?6 A
771.             sprintf(filename, "pre-encoding-frame-%03d.pnm", i);
     
772.             dump_pnm_file(filename, rbt, full_window, window_width, window_height);
     
773.         }
     
774. 
     5 ]' d5 y1 o8 l6 H8 M' O
775.         free(decoded_frame);
     4 E7 j& ?- L' {2 H# R
776. 
     8 T  h$ `8 i0 O5 [/ V! K6 a1 p
777.         /* update the frame header */
     
778.         /* width */
     
779.         rbt->frame_load_buffer[4] = (window_right - window_left) & 0xFF;
     
780.         rbt->frame_load_buffer[5] = (window_right - window_left) >> 8;
     
781.         /* height */
     
782.         rbt->frame_load_buffer[6] = (window_bottom - window_top) & 0xFF;
     
783.         rbt->frame_load_buffer[7] = (window_bottom - window_top) >> 8;
     / _$ T1 b. h! Z* g9 F2 E% z0 {
784.         /* origin X */
     
785.         rbt->frame_load_buffer[12] = window_left & 0xFF;
     & z$ w; Q( x. s# Z
786.         rbt->frame_load_buffer[13] = window_left >> 8;
     4 d9 Y* R! k. N; y3 x# _( ~
787.         /* origin Y */
     . ~% k% E: J( P3 Y& z* E, ~
788.         rbt->frame_load_buffer[14] = window_top & 0xFF;
     8 [0 p, d) d( N: L4 z! `
789.         rbt->frame_load_buffer[15] = window_top >> 8;
     ( t+ W8 ?1 N! j8 S4 K; y
790.         /* fragment payload size */
     
791.         rbt->frame_load_buffer[16] = (pb->byte_index + 10) & 0xFF;
     ! X- Z: c+ C- V1 n
792.         rbt->frame_load_buffer[17] = (pb->byte_index + 10) >> 8;
     
793.         /* fragment count (1) */
     
794.         rbt->frame_load_buffer[18] = 1;
     
795.         rbt->frame_load_buffer[19] = 0;
     6 I. S9 [: Q0 j
796. 
     / C. Q, g' k7 o8 M1 j2 U6 |
797.         /* update the fragment header */
     
798.         /* compressed size */
     / S( F  f/ F7 _9 B0 U
799.         rbt->frame_load_buffer[24 + 0] = (pb->byte_index >>  0) & 0xFF;
     
800.         rbt->frame_load_buffer[24 + 1] = (pb->byte_index >>  8) & 0xFF;
     
801.         rbt->frame_load_buffer[24 + 2] = (pb->byte_index >> 16) & 0xFF;
     
802.         rbt->frame_load_buffer[24 + 3] = (pb->byte_index >> 24) & 0xFF;
     
803.         /* decompressed size */
     , N; a1 ?- b3 r1 n! J
804.         rbt->frame_load_buffer[24 + 4] = (window_size >>  0) & 0xFF;
     
805.         rbt->frame_load_buffer[24 + 5] = (window_size >>  8) & 0xFF;
     
806.         rbt->frame_load_buffer[24 + 6] = (window_size >> 16) & 0xFF;
     * h0 ]* j: L* w) K- N
807.         rbt->frame_load_buffer[24 + 7] = (window_size >> 24) & 0xFF;
     ! Z# H3 F7 E0 n8 c: S6 R" m8 L
808.         /* compression format 0 */
     ' S2 ^8 e# z8 W, A
809.         rbt->frame_load_buffer[24 + 8] = 0;
     
810.         rbt->frame_load_buffer[24 + 9] = 0;
     
811. 
       b! Z& T* M7 H  z% A
812.         /* write the 24-byte frame header and the 10-byte fragment header */
     
813.         if (fwrite(rbt->frame_load_buffer, 24 + 10, 1, outrbt_file) != 1)
     
814.         {
     ; Y' n! f2 m7 X/ t' G
815.             printf("problem writing frame %d\n", i);
     - w( [: S4 S& g2 Y
816.             return 0;
     7 Q* y1 X. V1 P5 g: T' y, _
817.         }
     8 g5 R7 K( f" R5 [
818. 
     8 U4 k) i- d+ e) G4 \
819.         /* write the new compressed frame data */
     # s9 ]0 y0 p! {6 _2 t! `
820.         if (fwrite(pb->bytes, pb->byte_index, 1, outrbt_file) != 1)
     
821.         {
     
822.             printf("problem writing frame %d\n", i);
     
823.             return 0;
     6 d9 f% D& R; k
824.         }
     
825. 
     ; M8 E# ^+ V3 e& w5 m# @7 g  R
826.         /* write the audio data */
     & p- w" v1 y% @+ N% a* Z5 R
827.         if (fwrite(&rbt->frame_load_buffer[video_frame_size], frame_size - video_frame_size, 1, outrbt_file) != 1)
     
828.         {
     
829.             printf("problem writing frame %d\n", i);
     . |, T+ u6 A- H% M
830.             return 0;
     2 E  t- T4 H8 w  o. r( K( l$ \: P; b
831.         }
     
832. 
     % P. Q3 T( \- y- |! _
833.         /* update the table entries */
     
834.         video_frame_size = pb->byte_index + 24 + 10;
     
835.         frame_size = video_frame_size + audio_frame_size;
     5 L% u( S$ G* @$ q' T) E
836.         rbt->frame_size_table[i*2+0] = frame_size & 0xFF;
     
837.         rbt->frame_size_table[i*2+1] = frame_size >> 8;
     % w; a6 j* `7 n2 r; w8 E- F
838.         rbt->video_frame_size_table[i*2+0] = video_frame_size & 0xFF;
     - _* w- h( h  s3 y0 T  d8 }3 R9 n
839.         rbt->video_frame_size_table[i*2+1] = video_frame_size >> 8;
     ( c9 s/ x( |, d$ A# C
840.     }
     . E; T: Y) j: ^  _
841. 
     
842.     printf("maximum dimensions seen are %dx%d\n", max_width, max_height);
     
843. 
     
844.     delete_put_bits(pb);
     
845.     free(full_window);
     
846. 
     
847.     return 1;
     : y0 T$ e6 t0 p+ o/ A* t
848. }
     
849. 
     
850. int main(int argc, char *argv[])
     1 R5 C1 J  e& w% k' m8 x8 ~
851. {
     . X+ ^  N# [3 i' G" z
852.     char *subtitle_filename;
     , G7 U; j+ B1 }9 G0 O4 B# S
853.     FILE *subtitle_file;
     - e5 Q( ^7 Y3 Z6 `- N8 c: {; k! I8 f1 _
854.     char *inrbt_filename;
     & \3 n1 K2 _& u/ r; J3 V; f5 Z& [5 V
855.     FILE *inrbt_file;
     
856.     char *outrbt_filename;
     
857.     FILE *outrbt_file;
     9 [* \$ R1 }# [! u4 j
858.     rbt_dec_context rbt;
     
859.     int origin_x;
     ! }) ?- g8 C# ^8 Z
860.     int origin_y;
     8 x; X( K' |7 S/ s+ z2 j
861.     int window_width;
     
862.     int window_height;
     6 a. t- f/ r+ E3 t+ F2 T% G! T
863. 
     
864.     /* testing the bit functions */
     
865. #if 0
     & B+ F" L$ c& }
866.     int i;
     $ H& b# m  d% j: C: _) Y# z
867.     uint8_t bytestream[] = { 0x55, 0xAA, 0x00, 0xAA, 0x55, 0x77, 0xFF, 0x1B, 0x70, 0x8F };
     - f& g* [% @! }5 v& O1 G  s
868.     int bytestream_size = 10;
     
869.     get_bits_context gb;
     / F# \" o, E! V) d! p$ ~  W7 X& r
870.     put_bits_context *pb;
     
871.     int bits;
     
872. 
     
873.     init_get_bits(&gb, bytestream, bytestream_size);
     2 N4 B6 g0 E/ |9 J
874.     pb = init_put_bits();
     3 c6 M7 N6 C! O0 k1 {7 s  ~
875. 
     $ b  B6 G$ X6 K
876.     for (i = 1; i <= 12; i++)
     , T& ~" l" F! V- ]5 U6 s$ W
877.     {
     
878.         bits = view_bits(&gb, i);
     
879.         printf("view %d bits: %d\n", i, bits);
     6 d: @8 y4 x* Q: @! A% t0 Q- _" y
880.         printf("read %d bits: %d\n", i, read_bits(&gb, i));
       O; ]$ {: T; W) u
881.         put_bits(pb, bits, i);
     
882.     }
     
883.     put_bits_flush(pb);
     
884. 
     
885.     printf("original bytestream:\n");
     
886.     for (i = 0; i < bytestream_size; i++)
     
887.         printf(" %02X", bytestream[i]);
     
888.     printf("\nnewbytestream:\n");
     
889.     for (i = 0; i < pb->byte_index; i++)
     % R4 I. o8 Z2 L7 X5 a7 j  ?
890.         printf(" %02X", pb->bytes[i]);
     * _# Q  b* D. C" [: p' G+ H
891.     printf("\n");
     0 t  P4 T! H) `
892. 
     7 E* [; v. g* ^3 V8 g, [
893.     delete_get_bits(&gb);
     
894.     free(pb);
     
895. #endif
     1 M0 H- r0 f+ Z; w
896. 
     ! X/ n% i9 m& z/ L
897.     /* validate the number of arguments */
     7 E: g/ h9 h0 b  k7 V3 h1 m8 W. ^3 y
898.     if (argc != 8 && argc != 9)
     
899.     {
     % k$ m8 P: \" q0 a6 K
900.         printf("USAGE: subtitle-rbt <subtitles.ass> <in.rbt> <out.rbt> <origin X> <origin Y> <width> <height> [dump_frames]\n");
     . b9 y  A6 q0 ]# Z3 L
901.         return 1;
     " {$ v+ A/ I8 T  x4 x% P7 _" l/ `
902.     }
     9 m2 M9 O4 S1 ]4 Q/ q
903.     subtitle_filename = argv[1];
     
904.     inrbt_filename = argv[2];
     4 Y. \8 h4 H- Y
905.     outrbt_filename = argv[3];
     : n, L5 h0 h/ V" F
906.     origin_x = atoi(argv[4]);
     5 N/ r! h' A6 w# T5 `2 B
907.     origin_y = atoi(argv[5]);
     # i2 z: Y: ~2 j' v" C8 X
908.     window_width = atoi(argv[6]);
     
909.     window_height = atoi(argv[7]);
     0 N5 @; C% R3 ^2 ^7 Q! s. h$ y* a
910.     rbt.dump_frames = 0;
     
911.     if (argc == 9)
     
912.         rbt.dump_frames = 1;
     - F: W' U: M0 U4 b$ Y8 b* d
913. 
     + P. A, D7 }! W8 D
914.     /* verify that the specified input files are valid */
     
915.     subtitle_file = fopen(subtitle_filename, "r");
     
916.     if (!subtitle_file)
     
917.     {
     
918.         perror(subtitle_filename);
     
919.         return 1;
     
920.     }
     7 S/ P  {2 F$ X, Z6 f& R  F
921.     fclose(subtitle_file);
     / L/ \. T1 \+ X0 @( }
922.     inrbt_file = fopen(inrbt_filename, "rb");
       f" ~! ~3 s& t; F' f
923.     if (!inrbt_file)
     
924.     {
     
925.         perror(inrbt_filename);
     , m6 x1 ~" w. Y/ @* B
926.         return 1;
     . f3 L7 p' l; U+ o8 y1 d4 b
927.     }
     1 P- |: J1 o5 I; [  e
928. 
     $ ?9 \) H6 U8 R9 h& ?+ C, r
929.     /* initialize the subtitle support */
     8 X" D4 i, W% `: n2 Y% }3 L
930.     rbt.ass_lib = ass_library_init();
     
931.     rbt.ass_renderer = ass_renderer_init(rbt.ass_lib);
     
932.     rbt.ass_track = ass_read_file(rbt.ass_lib, subtitle_filename, "UTF-8");
     0 n' C8 l) t9 s% E( Q
933.     ass_set_frame_size(rbt.ass_renderer, window_width, window_height);
     
934.     ass_set_fonts(rbt.ass_renderer, NULL, NULL, 1, NULL, 1);
     
935. 
     7 k) B  K" r" n: ]
936.     /* open the output file */
     # N+ e: L1 Z8 k, Q: u: N
937.     outrbt_file = fopen(outrbt_filename, "wb");
     ; C6 ]  Q% ?& m+ Q0 r6 f6 q
938.     if (!outrbt_file)
     
939.     {
     
940.         perror(outrbt_filename);
     
941.         return 1;
     & q0 v4 L" r5 I" y* a$ ?
942.     }
     
943. 
     % Y8 d$ ~  H! s. ?
944.     /* transfer header from input to output */
     $ ~8 N( V+ A; w7 M
945.     if (!load_and_copy_rbt_header(&rbt, inrbt_file, outrbt_file))
     0 ~" m; s  v2 f- p) r
946.         return 1;
     
947. 
     
948.     /* rewrite the frames */
     
949.     if (!copy_frames(&rbt, inrbt_file, outrbt_file, origin_x, origin_y,
     $ G; ^  s5 y, ^* s& v4 Z9 A
950.         window_width, window_height))
     
951.         return 1;
     7 t1 O1 F8 e* ?7 x7 B, A" u; t
952. 
     
953.     /* write the modified frame size tables back to the file */
     
954.     fseek(outrbt_file, rbt.video_frame_size_table_offset, SEEK_SET);
     - d1 C( c" F$ M$ ]. y% Y
955.     fwrite(rbt.video_frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     * k$ r. `: \9 S& M3 P
956.     fseek(outrbt_file, rbt.frame_size_table_offset, SEEK_SET);
     
957.     fwrite(rbt.frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     
958. 
     
959.     /* finished with files */
     5 L* q1 |: c  _  Z7 q* r2 X+ ?
960.     fclose(inrbt_file);
     
961.     fclose(outrbt_file);
     
962. 
     ' ~6 i* y! W4 m. p. F; m
963.     /* clean up subtitle library */
     
964.     ass_free_track(rbt.ass_track);
     
965.     ass_renderer_done(rbt.ass_renderer);
     
966.     ass_library_done(rbt.ass_lib);
     
967. 
     
968.     /* clean up */
     % M+ _$ E+ v! r
969.     free(rbt.frame_load_buffer);
     
970.     free(rbt.video_frame_size_table);
     ! [4 j; J: @+ a  ]
971.     free(rbt.frame_size_table);
     8 ]" F& H" ?! J5 g6 V2 t3 q/ G+ g- f/ {
972. 
     
973.     return 0;
     # F3 T/ C! `0 e  Z4 j
974. }

复制代码

& J& p5 t0 U9 N+ Q. A+ v7 q) k: k
* B, ~, T: F/ S+ w$ q
/ x4 g' D3 R/ R

soring123

这游戏有字幕吗？

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
这游戏有字幕吗？

好像没有字幕，我说的是给视频外挂字幕方式的汉化。
就像syberia2汉化版下面那行字一样。

soring123

我记得是没字幕的 比较麻烦 都是视频的

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
我记得是没字幕的 比较麻烦 都是视频的

: ?' H( r  z$ V8 A给视频外挂字幕方式汉化也许能行。
要结合dosbox和代理dll技术。

宿矢

求汉化啊！

shane007

顶上来